Merge branch 'develop'

c0nstexpr · May 26, 2023 · c1e807f · c1e807f
2 parents 4575239 + 95a541b
commit c1e807f
Show file tree

Hide file tree

Showing 55 changed files with 1,281 additions and 1,271 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -7,7 +7,7 @@ include(cmake/Utils.cmake)
 #
 project(
   stdsharp
-  VERSION 0.6.1
+  VERSION 0.6.2
   LANGUAGES CXX)
 
 config_lib(${PROJECT_NAME} INTERFACE STD 23)

diff --git a/include/stdsharp/algorithm/algorithm.h b/include/stdsharp/algorithm/algorithm.h
@@ -10,32 +10,32 @@
 
 namespace stdsharp
 {
-    inline constexpr auto set_if = []<typename T, typename U, ::std::predicate<U, T> Comp>
-        requires ::std::assignable_from<T&, U> // clang-format off
+    inline constexpr auto set_if = []<typename T, typename U, std::predicate<U, T> Comp>
+        requires std::assignable_from<T&, U> // clang-format off
         (T& left, U&& right, Comp comp = {})
         noexcept(nothrow_predicate<Comp, U, T> && nothrow_assignable_from<T&, U>)
         -> T& // clang-format on
     {
-        if(::std::invoke(cpp_move(comp), right, left)) left = cpp_forward(right);
+        if(std::invoke(cpp_move(comp), right, left)) left = cpp_forward(right);
         return left;
     };
 
     using set_if_fn = decltype(set_if);
 
     inline constexpr auto set_if_greater = []<typename T, typename U>
-        requires ::std::invocable<set_if_fn, T&, U, ::std::ranges::greater> // clang-format off
+        requires std::invocable<set_if_fn, T&, U, std::ranges::greater> // clang-format off
         (T & left, U && right)
-        noexcept(nothrow_invocable<set_if_fn, T&, U, ::std::ranges::greater>) -> T& // clang-format on
+        noexcept(nothrow_invocable<set_if_fn, T&, U, std::ranges::greater>) -> T& // clang-format on
     {
         return set_if(left, cpp_forward(right), greater_v);
     };
 
     using set_if_greater_fn = decltype(set_if_greater);
 
     inline constexpr auto set_if_less = []<typename T, typename U>
-        requires ::std::invocable<set_if_fn, T&, U, ::std::ranges::less> // clang-format off
+        requires std::invocable<set_if_fn, T&, U, std::ranges::less> // clang-format off
         (T& left, U&& right)
-        noexcept(nothrow_invocable<set_if_fn, T&, U, ::std::ranges::less>) -> T& // clang-format on
+        noexcept(nothrow_invocable<set_if_fn, T&, U, std::ranges::less>) -> T& // clang-format on
     {
         return set_if(left, cpp_forward(right), less_v);
     };
@@ -46,9 +46,9 @@ namespace stdsharp
     {
         template<
             typename T,
-            typename Proj = ::std::identity,
-            ::std::indirect_strict_weak_order<::std::projected<const T*, Proj>> Compare =
-                ::std::ranges::less // clang-format off
+            typename Proj = std::identity,
+            std::indirect_strict_weak_order<std::projected<const T*, Proj>> Compare =
+                std::ranges::less // clang-format off
         > // clang-format on
         [[nodiscard]] constexpr auto operator()( // NOLINTBEGIN(*-easily-swappable-parameters)
             const T& t,
@@ -61,33 +61,33 @@ namespace stdsharp
                 !is_debug ||
                 nothrow_predicate<
                     Compare,
-                    ::std::projected<const T*, Proj>,
-                    ::std::projected<const T*, Proj> // clang-format off
+                    std::projected<const T*, Proj>,
+                    std::projected<const T*, Proj> // clang-format off
                 > // clang-format on
             )
         {
-            const auto& proj_max = ::std::invoke(proj, max);
-            const auto& proj_min = ::std::invoke(proj, min);
-            const auto& proj_t = ::std::invoke(proj, t);
+            const auto& proj_max = std::invoke(proj, max);
+            const auto& proj_min = std::invoke(proj, min);
+            const auto& proj_t = std::invoke(proj, t);
 
-            precondition<::std::invalid_argument>(
-                [&] { return !::std::invoke(cmp, proj_max, proj_min); },
+            precondition<std::invalid_argument>(
+                [&] { return !std::invoke(cmp, proj_max, proj_min); },
                 "max value should not less than min value"
             );
 
-            return !::std::invoke(cmp, proj_t, proj_min) && !::std::invoke(cmp, proj_max, proj_t);
+            return !std::invoke(cmp, proj_t, proj_min) && !std::invoke(cmp, proj_max, proj_t);
         }
     } is_between{};
 
     constexpr struct strict_compare_fn
     {
-        template<::std::ranges::input_range TRng, ::std::ranges::input_range URng>
-            requires ::std::three_way_comparable_with<
+        template<std::ranges::input_range TRng, std::ranges::input_range URng>
+            requires std::three_way_comparable_with<
                 range_const_reference_t<TRng>,
                 range_const_reference_t<URng>>
         constexpr auto operator()(const TRng& left, const URng& right) const
         {
-            using ordering = ::std::partial_ordering;
+            using ordering = std::partial_ordering;
 
             auto pre = ordering::equivalent;
             const auto cmp_impl = [](ordering& pre, const ordering next)
@@ -106,10 +106,10 @@ namespace stdsharp
             };
 
             {
-                auto l_it = ::std::ranges::cbegin(left);
-                auto r_it = ::std::ranges::cbegin(right);
-                const auto l_end = ::std::ranges::cend(left);
-                const auto r_end = ::std::ranges::cend(right);
+                auto l_it = std::ranges::cbegin(left);
+                auto r_it = std::ranges::cbegin(right);
+                const auto l_end = std::ranges::cend(left);
+                const auto r_end = std::ranges::cend(right);
                 for(; !is_ud(pre); ++l_it, ++r_it)
                 {
                     if(l_it == l_end)
@@ -124,7 +124,7 @@ namespace stdsharp
                         break;
                     }
 
-                    cmp_impl(pre, ::std::compare_three_way{}(*l_it, *r_it));
+                    cmp_impl(pre, std::compare_three_way{}(*l_it, *r_it));
                 }
             }
 

diff --git a/include/stdsharp/array/array.h b/include/stdsharp/array/array.h
@@ -8,27 +8,27 @@
 
 namespace stdsharp
 {
-    template<::std::size_t N>
+    template<std::size_t N>
     struct range_to_array_fn
     {
-        template<typename Rng, typename Proj = ::std::identity>
+        template<typename Rng, typename Proj = std::identity>
         constexpr auto operator()(Rng&& rng, Proj proj = {}) const
         {
-            using value_type = ::std::projected<::std::ranges::iterator_t<Rng>, Proj>::value_type;
+            using value_type = std::projected<std::ranges::iterator_t<Rng>, Proj>::value_type;
 
-            ::std::array<value_type, N> arr{};
+            std::array<value_type, N> arr{};
 
-            ::std::ranges::copy(
+            std::ranges::copy(
                 cpp_forward(rng) | //
-                    ::std::views::transform(proj) | //
-                    ::std::views::take(N),
+                    std::views::transform(proj) | //
+                    std::views::take(N),
                 arr.begin()
             );
 
             return arr;
         }
     };
 
-    template<::std::size_t N>
+    template<std::size_t N>
     inline constexpr range_to_array_fn<N> range_to_array{};
 }
diff --git a/include/stdsharp/cassert/cassert.h b/include/stdsharp/cassert/cassert.h
@@ -16,18 +16,18 @@ namespace stdsharp
         ;
 
     template<typename Exception, typename Predicate, typename... Args>
-        requires ::std::constructible_from<Exception, Args...> &&
-        ::std::predicate<const Predicate&> && is_debug
+        requires std::constructible_from<Exception, Args...> && std::predicate<const Predicate&> &&
+        is_debug
     constexpr void precondition(const Predicate& predicate, Args&&... args)
     {
-        ::std::invoke(predicate) ? void() : throw Exception{static_cast<Args&&>(args)...}; // NOLINT
+        std::invoke(predicate) ? void() : throw Exception{static_cast<Args&&>(args)...}; // NOLINT
     }
 
     template<typename, typename Predicate>
-        requires ::std::predicate<const Predicate&>
+        requires std::predicate<const Predicate&>
     constexpr void precondition([[maybe_unused]] const Predicate& predicate, auto&&...) noexcept
     {
-        STDSHARP_ASSUME(::std::invoke(predicate));
+        STDSHARP_ASSUME(std::invoke(predicate));
     }
 }
 

diff --git a/include/stdsharp/cmath/cmath.h b/include/stdsharp/cmath/cmath.h
@@ -5,7 +5,7 @@
 
 namespace stdsharp
 {
-    constexpr auto ceil_reminder(const ::std::integral auto x, decltype(x) y) noexcept
+    constexpr auto ceil_reminder(const std::integral auto x, decltype(x) y) noexcept
     {
         return (x + y - 1) / y;
     }

diff --git a/include/stdsharp/compare/compare.h b/include/stdsharp/compare/compare.h
@@ -4,8 +4,8 @@
 
 namespace stdsharp
 {
-    constexpr bool is_ud(const ::std::partial_ordering c) noexcept
+    constexpr bool is_ud(const std::partial_ordering c) noexcept
     {
-        return c == ::std::partial_ordering::unordered;
+        return c == std::partial_ordering::unordered;
     }
 }