refactor(allocation-value): reducing duplications

c0nstexpr · c0nstexpr · commit c664e86cb874 · 2024-04-18T17:31:19.000+08:00
diff --git a/include/stdsharp/memory/allocation_value.h b/include/stdsharp/memory/allocation_value.h
@@ -4,56 +4,81 @@
 #include "allocation_traits.h"
 #include "launder_iterator.h"
 
-namespace stdsharp
+namespace stdsharp::details
 {
-    template<allocator_req Allocator, typename T = Allocator::value_type>
+    template<typename Allocator, typename T>
     struct allocation_value
     {
         using allocation_traits = allocation_traits<Allocator>;
         using allocator_traits = allocation_traits::allocator_traits;
         using allocator_type = allocation_traits::allocator_type;
         using size_type = allocator_traits::size_type;
 
-        static constexpr auto always_equal = true;
-
-        [[nodiscard]] static constexpr auto value_size() noexcept { return sizeof(T); }
-
-        [[nodiscard]] bool operator==(const allocation_value&) const = default;
+        using ctor = allocator_traits::constructor;
+        using dtor = allocator_traits::destructor;
 
         static constexpr auto data = allocation_traits::template data<T>;
         static constexpr auto get = allocation_traits::template get<T>;
 
-    private:
-        using ctor = allocator_traits::constructor;
-        using dtor = allocator_traits::destructor;
-
-        constexpr void size_validate(const auto& allocation) const noexcept
+        constexpr void size_validate(this const auto& t, const auto& allocation) noexcept
         {
             Expects(
-                allocation.size() * sizeof(typename allocation_traits::value_type) >= value_size()
+                allocation.size() * sizeof(typename allocation_traits::value_type) >= t.value_size()
             );
         }
 
-        constexpr void
-            size_validate(const auto& src_allocation, const auto& dst_allocation) const noexcept
+        constexpr void size_validate(
+            this const auto& t,
+            const auto& src_allocation,
+            const auto& dst_allocation
+        ) noexcept
         {
-            size_validate(src_allocation);
-            size_validate(dst_allocation);
+            t.size_validate(src_allocation);
+            t.size_validate(dst_allocation);
         }
 
-    public:
         static constexpr struct default_construct_t
         {
         } default_construct{};
+    };
+}
 
+namespace stdsharp
+{
+    template<allocator_req Allocator, typename T = Allocator::value_type>
+    struct allocation_value : private details::allocation_value<Allocator, T>
+    {
+        using m_base = details::allocation_value<Allocator, T>;
+
+    public:
+        using typename m_base::allocation_traits;
+        using typename m_base::allocator_traits;
+        using typename m_base::allocator_type;
+        using typename m_base::size_type;
+        using typename m_base::default_construct_t;
+        using m_base::default_construct;
+        using m_base::data;
+        using m_base::get;
+
+        static constexpr auto always_equal = true;
+
+        [[nodiscard]] static constexpr auto value_size() noexcept { return sizeof(T); }
+
+        [[nodiscard]] bool operator==(const allocation_value&) const = default;
+
+    private:
+        using typename m_base::ctor;
+        using typename m_base::dtor;
+
+    public:
         constexpr void operator()(
             allocator_type& allocator,
             const allocation<Allocator> auto& allocation,
             const default_construct_t /*unused*/
         ) const noexcept(nothrow_invocable<ctor, allocator_type&, T*>)
             requires std::invocable<ctor, allocator_type&, T*>
         {
-            size_validate(allocation);
+            this->size_validate(allocation);
             ctor{}(allocator, data(allocation));
         }
 
@@ -64,7 +89,7 @@ namespace stdsharp
         ) const noexcept(nothrow_invocable<ctor, allocator_type&, T*, const T&>)
             requires std::invocable<ctor, allocator_type&, T*, const T&>
         {
-            size_validate(src_allocation, dst_allocation);
+            this->size_validate(src_allocation, dst_allocation);
             ctor{}(allocator, data(dst_allocation), get(src_allocation));
         }
 
@@ -75,7 +100,7 @@ namespace stdsharp
         ) const noexcept(nothrow_invocable<ctor, allocator_type&, T*, T>)
             requires std::invocable<ctor, allocator_type&, T*, T>
         {
-            size_validate(src_allocation, dst_allocation);
+            this->size_validate(src_allocation, dst_allocation);
             ctor{}(allocator, data(dst_allocation), cpp_move(get(src_allocation)));
         }
 
@@ -85,7 +110,7 @@ namespace stdsharp
         ) const noexcept(nothrow_copy_assignable<T>)
             requires copy_assignable<T>
         {
-            size_validate(src_allocation, dst_allocation);
+            this->size_validate(src_allocation, dst_allocation);
             get(dst_allocation) = get(src_allocation);
         }
 
@@ -95,7 +120,7 @@ namespace stdsharp
         ) const noexcept(nothrow_move_assignable<T>)
             requires move_assignable<T>
         {
-            size_validate(src_allocation, dst_allocation);
+            this->size_validate(src_allocation, dst_allocation);
             get(dst_allocation) = cpp_move(get(src_allocation));
         }
 
@@ -104,44 +129,34 @@ namespace stdsharp
             const allocation<Allocator> auto& allocation
         ) const noexcept
         {
-            size_validate(allocation);
+            this->size_validate(allocation);
             dtor{}(allocator, data(allocation));
         }
     };
 
     template<allocator_req Allocator, typename T>
-    struct allocation_value<Allocator, T[]> // NOLINT(*-c-arrays)
+    struct allocation_value<Allocator, T[]> :// NOLINT(*-c-arrays)
+        private details::allocation_value<Allocator, T>
     {
-    public:
-        using allocation_traits = allocation_traits<Allocator>;
-        using allocator_traits = allocation_traits::allocator_traits;
-        using allocator_type = allocation_traits::allocator_type;
-        using size_type = allocator_traits::size_type;
+        using m_base = details::allocation_value<Allocator, T>;
 
-        static constexpr auto data = allocation_traits::template data<T>;
-        static constexpr auto get = allocation_traits::template get<T>;
+    public:
+        using typename m_base::allocation_traits;
+        using typename m_base::allocator_traits;
+        using typename m_base::allocator_type;
+        using typename m_base::size_type;
+        using typename m_base::default_construct_t;
+        using m_base::default_construct;
+        using m_base::data;
+        using m_base::get;
 
     private:
-        using ctor = allocator_traits::constructor;
-        using dtor = allocator_traits::destructor;
+        using typename m_base::ctor;
+        using typename m_base::dtor;
         using size_t = std::size_t;
 
         size_t size_;
 
-        constexpr void size_validate(const auto& allocation) const noexcept
-        {
-            Expects(
-                allocation.size() * sizeof(typename allocation_traits::value_type) >= value_size()
-            );
-        }
-
-        constexpr void
-            size_validate(const auto& src_allocation, const auto& dst_allocation) const noexcept
-        {
-            size_validate(src_allocation);
-            size_validate(dst_allocation);
-        }
-
         [[nodiscard]] constexpr auto launder_begin(const auto& allocation) const noexcept
         {
             return launder_iterator{data(allocation)};
@@ -161,20 +176,16 @@ namespace stdsharp
 
         [[nodiscard]] bool operator==(const allocation_value&) const = default;
 
-        static constexpr struct default_construct_t
-        {
-        } default_construct{};
-
         constexpr void operator()(
             allocator_type& allocator,
             const allocation<Allocator> auto& allocation,
             const default_construct_t /*unused*/
         ) const noexcept(nothrow_invocable<ctor, allocator_type&, T*>)
             requires std::invocable<ctor, allocator_type&, T*>
         {
-            size_validate(allocation);
+            this->size_validate(allocation);
 
-            auto p = data(allocation);
+            auto&& p = data(allocation);
             const auto count = size();
             for(size_t i = 0; i < count; ++i, ++p) ctor{}(allocator, p);
         }
@@ -186,9 +197,9 @@ namespace stdsharp
         ) const noexcept(nothrow_invocable<ctor, allocator_type&, T*, const T&>)
             requires std::invocable<ctor, allocator_type&, T*, const T&>
         {
-            size_validate(src_allocation, dst_allocation);
+            this->size_validate(src_allocation, dst_allocation);
 
-            auto dst_begin = data(dst_allocation);
+            auto&& dst_begin = data(dst_allocation);
             const auto& src_begin = launder_begin(src_allocation);
             const auto count = size();
 
@@ -203,9 +214,9 @@ namespace stdsharp
         ) const noexcept(nothrow_invocable<ctor, allocator_type&, T*, T>)
             requires std::invocable<ctor, allocator_type&, T*, T>
         {
-            size_validate(src_allocation, dst_allocation);
+            this->size_validate(src_allocation, dst_allocation);
 
-            auto dst_begin = data(dst_allocation);
+            auto&& dst_begin = data(dst_allocation);
             const auto& src_begin = launder_begin(src_allocation);
             const auto count = size();
 
@@ -219,7 +230,7 @@ namespace stdsharp
         ) const noexcept(nothrow_copy_assignable<T>)
             requires copy_assignable<T>
         {
-            size_validate(src_allocation, dst_allocation);
+            this->size_validate(src_allocation, dst_allocation);
             std::ranges::copy_n( //
                 launder_begin(src_allocation),
                 size(),
@@ -233,7 +244,7 @@ namespace stdsharp
         ) const noexcept(nothrow_move_assignable<T>)
             requires move_assignable<T>
         {
-            size_validate(src_allocation, dst_allocation);
+            this->size_validate(src_allocation, dst_allocation);
             move_n(launder_begin(src_allocation), size(), launder_begin(dst_allocation));
         }
 
@@ -242,9 +253,9 @@ namespace stdsharp
             const allocation<Allocator> auto& allocation
         ) const noexcept
         {
-            size_validate(allocation);
+            this->size_validate(allocation);
 
-            auto iter = launder_begin(allocation);
+            auto&& iter = launder_begin(allocation);
             const auto count = size();
             for(size_t i = 0; i < count; ++i, ++iter) dtor{}(allocator, iter.data());
         }
diff --git a/include/stdsharp/memory/box.h b/include/stdsharp/memory/box.h
@@ -39,7 +39,7 @@ namespace stdsharp::details
             dispatcher<req.move_assign, void, const allocation_type&, const allocation_type&>,
             dispatcher<expr_req::no_exception, void, allocator_type&, const allocation_type&>>;
 
-        using allocation_value = allocation_value<allocator_type, box_traits>;
+        using allocation_value = stdsharp::allocation_value<allocator_type, box_traits>;
 
         using allocations_type = std::array<allocation_type, 1>;
         using callocations_type =
@@ -49,11 +49,11 @@ namespace stdsharp::details
     template<lifetime_req Req, typename Alloc, typename T>
     concept box_type_compatible = std::constructible_from<
         typename box_traits<Req, Alloc>::dispatchers,
-        allocation_value<Alloc, T>,
-        allocation_value<Alloc, T>,
-        allocation_value<Alloc, T>,
-        allocation_value<Alloc, T>,
-        allocation_value<Alloc, T>>;
+        stdsharp::allocation_value<Alloc, T>,
+        stdsharp::allocation_value<Alloc, T>,
+        stdsharp::allocation_value<Alloc, T>,
+        stdsharp::allocation_value<Alloc, T>,
+        stdsharp::allocation_value<Alloc, T>>;
 
     template<lifetime_req Req, typename Alloc, lifetime_req OtherReq>
     concept box_compatible =
