feat(arrow-operator): implemented

c0nstexpr · c0nstexpr · commit 5e9b92a228b9 · 2024-02-19T15:36:38.000+08:00
diff --git a/include/stdsharp/compare/compare.h b/include/stdsharp/compare/compare.h
@@ -21,7 +21,7 @@ namespace stdsharp
     }
 
     template<typename Fn, typename T, typename U, typename Cat = std::partial_ordering>
-    concept ordering_predicate = ordering_like<Cat> && invocable_r<Fn, Cat, T, U>;
+    concept ordering_predicate = ordering_like<Cat> && regular_invocable_r<Fn, Cat, T, U>;
 
     template<typename Fn, typename T, typename U, typename Cat = std::partial_ordering>
     concept nothrow_ordering_predicate =
diff --git a/include/stdsharp/concepts/concepts.h b/include/stdsharp/concepts/concepts.h
@@ -422,12 +422,12 @@ namespace stdsharp
     concept nothrow_invocable_r = std::is_nothrow_invocable_r_v<ReturnT, Func, Args...>;
 
     template<typename Func, typename ReturnT, typename... Args>
-    concept regular_invocable_r = std::regular_invocable<Func, ReturnT, Args...> &&
-        std::is_invocable_r_v<ReturnT, Func, Args...>;
+    concept regular_invocable_r =
+        std::regular_invocable<Func, Args...> && invocable_r<Func, ReturnT, Args...>;
 
     template<typename Func, typename ReturnT, typename... Args>
-    concept nothrow_regular_invocable_r = std::regular_invocable<Func, ReturnT, Args...> &&
-        nothrow_invocable_r<ReturnT, Func, Args...>;
+    concept nothrow_regular_invocable_r = regular_invocable_r<Func, ReturnT, Args...> &&
+        nothrow_invocable_r<Func,ReturnT,  Args...>;
 
     template<typename Func, typename... Args>
     concept nothrow_predicate = nothrow_invocable_r<Func, bool, Args...>;
diff --git a/include/stdsharp/default_operator.h b/include/stdsharp/default_operator.h
@@ -1,12 +1,12 @@
 #pragma once
 
-#include "utility/cast_to.h"
+#include "stdsharp/concepts/concepts.h"
 #include "type_traits/core_traits.h"
 
 namespace stdsharp
 {
     template<typename T>
-    class default_increase_and_decrease
+    class default_increase
     {
         [[nodiscard]] friend constexpr auto operator++(T& t, int) //
             noexcept(nothrow_copy_constructible<T>&& noexcept(++t))
@@ -28,7 +28,7 @@ namespace stdsharp
     };
 
     template<typename T>
-    class default_arithmetic_operator : default_increase_and_decrease<T>
+    class default_arithmetic_operator : default_increase<T>
     {
         friend constexpr T& operator++(T& t) noexcept(noexcept(t += 1))
             requires requires { t += 1; }
@@ -76,16 +76,49 @@ namespace stdsharp
     template<typename T>
     class default_arrow_operator
     {
-        [[nodiscard]] constexpr decltype(auto) operator->() const noexcept(noexcept(*static_cast<const T&>(*this)))
-            requires dereferenceable<const T&>
+        [[nodiscard]] constexpr decltype(auto) operator->() const
+            noexcept(noexcept(*static_cast<const T&>(*this)))
+            requires dereferenceable<const T>
         {
             return *static_cast<const T&>(*this);
         }
 
-        [[nodiscard]] constexpr decltype(auto) operator->() noexcept(noexcept(*static_cast<T&>(*this)))
-            requires dereferenceable<T&>
+        [[nodiscard]] constexpr decltype(auto) operator->() //
+            noexcept(noexcept(*static_cast<T&>(*this)))
+            requires dereferenceable<T>
         {
             return *static_cast<T&>(*this);
         }
+
+        [[nodiscard]] friend constexpr decltype(auto) operator->*(const T & t, auto&& ptr) //
+            noexcept(noexcept((*t).*cpp_forward(ptr)))
+            requires dereferenceable<const T>
+        {
+            return (*t).*cpp_forward(ptr);
+        }
+
+        [[nodiscard]] friend constexpr decltype(auto) operator->*(T & t, auto&& ptr) //
+            noexcept(noexcept((*t).*cpp_forward(ptr)))
+            requires dereferenceable<T>
+        {
+            return (*t).*cpp_forward(ptr);
+        }
+    };
+
+    template<typename T>
+    class default_subscriptor
+    {
+#if __cpp_multidimensional_subscript >= 202110L
+        [[nodiscard]] constexpr decltype(auto) operator[](auto&& first_arg, auto&&... args) //
+            noexcept( //
+                noexcept(static_cast<const T&>(*this)[cpp_forward(first_arg)][cpp_forward(args)...])
+            )
+            requires requires {
+                static_cast<const T&>(*this)[cpp_forward(first_arg)][cpp_forward(args)...];
+            }
+        {
+            return static_cast<const T&>(*this)[cpp_forward(first_arg)][cpp_forward(args)...];
+        }
+#endif
     };
 }
diff --git a/include/stdsharp/enumeration.h b/include/stdsharp/enumeration.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "utility/auto_cast.h"
-#include "concepts/concepts.h"
 
 namespace stdsharp
 {
diff --git a/include/stdsharp/memory/aligned.h b/include/stdsharp/memory/aligned.h
@@ -1,6 +1,9 @@
 #pragma once
 
+#include <span>
+
 #include "pointer_traits.h"
+#include "../cstdint/cstdint.h"
 
 namespace stdsharp
 {
diff --git a/include/stdsharp/memory/allocation.h b/include/stdsharp/memory/allocation.h
@@ -2,6 +2,7 @@
 
 #include "allocator_traits.h"
 #include "../functional/compose.h"
+#include "../ranges/ranges.h"
 
 namespace stdsharp::details
 {
diff --git a/include/stdsharp/memory/allocation_value.h b/include/stdsharp/memory/allocation_value.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "../algorithm/algorithm.h"
 #include "allocation_traits.h"
 #include "launder_iterator.h"
 
diff --git a/include/stdsharp/memory/allocator_traits.h b/include/stdsharp/memory/allocator_traits.h
@@ -6,6 +6,7 @@
 
 #include "../type_traits/special_member.h"
 #include "../utility/constructor.h"
+#include "../cassert/cassert.h"
 #include "pointer_traits.h"
 
 namespace stdsharp::details
diff --git a/include/stdsharp/memory/pointer_traits.h b/include/stdsharp/memory/pointer_traits.h
@@ -3,6 +3,9 @@
 #include <memory>
 
 #include "../type_traits/object.h"
+#include "../functional/invocables.h"
+#include "../utility/auto_cast.h"
+
 #include "../compilation_config_in.h"
 
 namespace stdsharp
diff --git a/include/stdsharp/ranges/ranges.h b/include/stdsharp/ranges/ranges.h
@@ -1,6 +1,3 @@
-//
-
-//
 #pragma once
 
 #include <ranges>
diff --git a/include/stdsharp/scope.h b/include/stdsharp/scope.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <exception>
 #include <optional>
 
 #include "enumeration.h"
diff --git a/include/stdsharp/type_traits/special_member.h b/include/stdsharp/type_traits/special_member.h
@@ -1,6 +1,7 @@
 #pragma once
 
-#include "../algorithm/algorithm.h"
+#include "../concepts/concepts.h"
+#include "../type_traits/core_traits.h"
 
 namespace stdsharp
 {
@@ -28,27 +29,21 @@ namespace stdsharp
             };
         }
 
-        [[nodiscard]] static constexpr auto trivial() noexcept { return lifetime_req{}; };
+        [[nodiscard]] static constexpr lifetime_req trivial() noexcept { return {}; };
 
-        [[nodiscard]] static constexpr auto normal() noexcept
+        [[nodiscard]] static constexpr lifetime_req normal() noexcept
         {
-            return lifetime_req{
-                .copy_construct = expr_req::well_formed,
-                .copy_assign = expr_req::well_formed
-            };
+            return {.copy_construct = expr_req::well_formed, .copy_assign = expr_req::well_formed};
         }
 
-        [[nodiscard]] static constexpr auto unique() noexcept
+        [[nodiscard]] static constexpr lifetime_req unique() noexcept
         {
-            return lifetime_req{
-                .copy_construct = expr_req::ill_formed,
-                .copy_assign = expr_req::ill_formed
-            };
+            return {.copy_construct = expr_req::ill_formed, .copy_assign = expr_req::ill_formed};
         }
 
-        [[nodiscard]] static constexpr auto ill_formed() noexcept
+        [[nodiscard]] static constexpr lifetime_req ill_formed() noexcept
         {
-            return lifetime_req{
+            return {
                 expr_req::ill_formed,
                 expr_req::ill_formed,
                 expr_req::ill_formed,
@@ -60,23 +55,37 @@ namespace stdsharp
         }
 
     private:
-        [[nodiscard]] constexpr auto to_rng() const noexcept
+        using ordering = std::partial_ordering;
+
+        static constexpr auto cmp_impl(ordering& pre, const ordering next) noexcept
         {
-            return std::array{
-                default_construct,
-                move_construct,
-                copy_construct,
-                move_assign,
-                copy_assign,
-                destruct,
-                swap
-            };
-        }
+            if(is_eq(pre))
+            {
+                pre = next;
+                return true;
+            }
+
+            if(pre != next && is_neq(next))
+            {
+                pre = ordering::unordered;
+                return false;
+            }
+
+            return true;
+        };
 
-        [[nodiscard]] friend constexpr std::partial_ordering
+        [[nodiscard]] friend constexpr ordering
             operator<=>(const lifetime_req left, const lifetime_req right) noexcept
         {
-            return strict_compare(left.to_rng(), right.to_rng());
+            ordering cmp = left.default_construct <=> right.default_construct;
+            cmp_impl(cmp, left.move_construct <=> right.move_construct) || //
+                cmp_impl(cmp, left.copy_construct <=> right.copy_construct) || //
+                cmp_impl(cmp, left.move_assign <=> right.move_assign) || //
+                cmp_impl(cmp, left.copy_assign <=> right.copy_assign) || //
+                cmp_impl(cmp, left.destruct <=> right.destruct) || //
+                cmp_impl(cmp, left.swap <=> right.swap);
+
+            return cmp;
         }
 
         [[nodiscard]] friend constexpr auto
@@ -139,13 +148,15 @@ namespace stdsharp
         {
         }
 
-        constexpr fake_type& operator=(fake_type&& /*unused*/) noexcept(is_noexcept(Req.move_assign))
+        constexpr fake_type& operator=(fake_type&& /*unused*/) noexcept(is_noexcept(Req.move_assign)
+        )
             requires(is_well_formed(Req.move_assign))
         {
             return *this;
         }
 
-        constexpr fake_type& operator=(const fake_type& /*unused*/) noexcept(is_noexcept(Req.copy_assign))
+        constexpr fake_type&
+            operator=(const fake_type& /*unused*/) noexcept(is_noexcept(Req.copy_assign))
             requires(is_well_formed(Req.copy_assign))
         {
             return *this;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -39,7 +39,7 @@ config_exe(${PROJECT_NAME} EXE_SRC ${src})
 
 target_compile_options(
   ${PROJECT_NAME}
-  PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/W4>
+  PUBLIC $<$<CXX_COMPILER_ID:MSVC>:/W4 /wd4459>
          $<$<CXX_COMPILER_ID:Clang>:-Qunused-arguments -ftime-trace
          -fdiagnostics-show-template-tree>)
 target_enable_clang_sanitizer(${PROJECT_NAME} PUBLIC SANITIZER address
diff --git a/tests/src/memory/composed_allocator_test.cpp b/tests/src/memory/composed_allocator_test.cpp
@@ -1,3 +1,5 @@
+#include <ranges>
+
 #include "stdsharp/memory/single_stack_allocator.h"
 #include "stdsharp/memory/composed_allocator.h"
 #include "stdsharp/memory/allocator_reference.h"

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ namespace stdsharp`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`template<typename Fn, typename T, typename U, typename Cat = std::partial_ordering>`
`24`		`- concept ordering_predicate = ordering_like<Cat> && invocable_r<Fn, Cat, T, U>;`
	`24`	`+ concept ordering_predicate = ordering_like<Cat> && regular_invocable_r<Fn, Cat, T, U>;`
`25`	`25`
`26`	`26`	`template<typename Fn, typename T, typename U, typename Cat = std::partial_ordering>`
`27`	`27`	`concept nothrow_ordering_predicate =`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,6 @@`
`1`	`1`	`#pragma once`
`2`	`2`
`3`	`3`	`#include "utility/auto_cast.h"`
`4`		`-#include "concepts/concepts.h"`
`5`	`4`
`6`	`5`	`namespace stdsharp`
`7`	`6`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,9 @@`
`1`	`1`	`#pragma once`
`2`	`2`
	`3`	`+#include <span>`
	`4`	`+`
`3`	`5`	`#include "pointer_traits.h"`
	`6`	`+#include "../cstdint/cstdint.h"`
`4`	`7`
`5`	`8`	`namespace stdsharp`
`6`	`9`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`
`3`	`3`	`#include "allocator_traits.h"`
`4`	`4`	`#include "../functional/compose.h"`
	`5`	`+#include "../ranges/ranges.h"`
`5`	`6`
`6`	`7`	`namespace stdsharp::details`
`7`	`8`	`{`
-Original file line number
+Diff line change
@@ @@ -1,6 +1,3 @@ @@
 -//
+-
 -//
 #pragma once
 #include <ranges>