EASTL Versions Save

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<T> is probably the correct trait to use.

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().

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<T>(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.

[EASTL 3.17.03] (#397)

EASTL: lru_cache iteration tests and added support for initializer_lists

eastl::atomic<T> : fixed msvc compiler warning 4459

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<T>

• 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

128-bit integral feature define fix (#393)

• 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<T> 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

• 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)

• Implemented C++17 eastl::shared_ptr::weak_from_this.
• Implemented C++20 char8_t string/string_view support improvements.
• Fixed unguarded eastl::allocator::set_name usage in eastl::vector_multimap.
• Added bool autoDestruct template parameter to eastl::late_constructed to determine whether to destruct the containing object
• eastl::finally fixes for missing type_traits headers.
• eastl::span fixes for C++17 deduction guides, and completing subspan API.
• eastl::array fixes for C++17 deduction guides.
• C++20 iterator fixes.
• atomic_exchange_explicit bug fix for a missing return statement in a member function.
• string_view::find_first_of bug fix where incorrect string count member variable was used.
• vector::DoRealloc tag dispatch bug fix for 'should_copy_tag' and 'should_move_tag' expression.
• eastl::u8string updated to C++20 definition 'basic_string<char8_t>'

• Implemented C++20 uniform container erasure algorithms as defined by: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/n4806.html#container.erasure
• removing eastl::sparse_matrix files as it was never implemented.
• eastl::span conversion constructor fix for eastl::vector.