3.27.00

Changes

• Fixed false positives for TSAN in shared_ptr's ref counting when releasing the last count.
• Add eastl::atomic_raw_X which provides an API similar to that of eastl::atomic<T> but which can operate on non-atomic variables. This can be used as a last resort in situations where we're interested in specifying memory order semantics but cannot change the type of the variable to eastl::atomic<T> (for example due to having to cross established API boundaries which can't change). We have only added support to operate on integral and pointer types. See atomic_raw.h for details.
• Improvements to atomic pointer loads with memory_order_read_depends:
  • Implement it in terms of the relaxed loads by default so TSAN understands the load as an atomic load. This can be changed to use acquire semantics instead with a config property.
  • Instrument it as a __tsan_memory_order_consume load so TSAN doesn't flag address dependent loads as errors, that's the intention for the read_depends memory order.
• Add atomic<T>::acquire_fence for integral T, which is intended for optimal synchronization when doing reference counting through the atomic.
• Improve default hash function implementation for floating-point types to avoid frequent collisions
• Fix hashtable and intrusive_hashtable so begin() will early out when they are empty instead of iterating through the entire bucket array.
• Fix compilation errors in get<I>() for tuples with an empty tuple member.
• Deprecate tuple_element for volatile types to match the standard.
• Fix vector::push_back() inserting the wrong value with an element from the vector. The vector now constructs the new element before moving the internal array when growing the vector.
• Fix Issue where fixed_function would allocate when another fixed function with a smaller buffer was assigned to it. I.e. the following would lead to allocations

   eastl::fixed_function<8, void(void)> f1;
   eastl::fixed_function<16, void(void)> f2;
   f2 = f1

• Add new compile assert when attempting to store functor with too large of alignment into fixed_function (this previously incorrectly triggered an allocation instead of asserting)
• Fix TSAN issues related to concurrently writing to the global empty bucket array in our hashtable implementation.
• Added hardened library asserts for expected and optional.
• Allow for vector to have more than 0x80000000 elements without asserting.
• Add asserts to vector to verify we don't overflow size_type when inserting elements into it.
• Add support for bitflags and maskflags (see the new bonus/flags.h header).
• Tweak fixed_vector implementation to reset capacity to starting value when using a resize() function that provokes a move back to the initially buffered range.
• Add some new fixed_vector constructors to match vector.
• Tweak bitvector "this_type" to properly specify container to prevent invalid template matches (eg swap functions that match bitvectors with different container types).
• Add any() and all() member functions to bitvector.
• Deprecate array<T, N> having a default of N = 1. This makes array conformant to the standard and reduces potential confusion with deduction guides, such as:

   eastl::array a{1, 2, 3}; // omit template parameters from the type declaration, parameters deduced using type deduction guide.
   eastl::array<int> a{1, 2, 3}; // error: won't deduce N. Defaults to N=1.

• Add make_from_tuple<T>(tuple<Ts...>)
• Allocators may now have an optional construct(), with the same semantics as the standard's Allocator construct function. EASTL now uses this wherever an allocator may be used to construct an object of the allocator's type (ie. containers, shared_ptr, shared_array and fixed_swap).
  • Note, in implementing this functionality the type trait is_default_constructible_v<T> may now be invoked on more types. This may cause compilations failures due to a C++ language defect. The language defect is that type traits may fail because it's unclear whether a nested type should be treated as a complete type in some contexts. In particular, a nested type with non-static data member initialization causes eastl::is_default_constructible_v<> to evaluate to false on Clang & GCC. For more details see llvm bug report and the defect tracked by the C++ standards committee.
    As a workaround to the language defect, declare a default constructor explicitly, eg. MyType() noexcept = default;
• Fixed containers no longer overwrite the allocator name when an overflow allocator is specified.
• Added static asserts that containers don't have const elements. This isn't supported.
• Deprecate fixed_vector and list incorrectly default initializing their elements. New behaviour is to value initialize them.
• Deprecate find_as() with default hash and equality objects for hash_set, hash_multiset, fixed_hash_set, fixed_hash_multiset, intrusive_hash_set, intrusive_hash_multiset. Use heterogeneous comparison lookup instead. See the FAQ and Best Practices pages for explanation of these new overloads.
• Remove the C++20 requirement for bit manipulation functions, isnan() and lerp(). Relax the requirement to C++17 for safe integer comparison functions.
• Fix implementation of countl_zero() for unsigned 128 bit types.
• Fix bitset<eastl_uint128_t>::count() implementation.
• bit_width now has a return type of int, which matches the standard.
• Alias iterator tags to the standard when EASTL_STD_ITERATOR_CATEGORY_ENABLED and replace usages of EASTL_ITC_NS with eastl, as it's no longer required.
• Add SetAssertionFailureFunction that uses instruction pointer for assertion callback to handle exact location of assertion.
• Add constexpr specifier to eastl::late_constructed's ctor so that dynamic initializers don't get generated for global instances when optimization is disabled (e.g. for debug builds).
• Explicitly crash when invoking the call operator on an empty eastl::function instead of potentially letting it fall through and return garbage.
• Fix natvis implementation for eastl::span which broke on version 3.21.20.
• Improvements to variant<Ts...>
  • get<T>(variant<Ts...>) and get<size_t>(variant<Ts...>) will now assert / throw if the variant doesn't hold the requested alternative type.
  • Only enable visit(Visitor&&, Variants&&) / visit<Result>(Visitor&&, Variants&&) overloads per the standard, ie. the visitor has to be callable with the variants' alternative types for the visit overload to be enabled.
  • Reduce the size of variant<Ts...>; internally it no longer uses a pointer for dispatch to the alternative type.
  • Special member functions are now only enabled if all the alternative types support the operation.
  • Only enable trivial special member functions (copy and move constructor and assignment) if all the alternative types' equivalent function is trivial. The original logic checks whether the alternative types are trivially destructible, which would incorrectly enable trivial special member functions.
  • converting assignment (variant<Ts...>::operator=<T>(T&&)) now calls the assignment operator if the variant already holds the alternative type that is being assigned (per the standard).
  • removed the unnecessary check from emplace<I>(...) that the alternative type for I must be unique.
  • swap(variant<Ts...>&, variant<Ts...>&) is now implemented in terms of swap() and move construction rather than just move construction (per the standard).
  • Implement hash<variant<Ts...>>, including disabling the hash when the alternative types do not have a hash specialization.
• Add in_place_type<T> and in_place_index<size_t>. Remove in_place<T>, in_place<size_t>.
• Make many scoped_ptr<T>'s operations noexcept.
• Fix EASTL_THROW_OR_ASSERT so it is defined after EASTL_EXCEPTIONS_ENABLED.
• Improvements to optional<T>
  • Special member functions are now only enabled if the contained type T supports the operation.
  • Remove optional<T>(const T&), optional<T>(T&&) constructors (not a part of the standard).
  • Fix optional<T>(in_place_t, T, Args...) constructor so that it doesn't use list initialization.
  • Add converting copy and move constructors.
  • Conditionally make constructors implicit if the contained type is implicitly convertible.
• Fix is_nothrow_constructible to use intrinsic if available.
• Fix ring_buffer comparison functions (operator < and operator==).
• Fix eastl::biset so it compiles with C++14.
• Remove unnecessary std:: causing issues when compiling with C++14.
• Add eastl::includes to algorithm.h. This function evaluates if an ordered range is a subsequence of another (docs).
• Add expected (P0323). This is available in EASTL if C++17 or later is enabled.
• Add transparent_string_hash, for use in hash_map.
• Extend hash<T> specializations for strings with any allocator.
• Fix deque::set_allocator() assertion so that it will assert when non-empty.
• Add assertions to set_allocator() for vector, string, shared_array, map, set, hash_map, hash_set, tuple_vector. This validates that an allocation hasn't already been made when changing the allocator, otherwise memory will be leaked / deallocated from the incorrect allocator.
• Add support for C++14's heterogeneous comparison lookup (N3657), C++23's heterogeneous erasu...

3.21.23

Changes

• Removed use of sumbodules to break circular dependencies, use CMake's FetchContent instead.
• Removed generic definition of numeric_limits<>
• Removed EASTL_CUSTOM_FLOAT_CONSTANTS_REQUIRED & associated functionality
• Removed Internal::numeric_limits_base
• Added isnan to EASTL when compiled with C++20
• Added is_constant_evaluated
• Fixed midpoint to behave correctly when passed NaNs
• Add bounds checking assert for array<T, N>::operator[].
• Fixed fixed_vector move constructor with an explicit allocator parameter. It now works with move-only types.
• Add bit_and, bit_or, bit_xor, bit_not and owner_less<void> function objects.
• Use string builtins to improve codegen for string literals operations on string_view and string.
• span is now specialized for static extents so that it doesn't need to store the size at runtime.
• Fixed a bug where calling emplace, emplace_hint, or try_emplace on a string_hash_map would call the underlying hash_map implementation, which caused a crash when string_hash_map would try to free memory it didn't own.
• Consolidate implementations of CharTypeStringSearch/Find functions in char_traits.h.
• Minor optimization to CharTypeStringRSearch to reduce iteration loop count.
• Fix deque move assignment operator for move only and non-default constructible types.
• Added monadic operations and_then, transform and or_else for optional.
• Fixed value_or for r-value refs to optional.
• Various bitset fixes and improvements:
  • Replace bitset(uint32_t) with bitset(unsigned long long) which matches the standard and means that 64 bit integers can be correctly converted to a bitset. As a result from_uint32() and from_uint64() are now unnecessary (not deprecated).
  • Add to_ulong_checked() with the same behaviour as the standard, ie. throws or asserts if the target type cannot represent all the set bits.
  • Add an extension to the standard, as_uint<T>() / as_ulong(), cast to a unsigned integral that can represent the entire bitset. If the target type cannot represent the entire bitset, then issue a compile error (overload does not exist).
  • Fix implementation for word types smaller than 32 bit. Fixed logic in find_prev(), other iteration functions and conversion to/from bitset functions that did not work for such types.
  • No longer assume sizeof(word_type) == EA_PLATFORM_WORD_SIZE. eg. from_uint64() previously would not copy the entire value into a bitset<N, uint32_t> for N > 32.
  • Now compiles for a word type of unsigned long or unsigned long long where the type is not uint64_t.
  • Add an assert that the word type is an unsigned integral, as these are the only types that are supported and tested.
• Add get<T>(pair<T1, T2>). Make get<I>(pair<T1, T2>) constexpr.
• Fix variant non-member functions get_if(), get(), holds_alternative() and converting constructor and assignment so that they only conditionally compile when the index or type unambiguously refers to a variant alternative.
• any::emplace() now returns a reference.
• lru_cache::emplace() now compiles correctly, forwarding its arguments and returns an pair of iterator and bool indiciating emplace success.
• Made changes to avoid -Wdeprecated-copy-with-user-provided-copy, which manifests for the following reasons:
  • definition of implicit copy assignment operator for class is deprecated because it has a user-provided copy constructor
  • definition of implicit copy constructor for class is deprecated because it has a user-provided copy assignment operator
• Fix various issues with segmented_vector:
  • Fix copy/move construction/assignment so it doesn't do a shallow copy.
  • clear() now behaves like other eastl containers in that it does not free memory when called, the container maintains it's capacity.
  • segmented_vector now supports types which are not default constructible.
  • Added some missing API functions: reserve, resize, shrink_to_fit, emplace_back.
  • Added comparison operations.
• Add constructor overloads to map, set, hash_set, hash_map that take an initializer_list and Allocator.
• Enable some container asserts (when EASTL_ASSERT_ENABLED is enabled), removing the requirement for EASTL_EMPTY_REFERENCE_ASSERT_ENABLED. When called with invalid arguments these functions will result in undefined behaviour.
• Add some additional asserts to container adaptors.
• Fix undefined behaviour in shell_sort() algorithm.
• Add return values for deque, list, slists's member functions emplace_front(), emplace_back() and unique().
• Add slist::unique() function.
• Fix references to std library that should be eastl.
• Fix compilation issues when C4626 is enabled as error on MSVC.
• Optimize bitset's find_first(), find_next(), find_last(), find_prev() (which are extensions to the standard).
• Fix bitset<N, eastl_uint128_t>::find_last().gg
• Added erase_unordered and erase_unordered_if for vector and deque (fixed_vector works implicitly with the
  vector version since it is a vector with a special allocator and these functions don't affect capacity). These
  work similar to free function erase/erase_if but are more efficient if those would result in moving a lot of
  elements. They achieve this by not respecting the order of the remaining element and just moving the elements from
  the end into the now empty spots.
• optional::emplace now correctly returns T& instead of void as specified in the standard.
• Explicitly define special member functions for some types. This fixes new compile errors from Visual Studio 17.7.0 Preview.
• Fix function::target not compiling due to missing template parameter when we called into the base class' member function.

Deprecations:

• Use EA_DEPRECATED date based macros if available to guide deprecations.
• Deprecate vector_map<Key, T>::at(index). this function was accidentally inherited from vector with incorrect semantics.
• Deprecate make_pair_ref(), use make_pair() instead. deprecate a make_pair() overload which was only enabled on MSVC.
• Deprecate a make_pair() overload which was only enabled on MSVC.
• Deprecate stack::emplace_back(), use stack::emplace() instead.
• Deprecate uninitialized_copy_ptr et al - uninitialized_copy is already perfectly suitable for pointers.
• Deprecate unwrap_iterator, is_reverse_iterator, is_move_iterator, is_insert_iterator, generic_iterator (the last is internal and should already be unused).

PRs

• Declare C++14 as required for building by @uilianries in #509
• Update EABase submodule by @mtnpke in #504
• Fix ring_buffer comparation logic by @ChaiByte in #514
• Add MSVC support to initializer_list by @mtnpke in #503

New Contributors

• @ChaiByte made their first contribution in #514

3.21.12

This version of EASTL contains a number of improvements, including many bug fixes found through the use of undefined behaviour sanitizer (UBSan), as well as a swathe of deprecations.

Changes:

• Add return type / value for some deque::insert() overloads that were missing a return.
• Make deque::insert(position, first, last) compilable for input (single pass) iterators.
• Fix issues compiling when EASTL_SIZE_T_32BIT is set to 1.
• Add a const to an operator to comply with P2468R2.
• Remove explicit copy constructor/assignment from eastl::bitvector so we don't inhibit move constructor/assignment.
• Added a test to see that we can now move eastl::bitvector.
• Remove various unused variables from variant to remove warnings.
• Add vector_map<Key, T>::at_key() overloads as the inherited vector<pair<const Key, T>>::at() function doesn't have the correct semantics and returns the incorrect type (pair<const Key, T>& rather than T).
• Add hash_map natvis for key/value visualization.
• Add is_partitioned and partition_point to algorithms.h.
• Ensure n > 0 before calling memcmp() in char_trait's Compare() and lexicographical_compare() to avoid undefined behaviour.
• Ensure n > 0 before calling memmove() in copy_backward() or move_backward() to avoid undefined behaviour.
• Ensure first != last before calling memcpy() in uninitialized_relocate_start() (which is deprecated) to avoid undefined behaviour.
• Make tuple default constructible when an element type has no member types (which tuple has an empty base optimization for).
• Ensure n > 0 before calling memmove() in basic_string::assign(); flagged by UBSan.
• Remove user provided implementation of copy/move assignment operators for eastl::pair so it can be trivially copied if the template parameters are trivially copyable.
• Added printf format specifiers for use with eastl_size_t that work with both 32- and 64-bit sizes.
• UBSAN fixes. Remove some unecessary invalid casting in rb_tree.
• Change some tests to avoid doing nullptr arithmetic, which is undefined behaviour.
• Change random_shuffle so it doesn't overrun the iterator when first == last.
• Change tim_sort_buffer so it doesn't invoke undefined behaviour when called on empty vectors.
• Change radix_sort_impl so it doesn't over-right-shifts on it's last loop when trying to write to the histogram.
• Change shell_sort so it doesn't overrun the iterator in the loop increment expression.
• Use aligned allocations in EASTLTestAllocator to avoid allocating missaligned memory on platfroms require larger alignment restrictions for operator new.
• Make list_map_iterator::mpNode private and change its type to avoid various insances of undefined behaviour when downcasting the anchor node, which is has type list_map_data_base but isn't a list_map_data<T>. No replacement accessor has been provided as mpNode is an internal impelmentation detail that isn't useful for users.
• Make rbtree_iterator::mpNode private and change its type to avoid various insances of undefined behaviour when downcasting the anchor node, which is has type rbtree_node_base but isn't a rbtree_node<T>. No replacement accessor has been provided as mpNode is an internal impelmentation detail that isn't useful for users.
• Add natvis support for atomic<T>.
• Make intrusive_list_iterator::mpNode private and change its type to avoid various insances of undefined behaviour when downcasting the anchor node, which is has type intrusive_list_node but isn't a T. A helper function nodePtr() has been provided, which is equivalent to accessing the old member directly.
• Update is_pod's implementation on clang-cl to no longer use the compiler builtin __has_trivial_constructor that is deprecated in latest version of clang.
• Change the type of ListIterator<T>::mpNode from ListNode<T>* to ListNodeBase* to avoid various instances of undefined behaviour when downcasting the anchor node which is a ListNodeBase but not a ListNode<T>.
• Change the type of SListIterator<T>::mpNode from SListNode<T>* to SListNodeBase* to avoid various instances of undefined behaviour when downcasting the anchor node which is an SListNodeBase but not a SListNode<T>.
• Remove EASTL_LIST_PROXY_ENABLED, there's no configuration in which it is enabled and enabling it explicitly causes compile errors that we're not interested in fixing.
• extract_signature_from_callable compiler fix for C++14.
• Remove uses of compiler builtins that are deprecated in latest version of clang.
• Added hash function to eastl::fixed_string
• fix compile error for uninitialized_copy for trivially copyable types that are not assignable.
• Removed unqualified name lookup for invoke in apply to prevent any ambiguity with other invoke functions.
• Fixed warning about uninitialised base class in estl::optional copy constructor
• Added deduction guides for function.
• Re-add string_view symmetric comparisons (relational operators).
• Fix "#pragma warning(pop): likely mismatch, popping warning state pushed in different file" warning generated by atomic_push_compiler_optins.h header.
• Reduce vector_set, vector_multiset, vector_map and vector_multimap's size when the Compare template parameter is an empty class.
• Fix tuple_cat for calls with l-values and for calls with less than two arguments.
• Remove non-standard array<T, N> behaviour: array<T, 0> no longer has size() == 1. Deprecate count enumerator.
• rotate(), uninitialized_copy() + deque optimizations: apply memmove/memcopy optimizations using the correct type trait, is_trivially_copyable<T>.
• Add structured binding support for array<T, N>.
• Disable EXPECT_ASSERT for windows-clang when exceptions are disabled to fix compile break.

Deprecations:
The following deprecations will be removed approximately April 2024.

• Aligning with the standard:
  • EASTL_DECLARE macros - assert that the type trait is true instead of overriding EASTL's definition.
    Note: compile warnings / errors generated will be on the usage of the type declared to have the trait.
    The correct fix is to remove the EASTL_DECLARE usage, not the usage of the type itself.
  • add_(un)signed - use make_(un)signed instead.
  • identity - use type_identity(_t) instead.
  • equal_to_2, not_equal_to_2, less_2 - instead use equal_to<>, not_equal_to<> and less<> respectively.
  • unary_compose, binary_compose - use a lambda instead.
  • add_reference - use add_lvalue_reference(_t) instead.
  • is_array_of_(un)known_bounds - use is_(un)bounded_array.
  • type_select - use conditional.
  • type_and, type_or, type_equal, type_not_equal, type_not - use bool_constant<(expression)> instead.
  • identity - use type_identity instead.
  • has_trivial_constructor - use is_trivially_default_constructible instead.
  • has_trivial_copy - use is_trivially_copy_constructible instead.
  • has_trivial_assign - use is_trivially_assignable, is_trivially_move_assignable or is_trivially_copy_assignable instead.
  • has_trivial_destructor - use is_trivially_destructible instead.
  • has_trivial_relocate - use is_trivially_copyable instead.
  • has_nothrow_constructor - use is_nothrow_constructible instead.
  • has_nothrow_copy - use is_nothrow_copy_constructible instead.
  • has_nothrow_assign - use is_nothrow_assignable instead.
  • uninitialized_relocate_start, uninitialized_relocate_commit, uninitialized_relocate_abort, uninitialized_relocate - pre-C++11 functions that are replaced by move semantics.
  • Deprecate uninitialized_default_fill(_n) - use uninitialized_value_construct instead.
  • Deprecate const and volatile element types for vector, fixed_vector and deque.
• Improvements to the standard:
  • is_literal_type - use constexpr if to determine whether an expression is constant evaluated.
  • iterator - define typedefs without the use of inheritence.
  • result_of - use invoke_result instead.
  • get_temporary_buffer - unused part of the standard (citation).
  • unary_function, binary_function - no need to inherit from these types.
  • unary_negate, binary_negate - no need to inherit from these types: use not_fn or lambdas instead if necessary.
  • pointer_to_unary_function, pointer_to_binary_function - use mem_fn or a lambda instead.
  • mem_fun, mem_fun_ref - use mem_fn, mem_fn(ref()) or a lambda.
  • bind1st, bind2nd - use a lambda instead.
• Miscellaneous:
  • hashtable::equal_function() - use key_eq() instead.
  • hashtable::kAllocFlagBuckets - use kHashtableAllocFlagBuckets instead.
  • hashtable comparison operator (non equality) - shouldn't be comparing hashtables.
  • queue::emplace_back - use emplace instead.
  • safe_ptr::has_references - use has_unique_references instead.
  • slist::splice_after - use one of the other splice or splice_after overloads.
  • Deprecate is_lvalue_assignable. Its usage seems limited, and is_copy_assignable is probably the correct trait to use.

3.18.00

Welcome to the 3.18.00 release of EASTL. Thank you to everyone who's contributed to this release.

Feature additions and standard updates:

• Implemented eastl::bit_cast.
• Implemented eastl::is_nothrow_invocable.
• Implemented eastl::to_underlying.
• Implemented LWG defect 2106: move_iterator doesn't work with iterators which don't return a reference

Bugfixes:

• eastl::invoke fixes:

  • invoke now correctly deduces the function signature when invoking a member function or member data pointer on a reference_wrapper.
    Previously, this would fail if using arguments which were convertible to the correct type, but did not exactly match.
  • invoke now correctly forwards arguments when invoking a member data pointer.
  • invoke now correctly uses decay_t instead of remove_reference_t in a number of places.
  • invoke_result_t no longer uses decay_t on the type being invoked.
  • invoke is now constexpr.

• eastl::variant fixes:

  • Fixed incorrect results from some relational operators when valueless_by_exception() is true.
  • Fixed incorrect index when an exception is thrown during emplace().

• Removed assertions from some eastl::array functions in order to ensure usability in constexpr contexts.

• eastl::make_signed and eastl::make_unsigned now work correctly for enum types and volatile-qualified types.

• Containers which support find_as now support using it with keys of the same type as the container's key.

• Disallowed use of smart pointer default deleter on incomplete types.

• Fixed an issue where nodes for some data structures could be under-aligned.

• Properly supported arrays in eastl::cbegin() and eastl::cend().

• Fixed creation of zero-length spans and subspans.

• eastl::is_reference now returns true for rvalue references.

• Fixed a potential out-of-bounds memory access when sorting certain containers.

Optimizations:

• eastl::variant optimizations:
  • Avoided unnecessary double index checks in variant relational operators.
  • Avoided unnecessary work in valueless_by_exception() when exceptions are disabled.
  • Optimized visit() for the common case of visiting a single variant.
  • Removed unnecessary copies during visit().

3.17.06

Minor spelling and grammar corrections. (#396)
Using of qualified eastl move() and forward() functions. (#405)
Fixed warnings in function_detail.h on MSVC at warning level 4. (#400)
Fix get(variant) when variant is a rvalue (#406)
Using of qualified eastl functions. (#407)
Removed extra parentheses on eastl::move's return statement (#409)

[EASTL 3.17.06] (#412)

Thanks to all committers for this EASTL release.

3.17.03

[EASTL 3.17.03] (#397)

EASTL: lru_cache iteration tests and added support for initializer_lists

eastl::atomic : fixed msvc compiler warning 4459

3.17.02

rbtree::emplace_hint() compilation fix for variadic arg use (#392)

• Fix hint-versions of rbtree class variadic insertion methods: parameter pack and move semantics support.

• Fix hashtable::insert() to satisfy new map tests.

Fixed typo in Deque comments (#394)

[EASTL 3.17.02] (#395)

eastl::atomic

• fix all the spelling mistakes in the doc
• Added support for non-trivially default constructible types
• Cleaned up comments and impl
• improved 128-bit load code gen
• fixed type pun to support non-trivially default constructible types
• ensure msvc instrinics do not emit prefetch instructions

EASTL: to_array implementation

EASTL: fix for rbtree input iterator ctor moving elements from the source container

3.17.01

128-bit integral feature define fix (#393)

3.17.00

• Ensure the alignment of a node<value_type> is the alignment of the whole node allocation, not just the user type

• Removing old compiler special case code for EA_CPP14_CONSTEXPR

• Adding eastl::string hash tests and removing an addition overload in the helper template that contrains usage to enum types.

• Fixing user reported regression when attempting to use fancy pointers in a tuple

• Resolving uint128_t hashing compiler errors from properly limiting the generic template for enums

• eastl::pair adding C++17 structured bindings unpacking support

• eastl::atomic implementation - See EASTL/atomic.h for documentation

• eastl::function - Optimized function call operator
  - see Invoker() in function_detail.h for explanation of the optimization

• Consolidate Warnings by using EA_DISABLE_WARNING macros

• Reverting the UDL warning suppression because of push/pop mismatch issues with the EABase warning suppression macros

• eastl::variant - Fixed variant warnings due to not sfinae overloads that are not the same type but still comparable
  - improved code gen on msvc
  - added tests

• Removed unndeded allocator_traits headers

• Added comments on reverse_wrapper

• Removed sparse_matrix.h as it was removed internally quite a while ago

• Updated files that had slight differences to internal eastl

• Update travis CI to use g++-9 && clang++-11

• Updated README and CONTRIBUTING to allow contributors to submit their info under the contributors section

• cleared mpPtrArray in base destructor #389

• Add eastl::span<*> to EASTL.natvis #386

• Fix typo in doc #384

• Fix reverse adaptor when using on a rvalue range #382

• Fix GCC 9 string SSO segfault #380

• eastl::shared_ptr<>::reset(): function not thread safe #378

• Enable compilation without building tests #359

• Fix tuple vector assign #374

• fixed unique_ptr<[]>::reset() instructions order. Internal pointer must be updated before deleting object #375

3.16.07

• fixing spelling mistake in eastl::basic_string

• Fix for insertion_sort() doing a --(BiDirectionalIterator.begin()) which is an illegal operation and causes crashes on containers such as eastl::deque.

• eastl::optional_storage - remove unneeded union and trivial type initialization since we use eastl::aligned_storage_t, remove unreferenced internal member function

• resolving 32-bit eastl_size_t compiler error

• EASTL_ALIGN_OF porting to C++11 alignof keyword.

• EASTL_EMPTY_REFERENCE_ASSERT_ENABLED when enabled would not assert when taking a reference to an empty container.
  Example, eastl::vector[0] would not assert that a null reference was being taken if the vector was empty.

• fixing shared_ptr compiler error when passing nullptr with a custom deleter lambda

• fixed unique_ptr::reset() instructions order. Internal pointer must be updated before deleting object (#373)

• fixed unique_ptr<[]>::reset() instructions order. Internal pointer must be updated before deleting object (#375)

• fixed adl with exchange inside unique_ptr to be fully qualified

• fix bitvector iterators (#358)
  use mContainer.begin() instead of &mContainer[0],
  since it causes out of bounds exception in non release build

• Fix circular dependency in fixed_function.h (#350)