Core/Misc: C++17 cleanups, commit 2, the advstd commit

6 files changed, 14 insertions, 120 deletions

diff --git a/src/common/Cryptography/CryptoGenerics.h b/src/common/Cryptography/CryptoGenerics.h
index baf5e95bcfd..e927139215d 100644
--- a/src/common/Cryptography/CryptoGenerics.h
+++ b/src/common/Cryptography/CryptoGenerics.h
@@ -35,7 +35,7 @@ namespace Trinity
             static typename Cipher::IV GenerateRandomIV()
             {
                 typename Cipher::IV iv;
-                int status = RAND_bytes(advstd::data(iv), advstd::size(iv));
+                int status = RAND_bytes(std::data(iv), std::size(iv));
                 ASSERT(status);
                 return iv;
             }
@@ -49,8 +49,8 @@ namespace Trinity
             template <typename C>
             static void SplitFromBack(std::vector<uint8>& data, C& tail)
             {
-                ASSERT(data.size() >= advstd::size(tail));
-                for (size_t i = 1, N = advstd::size(tail); i <= N; ++i)
+                ASSERT(data.size() >= std::size(tail));
+                for (size_t i = 1, N = std::size(tail); i <= N; ++i)
                 {
                     tail[N - i] = data.back();
                     data.pop_back();
diff --git a/src/common/Encoding/BaseEncoding.h b/src/common/Encoding/BaseEncoding.h
index f1136919da6..ef484015936 100644
--- a/src/common/Encoding/BaseEncoding.h
+++ b/src/common/Encoding/BaseEncoding.h
@@ -32,7 +32,7 @@ template <typename Encoding>
 struct GenericBaseEncoding
 {
     static constexpr std::size_t BITS_PER_CHAR = Encoding::BITS_PER_CHAR;
-    static constexpr std::size_t PAD_TO = advstd::lcm(8u, BITS_PER_CHAR);
+    static constexpr std::size_t PAD_TO = std::lcm(8u, BITS_PER_CHAR);
 
     static_assert(BITS_PER_CHAR < 8, "Encoding parameters are invalid");
 
diff --git a/src/common/Utilities/Containers.h b/src/common/Utilities/Containers.h
index 916a43cbd14..ad3887e2123 100644
--- a/src/common/Utilities/Containers.h
+++ b/src/common/Utilities/Containers.h
@@ -77,10 +77,10 @@ namespace Trinity
         void RandomResize(C& container, std::size_t requestedSize)
         {
             static_assert(std::is_base_of<std::forward_iterator_tag, typename std::iterator_traits<typename C::iterator>::iterator_category>::value, "Invalid container passed to Trinity::Containers::RandomResize");
-            if (advstd::size(container) <= requestedSize)
+            if (std::size(container) <= requestedSize)
                 return;
             auto keepIt = std::begin(container), curIt = std::begin(container);
-            uint32 elementsToKeep = requestedSize, elementsToProcess = advstd::size(container);
+            uint32 elementsToKeep = requestedSize, elementsToProcess = std::size(container);
             while (elementsToProcess)
             {
                 // this element has chance (elementsToKeep / elementsToProcess) of being kept
@@ -119,7 +119,7 @@ namespace Trinity
         inline auto SelectRandomContainerElement(C const& container) -> typename std::add_const<decltype(*std::begin(container))>::type&
         {
             auto it = std::begin(container);
-            std::advance(it, urand(0, uint32(advstd::size(container)) - 1));
+            std::advance(it, urand(0, uint32(std::size(container)) - 1));
             return *it;
         }
 
@@ -152,7 +152,7 @@ namespace Trinity
         auto SelectRandomWeightedContainerElement(C const& container, Fn weightExtractor) -> decltype(std::begin(container))
         {
             std::vector<double> weights;
-            weights.reserve(advstd::size(container));
+            weights.reserve(std::size(container));
             double weightSum = 0.0;
             for (auto& val : container)
             {
@@ -161,7 +161,7 @@ namespace Trinity
                 weightSum += weight;
             }
             if (weightSum <= 0.0)
-                weights.assign(advstd::size(container), 1.0);
+                weights.assign(std::size(container), 1.0);
 
             return SelectRandomWeightedContainerElement(container, weights);
         }
@@ -231,7 +231,7 @@ namespace Trinity
         }
 
         template <typename Container, typename Predicate>
-        std::enable_if_t<advstd::is_move_assignable_v<decltype(*std::declval<Container>().begin())>, void> EraseIf(Container& c, Predicate p)
+        std::enable_if_t<std::is_move_assignable_v<decltype(*std::declval<Container>().begin())>, void> EraseIf(Container& c, Predicate p)
         {
             auto wpos = c.begin();
             for (auto rpos = c.begin(), end = c.end(); rpos != end; ++rpos)
@@ -247,7 +247,7 @@ namespace Trinity
         }
 
         template <typename Container, typename Predicate>
-        std::enable_if_t<!advstd::is_move_assignable_v<decltype(*std::declval<Container>().begin())>, void> EraseIf(Container& c, Predicate p)
+        std::enable_if_t<!std::is_move_assignable_v<decltype(*std::declval<Container>().begin())>, void> EraseIf(Container& c, Predicate p)
         {
             for (auto it = c.begin(); it != c.end();)
             {
diff --git a/src/common/Utilities/EventProcessor.h b/src/common/Utilities/EventProcessor.h
index 304dbb3642c..a64bd4ffc2d 100644
--- a/src/common/Utilities/EventProcessor.h
+++ b/src/common/Utilities/EventProcessor.h
@@ -88,7 +88,7 @@ private:
 };
 
 template<typename T>
-using is_lambda_event = std::enable_if_t<!advstd::is_base_of_v<BasicEvent, std::remove_pointer_t<advstd::remove_cvref_t<T>>>>;
+using is_lambda_event = std::enable_if_t<!std::is_base_of_v<BasicEvent, std::remove_pointer_t<advstd::remove_cvref_t<T>>>>;
 
 class TC_COMMON_API EventProcessor
 {
diff --git a/src/common/Utilities/FuzzyFind.h b/src/common/Utilities/FuzzyFind.h
index ae511456aa3..69dfd351d56 100644
--- a/src/common/Utilities/FuzzyFind.h
+++ b/src/common/Utilities/FuzzyFind.h
@@ -30,7 +30,7 @@ namespace Trinity
         auto FuzzyFindIn(Container const& container, NeedleContainer const& needles, ContainsOperator const& contains = StringContainsStringI, int(*bonus)(decltype((*std::begin(std::declval<Container>())))) = nullptr)
         {
             using IteratorResult = decltype((*std::begin(container)));
-            using MappedType = std::conditional_t<advstd::is_reference_v<IteratorResult>, std::reference_wrapper<std::remove_reference_t<IteratorResult>>, IteratorResult>;
+            using MappedType = std::conditional_t<std::is_reference_v<IteratorResult>, std::reference_wrapper<std::remove_reference_t<IteratorResult>>, IteratorResult>;
             std::multimap<size_t, MappedType, std::greater<size_t>> results;
 
             for (auto outerIt = std::begin(container), outerEnd = std::end(container); outerIt != outerEnd; ++outerIt)
diff --git a/src/common/Utilities/advstd.h b/src/common/Utilities/advstd.h
index 0b51e9bc6dc..fc8221b7314 100644
--- a/src/common/Utilities/advstd.h
+++ b/src/common/Utilities/advstd.h
@@ -19,118 +19,12 @@
 #define TRINITY_ADVSTD_H
 
 #include <cstddef>
-#include <tuple>
 #include <type_traits>
-#include <utility>
 
 // this namespace holds implementations of upcoming stdlib features that our c++ version doesn't have yet
 namespace advstd
 {
-    // C++17 std::apply (constrained to only function pointers, not all callable)
-    template <typename... Ts>
-    using apply_tuple_type = std::tuple<std::remove_cv_t<std::remove_reference_t<Ts>>...>;
-    template <typename R, typename... Ts, std::size_t... I>
-    R apply_impl(R(*func)(Ts...), apply_tuple_type<Ts...>&& args, std::index_sequence<I...>)
-    {
-        return func(std::get<I>(std::forward<apply_tuple_type<Ts...>>(args))...);
-    }
-    template <typename R, typename... Ts>
-    R apply(R(*func)(Ts...), apply_tuple_type<Ts...>&& args)
-    {
-        return apply_impl(func, std::forward<apply_tuple_type<Ts...>>(args), std::index_sequence_for<Ts...>{});
-    }
-
-#define forward_1v(stdname, type) template <typename T> constexpr type stdname ## _v = std::stdname<T>::value
-#define forward_2v(stdname, type) template <typename U, typename V> constexpr type stdname ## _v = std::stdname<U,V>::value
-
-    // C++17 std::is_same_v
-    forward_2v(is_same, bool);
-
-    // C++17 std::is_integral_v
-    forward_1v(is_integral, bool);
-
-    // C++17 std::is_assignable_v
-    forward_2v(is_assignable, bool);
-
-    // C++17 std::is_signed_v
-    forward_1v(is_signed, bool);
-
-    // C++17 std::is_unsigned_v
-    forward_1v(is_unsigned, bool);
-
-    // C++17 std::is_base_of_v
-    forward_2v(is_base_of, bool);
-
-    // C++17 std::is_floating_point_v
-    forward_1v(is_floating_point, bool);
-
-    // C++17 std::is_pointer_v
-    forward_1v(is_pointer, bool);
-
-    // C++17 std::is_reference_v
-    forward_1v(is_reference, bool);
-
-    // C++17 std::tuple_size_v
-    forward_1v(tuple_size, size_t);
-
-    // C++17 std::is_enum_v
-    forward_1v(is_enum, bool);
-
-    // C++17 std::is_arithmetic_v
-    forward_1v(is_arithmetic, bool);
-
-    // C++17 std::is_move_assignable_v
-    forward_1v(is_move_assignable, bool);
-
-#undef forward_1v
-#undef forward_2v
-
-    // C++17 std::size
-    template <typename C>
-    constexpr auto size(const C& c) { return c.size(); }
-
-    template <typename T, std::size_t N>
-    constexpr std::size_t size(const T(&)[N]) noexcept { return N; }
-
-    // C++17 std::data
-    template <typename C>
-    constexpr auto data(C& c) { return c.data(); }
-
-    template <typename C>
-    constexpr auto data(C const& c) { return c.data(); }
-
-    template <typename T, std::size_t N>
-    constexpr T* data(T(&a)[N]) noexcept { return a; }
-
-    template <typename T, std::size_t N>
-    constexpr T const* data(const T(&a)[N]) noexcept { return a; }
-
-    template <typename T>
-    constexpr T const* data(std::initializer_list<T> l) noexcept { return l.begin(); }
-
-    // C++17 std::gcd
-    template <typename T1, typename T2>
-    constexpr std::enable_if_t<advstd::is_unsigned_v<T1> && advstd::is_unsigned_v<T2>, std::common_type_t<T1, T2>> gcd(T1 _m, T2 _n)
-    {
-        using T = std::common_type_t<T1, T2>;
-        T n=_n, m=_m;
-        while (n)
-        {
-            T o = m;
-            m = n;
-            n = o%n;
-        }
-        return m;
-    }
-
-    // C++17 std::lcm
-    template <typename T1, typename T2>
-    constexpr std::enable_if_t<advstd::is_unsigned_v<T1> && advstd::is_unsigned_v<T2>, std::common_type_t<T1, T2>> lcm(T1 m, T2 n)
-    {
-        return (m/gcd(m, n))*n;
-    }
-
-    // C++20 std::remove_cvref_t
+    // C++20 advstd::remove_cvref_t
     template <class T>
     using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
 }