Merge pull request electronicarts#493 from electronicarts/eastl-3.19.05

Update to 13.19.05

Author: grojo-ea

include/EASTL/algorithm.h

@@ -164,6 +164,8 @@
 //      random_shuffle<Random>
 //      remove
 //      remove_if
+//     +apply_and_remove
+//     +apply_and_remove_if
 //      remove_copy
 //      remove_copy_if
 //     +remove_heap                                 Found in heap.h
@@ -1261,14 +1263,8 @@ namespace eastl
 	inline BidirectionalIterator2 move_and_copy_backward_chooser(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 resultEnd)
 	{
 		typedef typename eastl::iterator_traits<BidirectionalIterator1>::iterator_category IIC;
-		typedef typename eastl::iterator_traits<BidirectionalIterator2>::iterator_category OIC;
-		typedef typename eastl::iterator_traits<BidirectionalIterator1>::value_type        value_type_input;
-		typedef typename eastl::iterator_traits<BidirectionalIterator2>::value_type        value_type_output;
 
-		const bool canBeMemmoved = eastl::is_trivially_copyable<value_type_output>::value &&
-								   eastl::is_same<value_type_input, value_type_output>::value &&
-								  (eastl::is_pointer<BidirectionalIterator1>::value || eastl::is_same<IIC, EASTL_ITC_NS::contiguous_iterator_tag>::value) &&
-								  (eastl::is_pointer<BidirectionalIterator2>::value || eastl::is_same<OIC, EASTL_ITC_NS::contiguous_iterator_tag>::value);
+		const bool canBeMemmoved = internal::can_be_memmoved_helper<BidirectionalIterator1, BidirectionalIterator2>::value;
 
 		return eastl::move_and_copy_backward_helper<IIC, isMove, canBeMemmoved>::move_or_copy_backward(first, last, resultEnd); // Need to chose based on the input iterator tag and not the output iterator tag, because containers accept input ranges of iterator types different than self.
 	}
@@ -2666,6 +2662,94 @@ namespace eastl
 	}
 
 
+	/// apply_and_remove_if
+	///
+	/// Calls the Function function for all elements referred to  my iterator i in the range
+	/// [first, last) for which the following corresponding condition holds:
+	/// predicate(*i) == true
+	/// and then left shift moves potential non-matching elements over it.
+	///
+	/// Returns: a past-the-end iterator for the new end of the range.
+	///
+	/// Complexity: Exactly 'last - first' applications of the corresponding predicate + applies
+	/// function once for every time the condition holds.
+	///
+	/// Note: Since removing is done by shifting (by means of copy move assignment) the elements
+	/// in the range in such a way that the elements that are not to be removed appear in the
+	/// beginning of the range doesn't actually remove it from the given container, the user must call
+	/// the container erase function if the user wants to erase the element
+	/// from the container. I.e. in the same they as for remove_if the excess elements
+	/// are left in a valid but possibly moved from state.
+	///
+	template <typename ForwardIterator, typename Function, typename Predicate>
+	inline ForwardIterator apply_and_remove_if(ForwardIterator first,
+	                                           ForwardIterator last,
+	                                           Function function,
+	                                           Predicate predicate)
+	{
+		first = eastl::find_if(first, last, predicate);
+		if (first != last)
+		{
+			function(*first);
+			for (auto i = next(first); i != last; ++i)
+			{
+				if (predicate(*i))
+				{
+					function(*i);
+					continue;
+				}
+				*first = eastl::move(*i);
+				++first;
+			}
+		}
+		return first;
+	}
+
+
+	/// apply_and_remove
+	///
+	/// Calls the Function function for all elements referred to my iterator i in the range
+	/// [first, last) for which the following corresponding condition holds:
+	/// value == *i
+	/// and then left shift moves potential non-matching elements over it.
+	///
+	/// Returns: a past-the-end iterator for the new end of the range.
+	///
+	/// Complexity: Exactly 'last - first' applications of the corresponding equality test
+	/// + applies function once for every time the condition holds.
+	///
+	/// Note: Since removing is done by shifting (by means of copy move assignment) the elements
+	/// in the range in such a way that the elements that are not to be removed appear in the
+	/// beginning of the range doesn't actually remove it from the given container, the user must call
+	/// the container erase function if the user wants to erase the element
+	/// from the container. I.e. in the same they as for remove_if the excess elements
+	/// are left in a valid but possibly moved from state.
+	///
+	template <typename ForwardIterator, typename Function, typename T>
+	inline ForwardIterator apply_and_remove(ForwardIterator first,
+	                                        ForwardIterator last,
+	                                        Function function,
+	                                        const T& value)
+	{
+		first = eastl::find(first, last, value);
+		if (first != last)
+		{
+			function(*first);
+			for (auto i = next(first); i != last; ++i)
+			{
+				if (value == *i)
+				{
+					function(*i);
+					continue;
+				}
+				*first = eastl::move(*i);
+				++first;
+			}
+		}
+		return first;
+	}
+
+
 	/// replace_copy
 	///
 	/// Effects: Assigns to every iterator i in the range [result, result + (last - first))

include/EASTL/bonus/lru_cache.h

@@ -122,7 +122,7 @@ namespace eastl
 		}
 
 		lru_cache(std::initializer_list<eastl::pair<Key, Value>> il)
-			: lru_cache(il.size())
+			: lru_cache(static_cast<size_type>(il.size()))
 		{
 			for(auto& p : il)
 				insert_or_assign(p.first, p.second);

include/EASTL/chrono.h

@@ -16,7 +16,7 @@
 #define EASTL_CHRONO_H
 
 #if defined(EA_PRAGMA_ONCE_SUPPORTED)
-	#pragma once 
+	#pragma once
 #endif
 
 #include <EASTL/internal/config.h>
@@ -52,7 +52,7 @@
 	// Nothing to do
 #elif defined(EA_PLATFORM_APPLE)
 	#include <mach/mach_time.h>
-#elif defined(EA_PLATFORM_POSIX) || defined(EA_PLATFORM_MINGW) || defined(EA_PLATFORM_ANDROID) 
+#elif defined(EA_PLATFORM_POSIX) || defined(EA_PLATFORM_MINGW) || defined(EA_PLATFORM_ANDROID)
 	// Posix means Linux, Unix, and Macintosh OSX, among others (including Linux-based mobile platforms).
 	#if defined(EA_PLATFORM_MINGW)
 		#include <pthread_time.h>
@@ -101,7 +101,7 @@ namespace chrono
 	namespace Internal
 	{
 		///////////////////////////////////////////////////////////////////////////////
-		// IsRatio 
+		// IsRatio
 		///////////////////////////////////////////////////////////////////////////////
 		template <typename> struct IsRatio                                           : eastl::false_type {};
 		template <intmax_t N, intmax_t D> struct IsRatio<ratio<N, D>>                : eastl::true_type {};
@@ -111,7 +111,7 @@ namespace chrono
 
 
 		///////////////////////////////////////////////////////////////////////////////
-		// IsDuration 
+		// IsDuration
 		///////////////////////////////////////////////////////////////////////////////
 		template<typename> struct IsDuration                                                            : eastl::false_type{};
 		template<typename Rep, typename Period> struct IsDuration<duration<Rep, Period>>                : eastl::true_type{};
@@ -121,7 +121,7 @@ namespace chrono
 
 
 		///////////////////////////////////////////////////////////////////////////////
-		// RatioGCD 
+		// RatioGCD
 		///////////////////////////////////////////////////////////////////////////////
 		template <class Period1, class Period2>
 		struct RatioGCD
@@ -194,10 +194,10 @@ namespace chrono
 
 
 	///////////////////////////////////////////////////////////////////////////////
-	// duration_cast 
+	// duration_cast
 	///////////////////////////////////////////////////////////////////////////////
 	template <typename ToDuration, typename Rep, typename Period>
-	inline typename eastl::enable_if<Internal::IsDuration<ToDuration>::value, ToDuration>::type 
+	inline typename eastl::enable_if<Internal::IsDuration<ToDuration>::value, ToDuration>::type
 	duration_cast(const duration<Rep, Period>& d)
 	{
 		typedef typename duration<Rep, Period>::this_type FromDuration;
@@ -206,20 +206,20 @@ namespace chrono
 
 
 	///////////////////////////////////////////////////////////////////////////////
-	// duration 
+	// duration
 	///////////////////////////////////////////////////////////////////////////////
 	template <class Rep, class Period>
 	class duration
 	{
-		Rep mRep;	
+		Rep mRep;
 
 	public:
 		typedef Rep rep;
 		typedef Period period;
 		typedef duration<Rep, Period> this_type;
 
     #if defined(EA_COMPILER_NO_DEFAULTED_FUNCTIONS)
-		EA_CONSTEXPR duration() 
+		EA_CONSTEXPR duration()
 			: mRep() {}
 
 		duration(const duration& other)
@@ -235,7 +235,7 @@ namespace chrono
 
 
 		///////////////////////////////////////////////////////////////////////////////
-		// conversion constructors 
+		// conversion constructors
 		///////////////////////////////////////////////////////////////////////////////
 		template <class Rep2>
 		inline EA_CONSTEXPR explicit duration(
@@ -255,12 +255,12 @@ namespace chrono
 		    : mRep(duration_cast<duration>(d2).count()) {}
 
 		///////////////////////////////////////////////////////////////////////////////
-		// returns the count of ticks 
+		// returns the count of ticks
 		///////////////////////////////////////////////////////////////////////////////
 		EA_CONSTEXPR Rep count() const { return mRep; }
 
 		///////////////////////////////////////////////////////////////////////////////
-		// static accessors of special duration values 
+		// static accessors of special duration values
 		///////////////////////////////////////////////////////////////////////////////
 		EA_CONSTEXPR inline static duration zero() { return duration(duration_values<Rep>::zero()); }
 		EA_CONSTEXPR inline static duration min()  { return duration(duration_values<Rep>::min()); }
@@ -418,7 +418,7 @@ namespace chrono
 	///////////////////////////////////////////////////////////////////////////////
 	// 20.12.6, time_point
 	///////////////////////////////////////////////////////////////////////////////
-	template <typename Clock, typename Duration = typename Clock::duration> 
+	template <typename Clock, typename Duration = typename Clock::duration>
 	class time_point
 	{
 		Duration mDuration;
@@ -440,7 +440,7 @@ namespace chrono
 
 		EA_CONSTEXPR Duration time_since_epoch() const { return mDuration; }
 
-		time_point& operator+=(const Duration& d) { mDuration += d; return *this; } 
+		time_point& operator+=(const Duration& d) { mDuration += d; return *this; }
 		time_point& operator-=(const Duration& d) { mDuration -= d; return *this; }
 
 		static EA_CONSTEXPR time_point min() { return time_point(Duration::min()); }
@@ -543,7 +543,7 @@ namespace chrono
 	namespace Internal
 	{
 		#if defined(EA_PLATFORM_MICROSOFT) && !defined(EA_PLATFORM_MINGW)
-			#define EASTL_NS_PER_TICK 1 
+			#define EASTL_NS_PER_TICK 1
 		#elif defined EA_PLATFORM_SONY
 			#define EASTL_NS_PER_TICK 1
 		#elif defined EA_PLATFORM_POSIX
@@ -552,17 +552,17 @@ namespace chrono
 			#define EASTL_NS_PER_TICK 100
 		#endif
 
-		#if defined(EA_PLATFORM_POSIX) 
+		#if defined(EA_PLATFORM_POSIX)
 			typedef chrono::nanoseconds::period SystemClock_Period;
 			typedef chrono::nanoseconds::period SteadyClock_Period;
 		#else
-			typedef eastl::ratio_multiply<eastl::ratio<EASTL_NS_PER_TICK, 1>, nano>::type SystemClock_Period; 
-			typedef eastl::ratio_multiply<eastl::ratio<EASTL_NS_PER_TICK, 1>, nano>::type SteadyClock_Period; 
+			typedef eastl::ratio_multiply<eastl::ratio<EASTL_NS_PER_TICK, 1>, nano>::type SystemClock_Period;
+			typedef eastl::ratio_multiply<eastl::ratio<EASTL_NS_PER_TICK, 1>, nano>::type SteadyClock_Period;
 		#endif
 
 
 		///////////////////////////////////////////////////////////////////////////////
-		// Internal::GetTicks 
+		// Internal::GetTicks
 		///////////////////////////////////////////////////////////////////////////////
 		inline uint64_t GetTicks()
 		{
@@ -595,7 +595,7 @@ namespace chrono
 				mach_timebase_info(&info);
 				return info;
 			};
-			
+
 			static auto timeInfo = queryTimeInfo();
 			uint64_t t = mach_absolute_time();
 			t *= timeInfo.numer;
@@ -625,7 +625,7 @@ namespace chrono
 
 
 	///////////////////////////////////////////////////////////////////////////////
-	// system_clock 
+	// system_clock
 	///////////////////////////////////////////////////////////////////////////////
 	class system_clock
 	{
@@ -639,15 +639,15 @@ namespace chrono
 		EA_CONSTEXPR_OR_CONST static bool is_steady = false;
 
 		// returns a time point representing the current point in time.
-		static time_point now() EA_NOEXCEPT 
-		{ 
-			return time_point(duration(Internal::GetTicks())); 
+		static time_point now() EA_NOEXCEPT
+		{
+			return time_point(duration(Internal::GetTicks()));
 		}
 	};
 
 
 	///////////////////////////////////////////////////////////////////////////////
-	// steady_clock 
+	// steady_clock
 	///////////////////////////////////////////////////////////////////////////////
 	class steady_clock
 	{
@@ -661,24 +661,24 @@ namespace chrono
 		EA_CONSTEXPR_OR_CONST static bool is_steady = true;
 
 		// returns a time point representing the current point in time.
-		static time_point now() EA_NOEXCEPT 
-		{ 
-			return time_point(duration(Internal::GetTicks())); 
+		static time_point now() EA_NOEXCEPT
+		{
+			return time_point(duration(Internal::GetTicks()));
 		}
 	};
 
 
 	///////////////////////////////////////////////////////////////////////////////
-	// high_resolution_clock 
+	// high_resolution_clock
 	///////////////////////////////////////////////////////////////////////////////
 	typedef system_clock high_resolution_clock;
 
 
-} // namespace chrono 
+} // namespace chrono
 
 
 	///////////////////////////////////////////////////////////////////////////////
-	// duration common_type specialization 
+	// duration common_type specialization
 	///////////////////////////////////////////////////////////////////////////////
 	template <typename Rep1, typename Period1, typename Rep2, typename Period2>
 	struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>
@@ -689,7 +689,7 @@ namespace chrono
 
 
 	///////////////////////////////////////////////////////////////////////////////
-	// time_point common_type specialization 
+	// time_point common_type specialization
 	///////////////////////////////////////////////////////////////////////////////
 	template <typename Clock, typename Duration1, typename Duration2>
 	struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>
@@ -699,10 +699,15 @@ namespace chrono
 
 
 	///////////////////////////////////////////////////////////////////////////////
-	// chrono_literals  
+	// chrono_literals
 	///////////////////////////////////////////////////////////////////////////////
 	#if EASTL_USER_LITERALS_ENABLED && EASTL_INLINE_NAMESPACES_ENABLED
-		EA_DISABLE_VC_WARNING(4455) // disable warning C4455: literal suffix identifiers that do not start with an underscore are reserved
+		// Disabling the Clang/GCC/MSVC warning about using user
+		// defined literals without a leading '_' as they are reserved
+		// for standard libary usage.
+		EA_DISABLE_VC_WARNING(4455)
+		EA_DISABLE_CLANG_WARNING(-Wuser-defined-literals)
+		EA_DISABLE_GCC_WARNING(-Wliteral-suffix)
 		inline namespace literals
 		{
 			inline namespace chrono_literals
@@ -735,7 +740,9 @@ namespace chrono
 
 			} // namespace chrono_literals
 		}// namespace literals
-		EA_RESTORE_VC_WARNING() // warning: 4455
+		EA_RESTORE_GCC_WARNING()	// -Wliteral-suffix
+		EA_RESTORE_CLANG_WARNING()	// -Wuser-defined-literals
+		EA_RESTORE_VC_WARNING()		// warning: 4455
 	#endif
 
 } // namespace eastl
@@ -749,4 +756,4 @@ namespace chrono
 #endif
 
 
-#endif 
+#endif