3.05.02 release

Author: rparolin

include/EASTL/bonus/fixed_ring_buffer.h

@@ -0,0 +1,48 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (c) Electronic Arts Inc. All rights reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef EASTL_FIXED_RING_BUFFER_H
+#define EASTL_FIXED_RING_BUFFER_H
+
+#include <EASTL/internal/config.h>
+#include <EASTL/fixed_vector.h>
+#include <EASTL/bonus/ring_buffer.h>
+
+EA_ONCE()
+
+namespace eastl
+{
+
+	/// fixed_ring_buffer
+	///
+	/// This is a convenience template alias for creating a fixed-sized
+	/// ring_buffer using eastl::fixed_vector as its storage container. This has
+	/// been tricky for users to get correct due to the constructor requirements
+	/// of eastl::ring_buffer leaking the implementation detail of the sentinel
+	/// value being used internally.  In addition, it was not obvious what the
+	/// correct allocator_type template parameter should be used for containers
+	/// providing both a default allocator type and an overflow allocator type.
+	///
+	/// We are over-allocating the fixed_vector container to accommodate the
+	/// ring_buffer sentinel to prevent that implementation detail leaking into
+	/// user code.
+	///
+	/// Example usage:
+	///
+	/// 	fixed_ring_buffer<int, 8> rb = {0, 1, 2, 3, 4, 5, 6, 7};
+	///  or
+	/// 	fixed_ring_buffer<int, 8> rb(8); // capacity doesn't need to respect sentinel
+	/// 	rb.push_back(0);
+	///
+	///
+#if !defined(EA_COMPILER_NO_TEMPLATE_ALIASES)
+	template <typename T, size_t N>
+	using fixed_ring_buffer =
+	    ring_buffer<T, fixed_vector<T, N + 1, false>, typename fixed_vector<T, N + 1, false>::overflow_allocator_type>;
+#endif
+
+} // namespace eastl
+
+#endif // Header include guard
+

include/EASTL/bonus/ring_buffer.h

@@ -32,6 +32,20 @@
 
 namespace eastl
 {
+	/// EASTL_RING_BUFFER_DEFAULT_NAME
+	///
+	/// Defines a default container name in the absence of a user-provided name.
+	///
+	#ifndef EASTL_RING_BUFFER_DEFAULT_NAME
+		#define EASTL_RING_BUFFER_DEFAULT_NAME EASTL_DEFAULT_NAME_PREFIX " ring_buffer" // Unless the user overrides something, this is "EASTL ring_buffer".
+	#endif
+
+	/// EASTL_RING_BUFFER_DEFAULT_ALLOCATOR
+	///
+	#ifndef EASTL_RING_BUFFER_DEFAULT_ALLOCATOR
+		#define EASTL_RING_BUFFER_DEFAULT_ALLOCATOR allocator_type(EASTL_RING_BUFFER_DEFAULT_NAME)
+	#endif
+
 
 	/// ring_buffer_iterator
 	///
@@ -222,17 +236,17 @@ namespace eastl
 		explicit ring_buffer(const allocator_type& allocator);
 		ring_buffer(const this_type& x);
 		#if EASTL_MOVE_SEMANTICS_ENABLED
-		ring_buffer(this_type&& x);
-		ring_buffer(this_type&& x, const allocator_type& allocator);
+			ring_buffer(this_type&& x);
+			ring_buffer(this_type&& x, const allocator_type& allocator);
 		#endif
-		ring_buffer(std::initializer_list<value_type> ilist, const allocator_type& allocator = allocator_type()); // This function sets the capacity to be equal to the size of the initializer list.
+		ring_buffer(std::initializer_list<value_type> ilist, const allocator_type& allocator = EASTL_RING_BUFFER_DEFAULT_ALLOCATOR); // This function sets the capacity to be equal to the size of the initializer list.
 
 		// No destructor necessary. Default will do.
 
 		this_type& operator=(const this_type& x);
 		this_type& operator=(std::initializer_list<value_type> ilist);
 		#if EASTL_MOVE_SEMANTICS_ENABLED
-		this_type& operator=(this_type&& x);
+			this_type& operator=(this_type&& x);
 		#endif
 
 		template <typename InputIterator>

include/EASTL/internal/char_traits.h

@@ -271,6 +271,64 @@ namespace eastl
 		return pDestination + (pSourceEnd - pSource);
 	}
 
+	template <typename T>
+	const T* CharTypeStringFindEnd(const T* pBegin, const T* pEnd, T c)
+	{
+		const T* pTemp = pEnd;
+		while(--pTemp >= pBegin)
+		{
+			if(*pTemp == c)
+				return pTemp;
+		}
+
+		return pEnd;
+	}
+    
+	template <typename T>
+	const T* CharTypeStringRSearch(const T* p1Begin, const T* p1End, 
+								   const T* p2Begin, const T* p2End)
+	{
+		// Test for zero length strings, in which case we have a match or a failure, 
+		// but the return value is the same either way.
+		if((p1Begin == p1End) || (p2Begin == p2End))
+			return p1Begin;
+
+		// Test for a pattern of length 1.
+		if((p2Begin + 1) == p2End)
+			return CharTypeStringFindEnd(p1Begin, p1End, *p2Begin);
+
+		// Test for search string length being longer than string length.
+		if((p2End - p2Begin) > (p1End - p1Begin))
+			return p1End;
+
+		// General case.
+		const T* pSearchEnd = (p1End - (p2End - p2Begin) + 1);
+		const T* pCurrent1;
+		const T* pCurrent2;
+
+		while(pSearchEnd != p1Begin)
+		{
+			// Search for the last occurrence of *p2Begin.
+			pCurrent1 = CharTypeStringFindEnd(p1Begin, pSearchEnd, *p2Begin);
+			if(pCurrent1 == pSearchEnd) // If the first char of p2 wasn't found, 
+				return p1End;           // then we immediately have failure.
+
+			// In this case, *pTemp == *p2Begin. So compare the rest.
+			pCurrent2 = p2Begin;
+			while(*pCurrent1++ == *pCurrent2++)
+			{
+				if(pCurrent2 == p2End)
+					return (pCurrent1 - (p2End - p2Begin));
+			}
+
+			// A smarter algorithm might know to subtract more than just one,
+			// but in most cases it won't make much difference anyway.
+			--pSearchEnd;
+		}
+
+		return p1End;
+	}
+
 	template <typename T>
 	inline const T* CharTypeStringFindFirstOf(const T* p1Begin, const T* p1End, const T* p2Begin, const T* p2End)
 	{

include/EASTL/internal/config.h

@@ -105,8 +105,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef EASTL_VERSION
-	#define EASTL_VERSION   "3.05.00"
-	#define EASTL_VERSION_N  30500
+	#define EASTL_VERSION   "3.05.02"
+	#define EASTL_VERSION_N  30502
 #endif
 
 

include/EASTL/internal/hashtable.h

@@ -112,13 +112,19 @@ namespace eastl
 	template <typename Value, bool bCacheHashCode>
 	struct hash_node;
 
-	EA_DISABLE_VC_WARNING(4625) // disable warning: "copy constructor could not be generated because a base class copy constructor is inaccessible or deleted"
+	EA_DISABLE_VC_WARNING(4625 4626) // "copy constructor / assignment operator could not be generated because a base class copy constructor is inaccessible or deleted"
 	#ifdef EA_COMPILER_MSVC_2015
 		EA_DISABLE_VC_WARNING(5026) // disable warning: "move constructor was implicitly defined as deleted"
 	#endif
 		template <typename Value>
 		struct hash_node<Value, true>
 		{
+			#if defined(_MSC_VER) && (EA_COMPILER_VERSION == 1800) // VS2013
+				hash_node(hash_node&& x) : mValue(eastl::move(x.mValue)), mpNext(x.mpNext), mnHashCode(x.mnHashCode) {}
+			#elif EASTL_MOVE_SEMANTICS_ENABLED && !defined(EA_COMPILER_NO_DEFAULTED_FUNCTIONS)
+				hash_node(hash_node&&) = default;
+			#endif
+
 			Value        mValue;
 			hash_node*   mpNext;
 			eastl_size_t mnHashCode;      // See config.h for the definition of eastl_size_t, which defaults to uint32_t.
@@ -127,7 +133,13 @@ namespace eastl
 		template <typename Value>
 		struct hash_node<Value, false>
 		{
-			Value      mValue;
+			#if defined(_MSC_VER) && (EA_COMPILER_VERSION == 1800) // VS2013
+				hash_node(hash_node&& x) : mValue(eastl::move(x.mValue)), mpNext(x.mpNext) {}
+			#elif EASTL_MOVE_SEMANTICS_ENABLED && !defined(EA_COMPILER_NO_DEFAULTED_FUNCTIONS)
+				hash_node(hash_node&&) = default;
+			#endif
+
+		    Value      mValue;
 			hash_node* mpNext;
 		} EASTL_MAY_ALIAS;
 
@@ -1517,20 +1529,15 @@ namespace eastl
 			  typename H1, typename H2, typename H, typename RP, bool bC, bool bM, bool bU>
 	void hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::swap(this_type& x)
 	{
-		if(mAllocator == x.mAllocator) // If allocators are equivalent...
-		{
-			// We leave mAllocator as-is.
-			hash_code_base<K, V, EK, Eq, H1, H2, H, bC>::base_swap(x); // hash_code_base has multiple implementations, so we let them handle the swap.
-			eastl::swap(mRehashPolicy,  x.mRehashPolicy);
-			EASTL_MACRO_SWAP(node_type**, mpBucketArray, x.mpBucketArray); // Use EASTL_MACRO_SWAP because GCC (at least v4.6-4.8) has a bug where it fails to compile eastl::swap(mpBucketArray, x.mpBucketArray).
-			eastl::swap(mnBucketCount,  x.mnBucketCount);
-			eastl::swap(mnElementCount, x.mnElementCount);
-		}
-		else
+		hash_code_base<K, V, EK, Eq, H1, H2, H, bC>::base_swap(x); // hash_code_base has multiple implementations, so we let them handle the swap.
+		eastl::swap(mRehashPolicy, x.mRehashPolicy);
+		eastl::swap(mpBucketArray, x.mpBucketArray);
+		eastl::swap(mnBucketCount, x.mnBucketCount);
+		eastl::swap(mnElementCount, x.mnElementCount);
+
+		if (mAllocator != x.mAllocator) // If allocators are not equivalent...
 		{
-			const this_type temp(*this); // Can't call eastl::swap because that would
-			*this = x;                   // itself call this member swap function.
-			x     = temp;
+			eastl::swap(mAllocator, x.mAllocator);
 		}
 	}
 

include/EASTL/iterator.h

@@ -468,7 +468,7 @@ namespace eastl
 			move_iterator operator++(int)
 			{
 				move_iterator tempMoveIterator = *this;
-				++tempMoveIterator;
+				++mIterator;
 				return tempMoveIterator;
 			}
 
@@ -481,7 +481,7 @@ namespace eastl
 			move_iterator operator--(int)
 			{
 				move_iterator tempMoveIterator = *this;
-				--tempMoveIterator;
+				--mIterator;
 				return tempMoveIterator;
 			}
 

include/EASTL/string_view.h

@@ -38,7 +38,7 @@ namespace eastl
 		typedef const T* const_iterator;
 		typedef eastl::reverse_iterator<iterator> reverse_iterator;
 		typedef eastl::reverse_iterator<const_iterator> const_reverse_iterator;
-		typedef eastl_size_t size_type;
+		typedef size_t size_type;
 		typedef ptrdiff_t difference_type;
 
 		static const EA_CONSTEXPR size_type npos = size_type(-1);
@@ -60,10 +60,10 @@ namespace eastl
 		EA_CONSTEXPR const_iterator cbegin() const EA_NOEXCEPT { return mpBegin; }
 		EA_CONSTEXPR const_iterator end() const EA_NOEXCEPT { return mpBegin + mnCount; }
 		EA_CONSTEXPR const_iterator cend() const EA_NOEXCEPT { return mpBegin + mnCount; }
-		EA_CONSTEXPR const_reverse_iterator rbegin() const EA_NOEXCEPT { return reverse_iterator(mpBegin + mnCount); }
-		EA_CONSTEXPR const_reverse_iterator crbegin() const EA_NOEXCEPT { return reverse_iterator(mpBegin + mnCount); }
-		EA_CONSTEXPR const_reverse_iterator rend() const EA_NOEXCEPT { return reverse_iterator(mpBegin); }
-		EA_CONSTEXPR const_reverse_iterator crend() const EA_NOEXCEPT { return reverse_iterator(mpBegin); }
+		EA_CONSTEXPR const_reverse_iterator rbegin() const EA_NOEXCEPT { return const_reverse_iterator(mpBegin + mnCount); }
+		EA_CONSTEXPR const_reverse_iterator crbegin() const EA_NOEXCEPT { return const_reverse_iterator(mpBegin + mnCount); }
+		EA_CONSTEXPR const_reverse_iterator rend() const EA_NOEXCEPT { return const_reverse_iterator(mpBegin); }
+		EA_CONSTEXPR const_reverse_iterator crend() const EA_NOEXCEPT { return const_reverse_iterator(mpBegin); }
 
 
 		// 21.4.2.4, element access

include/EASTL/type_traits.h

@@ -629,13 +629,35 @@ namespace eastl
 		struct is_function
 			: public eastl::false_type {};
 
-		template <typename ReturnValue, typename... ArgPack>
-		struct is_function<ReturnValue /*FunctionName*/(ArgPack...)>
-			: public eastl::true_type {};
-
-		template <typename ReturnValue, typename... ArgPack>
-		struct is_function<ReturnValue /*FunctionName*/(ArgPack..., ...)>    // The second ellipsis handles the case of a function that takes ellipsis, like printf.
-			: public eastl::true_type {};
+		#if EA_PLATFORM_PTR_SIZE == 4 && defined(EA_PLATFORM_MICROSOFT) && defined(_MSC_EXTENSIONS)
+			// __cdecl specialization
+			template <typename ReturnValue, typename... ArgPack>
+			struct is_function<ReturnValue __cdecl (ArgPack...)>
+				: public eastl::true_type {};
+
+			template <typename ReturnValue, typename... ArgPack>
+			struct is_function<ReturnValue __cdecl (ArgPack..., ...)>    // The second ellipsis handles the case of a function that takes ellipsis, like printf.
+				: public eastl::true_type {};
+
+			// __stdcall specialization
+			template <typename ReturnValue, typename... ArgPack>
+			struct is_function<ReturnValue __stdcall (ArgPack...)>
+				: public eastl::true_type {};
+
+			// When functions use a variable number of arguments, it is the caller that cleans the stack (cf. cdecl).
+			//
+			// template <typename ReturnValue, typename... ArgPack>
+			// struct is_function<ReturnValue __stdcall (ArgPack..., ...)>    // The second ellipsis handles the case of a function that takes ellipsis, like printf.
+			//     : public eastl::true_type {};
+		#else 
+			template <typename ReturnValue, typename... ArgPack>
+			struct is_function<ReturnValue (ArgPack...)>
+				: public eastl::true_type {};
+
+			template <typename ReturnValue, typename... ArgPack>
+			struct is_function<ReturnValue (ArgPack..., ...)>    // The second ellipsis handles the case of a function that takes ellipsis, like printf.
+				: public eastl::true_type {};
+		#endif
 	#endif
 
 

include/EASTL/unordered_map.h

@@ -0,0 +1,52 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (c) Electronic Arts Inc. All rights reserved.
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef EASTL_UNORDERED_MAP_H
+#define EASTL_UNORDERED_MAP_H
+
+#include <EASTL/internal/config.h>
+#include <EASTL/hash_map.h>
+
+EA_ONCE()
+
+namespace eastl
+{
+	/// unordered_map 
+	///
+	/// The original TR1 (technical report 1) used "hash_map" to name a hash
+	/// table backed associative container of unique key-value pairs.  When the
+	/// container was added to the C++11 standard the committee chose the name
+	/// "unordered_map" to clarify that internally the elements are NOT sorted in
+	/// any particular order.  We provide a template alias here to ensure feature
+	/// parity with the original eastl::hash_map.
+	///
+	#if !defined(EA_COMPILER_NO_TEMPLATE_ALIASES)
+		template <typename Key,
+				  typename T,
+				  typename Hash = eastl::hash<Key>,
+				  typename Predicate = eastl::equal_to<Key>,
+				  typename Allocator = EASTLAllocatorType,
+				  bool bCacheHashCode = false>
+		using unordered_map = hash_map<Key, T, Hash, Predicate, Allocator, bCacheHashCode>;
+    #endif
+
+    /// unordered_multimap
+	///
+	/// Similar template alias as "unordered_map" except the contained elements
+	/// need not be unique. See "hash_multimap" for more details.
+	///
+	#if !defined(EA_COMPILER_NO_TEMPLATE_ALIASES)
+		template <typename Key,
+				  typename T,
+				  typename Hash = eastl::hash<Key>,
+				  typename Predicate = eastl::equal_to<Key>,
+				  typename Allocator = EASTLAllocatorType,
+				  bool bCacheHashCode = false>
+		using unordered_multimap = hash_multimap<Key, T, Hash, Predicate, Allocator, bCacheHashCode>;
+    #endif
+
+} // namespace eastl
+
+#endif // Header include guard
+