updated to latest version

Author: questor

algorithm.h

@@ -250,7 +250,6 @@
 #include <eastl/iterator.h>
 #include <eastl/functional.h>
 #include <eastl/utility.h>
-#include <eastl/internal/generic_iterator.h>
 #include <eastl/random.h>
 #include <eastl/compare.h>
 
@@ -1282,11 +1281,12 @@ namespace eastl
 	}
 
 
-	// We have a second layer of unwrap_iterator calls because the original iterator might be something like move_iterator<generic_iterator<int*> > (i.e. doubly-wrapped).
 	template <bool isMove, typename BidirectionalIterator1, typename BidirectionalIterator2>
-	inline BidirectionalIterator2 move_and_copyBackward_unwrapper(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 resultEnd)
+	EASTL_REMOVE_AT_2024_SEPT inline BidirectionalIterator2 move_and_copyBackward_unwrapper(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 resultEnd)
 	{
+		EASTL_INTERNAL_DISABLE_DEPRECATED() // 'unwrap_iterator': was declared deprecated
 		return BidirectionalIterator2(eastl::move_and_copyBackward_chooser<isMove>(eastl::unwrap_iterator(first), eastl::unwrap_iterator(last), eastl::unwrap_iterator(resultEnd))); // Have to convert to BidirectionalIterator2 because result.base() could be a T*
+		EASTL_INTERNAL_RESTORE_DEPRECATED()
 	}
 
 
@@ -1314,7 +1314,7 @@ namespace eastl
 	template <typename BidirectionalIterator1, typename BidirectionalIterator2>
 	inline BidirectionalIterator2 move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 resultEnd)
 	{
-		return eastl::move_and_copyBackward_unwrapper<true>(eastl::unwrap_iterator(first), eastl::unwrap_iterator(last), resultEnd);
+		return eastl::move_and_copyBackward_chooser<true>(first, last, resultEnd);
 	}
 
 
@@ -1335,9 +1335,7 @@ namespace eastl
 	template <typename BidirectionalIterator1, typename BidirectionalIterator2>
 	inline BidirectionalIterator2 copyBackward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 resultEnd)
 	{
-		const bool isMove = eastl::is_move_iterator<BidirectionalIterator1>::value; EA_UNUSED(isMove);
-
-		return eastl::move_and_copyBackward_unwrapper<isMove>(eastl::unwrap_iterator(first), eastl::unwrap_iterator(last), resultEnd);
+		return eastl::move_and_copyBackward_chooser<false>(first, last, resultEnd);
 	}
 
 

any.h

@@ -193,14 +193,19 @@ namespace eastl
 				refAny.m_handler = nullptr;
 			}
 
+			static void* get(const any* pThis)
+			{
+				EASTL_ASSERT(pThis);
+				return (void*)(&pThis->m_storage.internal_storage);
+			}
+
 			static void* handler_func(storage_operation op, const any* pThis, any* pOther)
 			{
 				switch (op)
 				{
 					case storage_operation::GET:
 					{
-						EASTL_ASSERT(pThis);
-						return (void*)(&pThis->m_storage.internal_storage);
+						return get(pThis);
 					}
 					break;
 
@@ -280,15 +285,20 @@ namespace eastl
 				refAny.m_handler = nullptr;
 			}
 
+			static void* get(const any* pThis)
+			{
+				EASTL_ASSERT(pThis);
+				EASTL_ASSERT(pThis->m_storage.external_storage);
+				return static_cast<void*>(pThis->m_storage.external_storage);
+			}
+
 			static void* handler_func(storage_operation op, const any* pThis, any* pOther)
 			{
 				switch (op)
 				{
 					case storage_operation::GET:
 					{
-						EASTL_ASSERT(pThis);
-						EASTL_ASSERT(pThis->m_storage.external_storage);
-						return static_cast<void*>(pThis->m_storage.external_storage);
+						return get(pThis);
 					}
 					break;
 
@@ -456,25 +466,27 @@ namespace eastl
         // 20.7.3.3, modifiers
 		#if EASTL_VARIADIC_TEMPLATES_ENABLED
 			template <class T, class... Args>
-			void emplace(Args&&... args)
+			typename eastl::enable_if<eastl::is_constructible_v<eastl::decay_t<T>, Args...> && eastl::is_copy_constructible_v<eastl::decay_t<T>>, eastl::decay_t<T>&>::type
+			emplace(Args&&... args)
 			{
 			    typedef storage_handler<decay_t<T>> StorageHandlerT;
-				static_assert(eastl::is_constructible<T, Args...>::value, "T must be constructible with Args...");
 
 			    reset();
 				StorageHandlerT::construct_inplace(m_storage, eastl::forward<Args>(args)...);
 				m_handler = &StorageHandlerT::handler_func;
+				return *static_cast<decay_t<T>*>(StorageHandlerT::get(this));
 			}
 
 			template <class NT, class U, class... Args>
-		    typename eastl::enable_if<eastl::is_constructible<NT, std::initializer_list<U>&, Args...>::value, void>::type
+		    typename eastl::enable_if<eastl::is_constructible_v<eastl::decay_t<NT>, std::initializer_list<U>&, Args...> && eastl::is_copy_constructible_v<eastl::decay_t<NT>>, eastl::decay_t<NT>&>::type
 			emplace(std::initializer_list<U> il, Args&&... args)
 			{
 			    typedef storage_handler<decay_t<NT>> StorageHandlerT;
 
 				reset();
 				StorageHandlerT::construct_inplace(m_storage, il, eastl::forward<Args>(args)...);
 				m_handler = &StorageHandlerT::handler_func;
+				return *static_cast<decay_t<NT>*>(StorageHandlerT::get(this));
 			}
         #endif
 

array.h

@@ -29,6 +29,9 @@
 	EA_RESTORE_ALL_VC_WARNINGS()
 #endif
 
+// 4512/4626 - 'class' : assignment operator could not be generated.  // This disabling would best be put elsewhere.
+EA_DISABLE_VC_WARNING(4512 4626);
+
 #if defined(EASTL_PRAGMA_ONCE_SUPPORTED)
 	#pragma once // Some compilers (e.g. VC++) benefit significantly from using this. We've measured 3-4% build speed improvements in apps as a result.
 #endif
@@ -152,11 +155,11 @@ namespace eastl
 
 		// We intentionally provide no constructor, destructor, or assignment operator.
 
-		void fill(const value_type& value) {}
+		void fill(const value_type&) {}
 
 		// Unlike the swap function for other containers, array::swap takes linear time,
 		// may exit via an exception, and does not cause iterators to become associated with the other container.
-		void swap(this_type& x) EASTL_NOEXCEPT {}
+		void swap(this_type&) EASTL_NOEXCEPT {}
 
 		EA_CPP14_CONSTEXPR iterator       begin() EASTL_NOEXCEPT { return nullptr; }
 		EA_CPP14_CONSTEXPR const_iterator begin() const EASTL_NOEXCEPT { return nullptr; }
@@ -181,9 +184,11 @@ namespace eastl
 		EA_CPP14_CONSTEXPR T* data() EASTL_NOEXCEPT { return nullptr; }
 		EA_CPP14_CONSTEXPR const T* data() const EASTL_NOEXCEPT { return nullptr; }
 
-		EA_CPP14_CONSTEXPR reference       operator[](size_type i) { return *data(); }
-		EA_CPP14_CONSTEXPR const_reference operator[](size_type i) const { return *data(); }
-		EA_CPP14_CONSTEXPR const_reference at(size_type i) const
+		EA_CPP14_CONSTEXPR reference       operator[](size_type) { return *data(); }
+		EA_CPP14_CONSTEXPR const_reference operator[](size_type) const { return *data(); }
+
+		EA_DISABLE_VC_WARNING(4702); // unreachable code
+		EA_CPP14_CONSTEXPR const_reference at(size_type) const
 		{
 #if EASTL_EXCEPTIONS_ENABLED
 			throw std::out_of_range("array::at -- out of range");
@@ -192,7 +197,10 @@ namespace eastl
 #endif
 			return *data();
 		}
-		EA_CPP14_CONSTEXPR reference       at(size_type i)
+		EA_RESTORE_VC_WARNING();
+
+		EA_DISABLE_VC_WARNING(4702); // unreachable code
+		EA_CPP14_CONSTEXPR reference       at(size_type)
 		{
 #if EASTL_EXCEPTIONS_ENABLED
 			throw std::out_of_range("array::at -- out of range");
@@ -201,6 +209,7 @@ namespace eastl
 #endif
 			return *data();
 		}
+		EA_RESTORE_VC_WARNING();
 
 		EA_CPP14_CONSTEXPR reference       front() { return *data(); }
 		EA_CPP14_CONSTEXPR const_reference front() const { return *data(); }
@@ -209,7 +218,7 @@ namespace eastl
 		EA_CPP14_CONSTEXPR const_reference back() const { return *data(); }
 
 		bool validate() const { return true; }
-		int  validateIterator(const_iterator i) const { return isf_none; }
+		int  validateIterator(const_iterator) const { return isf_none; }
 
 	}; // class array
 
@@ -365,6 +374,15 @@ namespace eastl
 	EA_CPP14_CONSTEXPR inline typename array<T, N>::reference
 	array<T, N>::operator[](size_type i)
 	{
+		#if EASTL_ASSERT_ENABLED && EASTL_EMPTY_REFERENCE_ASSERT_ENABLED
+			if (EASTL_UNLIKELY(i >= N))
+				EASTL_FAIL_MSG("array::operator[] -- out of range");
+		#elif EASTL_ASSERT_ENABLED
+			// We allow taking a reference to arr[0]
+			if (EASTL_UNLIKELY((i != 0) && i >= N))
+				EASTL_FAIL_MSG("array::operator[] -- out of range");
+		#endif
+
 		return mValue[i];
 	}
 
@@ -373,6 +391,15 @@ namespace eastl
 	EA_CPP14_CONSTEXPR inline typename array<T, N>::const_reference
 	array<T, N>::operator[](size_type i) const
 	{
+		#if EASTL_ASSERT_ENABLED && EASTL_EMPTY_REFERENCE_ASSERT_ENABLED
+			if (EASTL_UNLIKELY(i >= N))
+				EASTL_FAIL_MSG("array::operator[] -- out of range");
+		#elif EASTL_ASSERT_ENABLED
+			// We allow taking a reference to arr[0]
+			if (EASTL_UNLIKELY((i != 0) && i >= N))
+				EASTL_FAIL_MSG("array::operator[] -- out of range");
+		#endif
+
 		return mValue[i];
 	}
 
@@ -649,6 +676,8 @@ struct tuple_element<I, eastl::array<T, N>> : public eastl::tuple_element<I, eas
 #endif
 
 
+EA_RESTORE_VC_WARNING();
+
 #endif // Header include guard
 
 

bit.h

@@ -13,6 +13,7 @@
 
 #include <eastl/internal/memory_base.h>
 #include <eastl/type_traits.h>
+#include <eastl/numeric_limits.h>
 #include <string.h> // memcpy
 
 namespace eastl