refactor: simplify code

Author: Cra3z

examples/pipe.cpp

@@ -16,7 +16,7 @@ auto main() -> int {
     io_context context;
     auto [reader, writer] = coio::make_pipe(context.get_scheduler());
     coio::async_scope scope;
-    scope.spawn([](auto r) -> coio::task<> {
+    scope.spawn([](coio::pipe_reader<io_context::scheduler> r) -> coio::task<> {
         try {
             char buffer[128];
             while (true) {
@@ -33,7 +33,7 @@ auto main() -> int {
         }
     }(std::move(reader)));
 
-    scope.spawn([](auto w) -> coio::task<> {
+    scope.spawn([](coio::pipe_writer<io_context::scheduler> w) -> coio::task<> {
         std::string_view messages[]{
           "Lorem ipsum dolor sit amet, consectetur adipiscing elit",
           "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",

include/coio/utils/allocator_resource.h

@@ -4,6 +4,7 @@
 #include <memory_resource>
 #include <cstddef>
 #include <coio/utils/utility.h>
+#include <coio/utils/new_object.h>
 #include <coio/detail/concepts.h>
 #include <coio/detail/suppress_push.h> // IWYU pragma: keep
 
@@ -99,11 +100,7 @@ namespace coio {
                     std::destroy_at(this);
                 }
                 else {
-                    using alloc_t = typename std::allocator_traits<Alloc>::template rebind_alloc<proxied>;
-                    using traits_t = std::allocator_traits<alloc_t>;
-                    alloc_t alloc(alloc_);
-                    traits_t::destroy(alloc, this);
-                    traits_t::deallocate(alloc, this, 1);
+                    coio::delete_object(alloc_, this);
                 }
             }
 
@@ -113,25 +110,13 @@ namespace coio {
     public:
         // ReSharper disable once CppPossiblyUninitializedMember
         template<simple_allocator Alloc>
-        explicit allocator_resource(Alloc alloc) { // NOLINT(*-pro-type-member-init)
-            proxied<Alloc>* location = nullptr;
+        explicit allocator_resource(const Alloc& alloc) { // NOLINT(*-pro-type-member-init)
             if constexpr (is_small_object<proxied<Alloc>>) {
-                location = std::construct_at(reinterpret_cast<proxied<Alloc>*>(storage_), alloc);
+                impl_ = std::construct_at(reinterpret_cast<proxied<Alloc>*>(storage_), alloc);
             }
             else {
-                using alloc_t = typename std::allocator_traits<Alloc>::template rebind_alloc<proxied<Alloc>>;
-                using traits_t = std::allocator_traits<alloc_t>;
-                alloc_t pro_alloc(alloc);
-                location = traits_t::allocate(pro_alloc, 1);
-                try {
-                    traits_t::construct(pro_alloc, location, alloc);
-                }
-                catch (...) {
-                    traits_t::deallocate(pro_alloc, location, 1);
-                    throw;
-                }
+                impl_ = coio::new_object<proxied<Alloc>>(alloc, alloc);
             }
-            impl_ = location;
         }
 
         allocator_resource(const allocator_resource&) = delete;

include/coio/utils/new_object.h

@@ -0,0 +1,32 @@
+#pragma once
+#include <memory>
+#include <utility>
+#include <coio/detail/concepts.h>
+
+namespace coio {
+    template<unqualified_object T, simple_allocator Allocator, typename... Args>
+    [[nodiscard]]
+    COIO_ALWAYS_INLINE auto new_object(const Allocator& allocator, Args&&... args) -> T* {
+        using alloc_t = typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
+        using alloc_traits = std::allocator_traits<alloc_t>;
+        alloc_t alloc(allocator);
+        auto ptr = alloc_traits::allocate(alloc, 1);
+        try {
+            alloc_traits::construct(alloc, ptr, std::forward<Args>(args)...);
+            return ptr;
+        }
+        catch (...) {
+            alloc_traits::deallocate(alloc, ptr, 1);
+            throw;
+        }
+    }
+
+    template<simple_allocator Allocator, typename T>
+    COIO_ALWAYS_INLINE auto delete_object(const Allocator& allocator, T* ptr) noexcept -> void {
+        using alloc_t = typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
+        using alloc_traits = std::allocator_traits<alloc_t>;
+        alloc_t alloc(allocator);
+        alloc_traits::destroy(alloc, ptr);
+        alloc_traits::deallocate(alloc, ptr, 1);
+    }
+}

include/coio/utils/polymorphic_scheduler.h

@@ -3,6 +3,7 @@
 #include <optional>
 #include <coio/detail/concepts.h>
 #include <coio/detail/execution.h>
+#include <coio/utils/new_object.h>
 #include <coio/utils/retain_ptr.h>
 #include <coio/utils/scope_exit.h>
 
@@ -66,10 +67,7 @@ namespace coio {
                 }
 
                 auto delete_self() noexcept -> void override {
-                    using alloc_t = std::allocator_traits<allocator_t>::template rebind_alloc<state_proxy>;
-                    alloc_t al(std::move(alloc));
-                    std::allocator_traits<alloc_t>::destroy(al, this);
-                    std::allocator_traits<alloc_t>::deallocate(al, this, 1);
+                    coio::delete_object(alloc, this);
                 }
 
                 allocator_t alloc;
@@ -99,11 +97,7 @@ namespace coio {
                 }
                 else {
                     auto alloc = detail::get_suitable_allocator(execution::get_env(sndr));
-                    using alloc_t = std::allocator_traits<decltype(alloc)>::template rebind_alloc<state_proxy<Sndr, false>>;
-                    alloc_t al(std::move(alloc));
-                    auto ptr = std::allocator_traits<alloc_t>::allocate(al, 1);
-                    std::allocator_traits<alloc_t>::construct(al, ptr, std::move(sndr), std::move(rcvr));
-                    proxy = ptr;
+                    proxy = coio::new_object<state_proxy<Sndr, false>>(alloc, std::move(sndr), std::move(rcvr));
                 }
             }
 
@@ -251,22 +245,17 @@ namespace coio {
             explicit backend_for(Sched sched, Alloc alloc) noexcept : base(std::move(sched)), alloc(std::move(alloc)) {}
 
             auto do_lose() noexcept -> void override {
-                using alloc_t = std::allocator_traits<Alloc>::template rebind_alloc<backend_for>;
-                alloc_t al(std::move(alloc));
-                std::allocator_traits<alloc_t>::destroy(al, this);
-                std::allocator_traits<alloc_t>::deallocate(al, this, 1);
+                coio::delete_object(alloc, this);
             }
 
             COIO_NO_UNIQUE_ADDRESS Alloc alloc;
         };
 
         template<typename Sched, typename Alloc>
         static auto create_backend(Sched sched, Alloc alloc) -> retain_ptr<backend> {
-            using alloc_t = std::allocator_traits<Alloc>::template rebind_alloc<backend_for<Sched, Alloc>>;
-            alloc_t al(alloc);
-            auto ptr = std::allocator_traits<alloc_t>::allocate(al, 1);
-            std::allocator_traits<alloc_t>::construct(al, ptr, std::move(sched), std::move(alloc));
-            return retain_ptr<backend>(ptr);
+            return retain_ptr<backend>{
+                coio::new_object<backend_for<Sched, Alloc>>(alloc, std::move(sched), std::move(alloc))
+            };
         }
 
     public: