Using of qualified eastl functions. (#407)

electronicarts · Dec 12, 2020 · 853befb · 853befb
1 parent 07aecde
commit 853befb
Show file tree

Hide file tree

Showing 11 changed files with 87 additions and 88 deletions.
diff --git a/include/EASTL/algorithm.h b/include/EASTL/algorithm.h
@@ -2922,7 +2922,7 @@ namespace eastl
 		if(count <= 0)
 			return first;
 		else if(count == 1)
-			return find(first, last, value);
+			return eastl::find(first, last, value);
 		else if(last > first)
 		{
 			RandomAccessIterator lookAhead;
@@ -3758,7 +3758,7 @@ namespace eastl
 	{
 		typedef typename eastl::iterator_traits<BidirectionalIterator>::value_type value_type;
 
-		return next_permutation(first, last, eastl::less<value_type>());
+		return eastl::next_permutation(first, last, eastl::less<value_type>());
 	}
 
 
@@ -4061,12 +4061,6 @@ namespace eastl
 	///
 	/// http://en.cppreference.com/w/cpp/algorithm/clamp
 	///
-	template <class T>
-	EA_CONSTEXPR const T& clamp(const T& v, const T& lo, const T& hi)
-	{
-		return clamp(v, lo, hi, eastl::less<>());
-	}
-
 	template <class T, class Compare>
 	EA_CONSTEXPR const T& clamp(const T& v, const T& lo, const T& hi, Compare comp)
 	{
@@ -4075,6 +4069,11 @@ namespace eastl
 			   comp(v, lo) ? lo : comp(hi, v) ? hi : v;
 	}
 
+	template <class T>
+	EA_CONSTEXPR const T& clamp(const T& v, const T& lo, const T& hi)
+	{
+		return eastl::clamp(v, lo, hi, eastl::less<>());
+	}
 
 } // namespace eastl
 

diff --git a/include/EASTL/bonus/adaptors.h b/include/EASTL/bonus/adaptors.h
@@ -60,15 +60,15 @@ namespace eastl
 	};
 
 	template <typename Container>
-	auto begin(const reverse_wrapper<Container>& w) -> decltype(rbegin(w.mContainer))
+	auto begin(const reverse_wrapper<Container>& w) -> decltype(eastl::rbegin(w.mContainer))
 	{
-		return rbegin(w.mContainer);
+		return eastl::rbegin(w.mContainer);
 	}
 
 	template <typename Container>
-	auto end(const reverse_wrapper<Container>& w) -> decltype(rend(w.mContainer))
+	auto end(const reverse_wrapper<Container>& w) -> decltype(eastl::rend(w.mContainer))
 	{
-		return rend(w.mContainer);
+		return eastl::rend(w.mContainer);
 	}
 
 	template <typename Container>

diff --git a/include/EASTL/bonus/tuple_vector.h b/include/EASTL/bonus/tuple_vector.h
@@ -728,7 +728,7 @@ class TupleVecImpl<Allocator, index_sequence<Indices...>, Ts...> : public TupleV
 		{
 			if (newNumElements > oldNumCapacity)
 			{
-				const size_type newCapacity = max(GetNewCapacity(oldNumCapacity), newNumElements);
+				const size_type newCapacity = eastl::max(GetNewCapacity(oldNumCapacity), newNumElements);
 
 				void* ppNewLeaf[sizeof...(Ts)];
 				pair<void*, size_type> allocation =	TupleRecurser<Ts...>::template DoAllocate<allocator_type, 0, index_sequence_type, Ts...>(
@@ -774,7 +774,7 @@ class TupleVecImpl<Allocator, index_sequence<Indices...>, Ts...> : public TupleV
 		{
 			if (newNumElements > oldNumCapacity)
 			{
-				const size_type newCapacity = max(GetNewCapacity(oldNumCapacity), newNumElements);
+				const size_type newCapacity = eastl::max(GetNewCapacity(oldNumCapacity), newNumElements);
 
 				void* ppNewLeaf[sizeof...(Ts)];
 				pair<void*, size_type> allocation = TupleRecurser<Ts...>::template DoAllocate<allocator_type, 0, index_sequence_type, Ts...>(
@@ -826,7 +826,7 @@ class TupleVecImpl<Allocator, index_sequence<Indices...>, Ts...> : public TupleV
 		{
 			if (newNumElements > oldNumCapacity)
 			{
-				const size_type newCapacity = max(GetNewCapacity(oldNumCapacity), newNumElements);
+				const size_type newCapacity = eastl::max(GetNewCapacity(oldNumCapacity), newNumElements);
 
 				void* ppNewLeaf[sizeof...(Ts)];
 				pair<void*, size_type> allocation = TupleRecurser<Ts...>::template DoAllocate<allocator_type, 0, index_sequence_type, Ts...>(
@@ -880,7 +880,7 @@ class TupleVecImpl<Allocator, index_sequence<Indices...>, Ts...> : public TupleV
 		{
 			if (newNumElements > oldNumCapacity)
 			{
-				const size_type newCapacity = max(GetNewCapacity(oldNumCapacity), newNumElements);
+				const size_type newCapacity = eastl::max(GetNewCapacity(oldNumCapacity), newNumElements);
 
 				void* ppNewLeaf[sizeof...(Ts)];
 				pair<void*, size_type> allocation = TupleRecurser<Ts...>::template DoAllocate<allocator_type, 0, index_sequence_type, Ts...>(

diff --git a/include/EASTL/internal/functional_base.h b/include/EASTL/internal/functional_base.h
@@ -210,7 +210,7 @@ namespace eastl
 
 	template <typename T>
 	reference_wrapper<T>::reference_wrapper(T &v) EA_NOEXCEPT
-		: val(addressof(v))
+		: val(eastl::addressof(v))
 	{}
 
 	template <typename T>

diff --git a/include/EASTL/internal/hashtable.h b/include/EASTL/internal/hashtable.h
@@ -2701,8 +2701,8 @@ namespace eastl
 	inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::insert_return_type
 	hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::try_emplace(const key_type& key, Args&&... args)
 	{
-		return DoInsertValue(has_unique_keys_type(), piecewise_construct, forward_as_tuple(key),
-		                     forward_as_tuple(eastl::forward<Args>(args)...));
+		return DoInsertValue(has_unique_keys_type(), piecewise_construct, eastl::forward_as_tuple(key),
+		                     eastl::forward_as_tuple(eastl::forward<Args>(args)...));
 	}
 
 	template <typename K, typename V, typename A, typename EK, typename Eq,
@@ -2712,8 +2712,8 @@ namespace eastl
 	inline typename hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::insert_return_type
 	hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::try_emplace(key_type&& key, Args&&... args)
 	{
-		return DoInsertValue(has_unique_keys_type(), piecewise_construct, forward_as_tuple(eastl::move(key)),
-		                     forward_as_tuple(eastl::forward<Args>(args)...));
+		return DoInsertValue(has_unique_keys_type(), piecewise_construct, eastl::forward_as_tuple(eastl::move(key)),
+		                     eastl::forward_as_tuple(eastl::forward<Args>(args)...));
 	}
 
 	template <typename K, typename V, typename A, typename EK, typename Eq,
@@ -2724,7 +2724,7 @@ namespace eastl
 	{
 		insert_return_type result = DoInsertValue(
 		    has_unique_keys_type(),
-		    value_type(piecewise_construct, forward_as_tuple(key), forward_as_tuple(eastl::forward<Args>(args)...)));
+		    value_type(piecewise_construct, eastl::forward_as_tuple(key), eastl::forward_as_tuple(eastl::forward<Args>(args)...)));
 
 		return DoGetResultIterator(has_unique_keys_type(), result);
 	}
@@ -2736,8 +2736,8 @@ namespace eastl
 	hashtable<K, V, A, EK, Eq, H1, H2, H, RP, bC, bM, bU>::try_emplace(const_iterator, key_type&& key, Args&&... args)
 	{
 		insert_return_type result =
-		    DoInsertValue(has_unique_keys_type(), value_type(piecewise_construct, forward_as_tuple(eastl::move(key)),
-		                                                     forward_as_tuple(eastl::forward<Args>(args)...)));
+		    DoInsertValue(has_unique_keys_type(), value_type(piecewise_construct, eastl::forward_as_tuple(eastl::move(key)),
+		                                                     eastl::forward_as_tuple(eastl::forward<Args>(args)...)));
 
 		return DoGetResultIterator(has_unique_keys_type(), result);
 	}
@@ -2850,7 +2850,7 @@ namespace eastl
 		auto iter = find(k);
 		if(iter == end())
 		{
-			return insert(value_type(piecewise_construct, forward_as_tuple(k), forward_as_tuple(eastl::forward<M>(obj))));
+			return insert(value_type(piecewise_construct, eastl::forward_as_tuple(k), eastl::forward_as_tuple(eastl::forward<M>(obj))));
 		}
 		else
 		{
@@ -2868,7 +2868,7 @@ namespace eastl
 		auto iter = find(k);
 		if(iter == end())
 		{
-			return insert(value_type(piecewise_construct, forward_as_tuple(eastl::move(k)), forward_as_tuple(eastl::forward<M>(obj))));
+			return insert(value_type(piecewise_construct, eastl::forward_as_tuple(eastl::move(k)), eastl::forward_as_tuple(eastl::forward<M>(obj))));
 		}
 		else
 		{

diff --git a/include/EASTL/internal/red_black_tree.h b/include/EASTL/internal/red_black_tree.h
@@ -1105,15 +1105,15 @@ namespace eastl
 	inline eastl::pair<typename rbtree<K, V, C, A, E, bM, bU>::iterator, bool>
 	rbtree<K, V, C, A, E, bM, bU>::try_emplace(const key_type& key, Args&&... args)
 	{
-		return DoInsertValue(has_unique_keys_type(), piecewise_construct, forward_as_tuple(key), forward_as_tuple(eastl::forward<Args>(args)...));
+		return DoInsertValue(has_unique_keys_type(), piecewise_construct, eastl::forward_as_tuple(key), eastl::forward_as_tuple(eastl::forward<Args>(args)...));
 	}
 
 	template <typename K, typename V, typename C, typename A, typename E, bool bM, bool bU>
 	template <class... Args>
 	inline eastl::pair<typename rbtree<K, V, C, A, E, bM, bU>::iterator, bool>
 	rbtree<K, V, C, A, E, bM, bU>::try_emplace(key_type&& key, Args&&... args)
 	{
-		return DoInsertValue(has_unique_keys_type(), piecewise_construct, forward_as_tuple(eastl::move(key)), forward_as_tuple(eastl::forward<Args>(args)...));
+		return DoInsertValue(has_unique_keys_type(), piecewise_construct, eastl::forward_as_tuple(eastl::move(key)), eastl::forward_as_tuple(eastl::forward<Args>(args)...));
 	}
 
 	template <typename K, typename V, typename C, typename A, typename E, bool bM, bool bU>
@@ -1123,7 +1123,7 @@ namespace eastl
 	{
 		return DoInsertValueHint(
 		    has_unique_keys_type(), position,
-		    piecewise_construct, forward_as_tuple(key), forward_as_tuple(eastl::forward<Args>(args)...));
+		    piecewise_construct, eastl::forward_as_tuple(key), eastl::forward_as_tuple(eastl::forward<Args>(args)...));
 	}
 
 	template <typename K, typename V, typename C, typename A, typename E, bool bM, bool bU>
@@ -1133,7 +1133,7 @@ namespace eastl
 	{
 		return DoInsertValueHint(
 		    has_unique_keys_type(), position,
-		    piecewise_construct, forward_as_tuple(eastl::move(key)), forward_as_tuple(eastl::forward<Args>(args)...));
+		    piecewise_construct, eastl::forward_as_tuple(eastl::move(key)), eastl::forward_as_tuple(eastl::forward<Args>(args)...));
 	}
 
 
@@ -1180,7 +1180,7 @@ namespace eastl
 
 		if(iter == end())
 		{
-			return insert(value_type(piecewise_construct, forward_as_tuple(k), forward_as_tuple(eastl::forward<M>(obj))));
+			return insert(value_type(piecewise_construct, eastl::forward_as_tuple(k), eastl::forward_as_tuple(eastl::forward<M>(obj))));
 		}
 		else
 		{
@@ -1198,7 +1198,7 @@ namespace eastl
 
 		if(iter == end())
 		{
-			return insert(value_type(piecewise_construct, forward_as_tuple(eastl::move(k)), forward_as_tuple(eastl::forward<M>(obj))));
+			return insert(value_type(piecewise_construct, eastl::forward_as_tuple(eastl::move(k)), eastl::forward_as_tuple(eastl::forward<M>(obj))));
 		}
 		else
 		{
@@ -1216,7 +1216,7 @@ namespace eastl
 
 		if(iter == end())
 		{
-			return insert(hint, value_type(piecewise_construct, forward_as_tuple(k), forward_as_tuple(eastl::forward<M>(obj))));
+			return insert(hint, value_type(piecewise_construct, eastl::forward_as_tuple(k), eastl::forward_as_tuple(eastl::forward<M>(obj))));
 		}
 		else
 		{
@@ -1234,7 +1234,7 @@ namespace eastl
 
 		if(iter == end())
 		{
-			return insert(hint, value_type(piecewise_construct, forward_as_tuple(eastl::move(k)), forward_as_tuple(eastl::forward<M>(obj))));
+			return insert(hint, value_type(piecewise_construct, eastl::forward_as_tuple(eastl::move(k)), eastl::forward_as_tuple(eastl::forward<M>(obj))));
 		}
 		else
 		{

diff --git a/include/EASTL/memory.h b/include/EASTL/memory.h
@@ -1390,7 +1390,7 @@ namespace eastl
 	inline void destroy(ForwardIterator first, ForwardIterator last)
 	{
 		for (; first != last; ++first)
-			destroy_at(addressof(*first));
+			eastl::destroy_at(eastl::addressof(*first));
 	}
 
 
@@ -1404,7 +1404,7 @@ namespace eastl
 	ForwardIterator destroy_n(ForwardIterator first, Size n)
 	{
 		for (; n > 0; ++first, --n)
-			destroy_at(addressof(*first));
+			eastl::destroy_at(eastl::addressof(*first));
 
 		return first;
 	}

diff --git a/include/EASTL/optional.h b/include/EASTL/optional.h
@@ -111,7 +111,7 @@ namespace eastl
 			inline explicit optional_storage(in_place_t, Args&&... args)
 			    : engaged(true)
 			{
-				::new (eastl::addressof(val)) T{std::forward<Args>(args)...};
+				::new (eastl::addressof(val)) T{eastl::forward<Args>(args)...};
 			}
 
 			template <typename U,

diff --git a/include/EASTL/sort.h b/include/EASTL/sort.h
@@ -439,7 +439,7 @@ namespace eastl
 
 			if (lastSortedEnd < 1)
 			{
-				lastSortedEnd = is_sorted_until<RandomAccessIterator, StrictWeakOrdering>(first, last, compare) - first;
+				lastSortedEnd = eastl::is_sorted_until<RandomAccessIterator, StrictWeakOrdering>(first, last, compare) - first;
 			}
 
 			// Sort the region unless lastSortedEnd indicates it is already sorted.