feat(synchronizer): rename concurrent object to

synchronizer

Author: c0nstexpr

include/stdsharp/namespace_alias.h

@@ -6,5 +6,5 @@ namespace std
 
 namespace stdsharp
 {
-    namespace std = std;
+    namespace std = ::std;
 }

include/stdsharp/concurrent_object.h renamed to include/stdsharp/synchronizer.h

@@ -12,7 +12,7 @@ namespace stdsharp
 {
     template<typename T, shared_lockable Lockable = std::shared_mutex>
         requires basic_lockable<Lockable>
-    class concurrent_object
+    class synchronizer
     {
     public:
         using value_type = std::optional<T>;
@@ -22,7 +22,7 @@ namespace stdsharp
             requires copy_assignable<value_type>
         static constexpr void assign_value(
             value_type& object, //
-            const concurrent_object<T, OtherLockable>& other //
+            const synchronizer<T, OtherLockable>& other //
         )
         {
             other.read([&object](const value_type& obj) { object = obj; });
@@ -31,7 +31,7 @@ namespace stdsharp
         template<typename OtherLockable>
             requires move_assignable<value_type>
         static constexpr void
-            assign_value(value_type& object, concurrent_object<T, OtherLockable>&& other)
+            assign_value(value_type& object, synchronizer<T, OtherLockable>&& other)
         {
             cpp_move(other).write([&object](value_type&& obj) { object = cpp_move(obj); });
         }
@@ -40,19 +40,19 @@ namespace stdsharp
         static constexpr bool other_assignable =
             requires(value_type obj) { assign_value(obj, std::declval<Other>()); };
 
-        static constexpr bool copy_assignable = other_assignable<const concurrent_object&>;
-        static constexpr bool move_assignable = other_assignable<concurrent_object>;
+        static constexpr bool copy_assignable = other_assignable<const synchronizer&>;
+        static constexpr bool move_assignable = other_assignable<synchronizer>;
 
         template<typename Other>
             requires(other_assignable<Other>)
-        constexpr concurrent_object(const empty_t, Other&& other)
+        constexpr synchronizer(const empty_t, Other&& other)
         {
             assign_value(object_, cpp_forward(other));
         }
 
         template<typename Other>
             requires(other_assignable<Other>)
-        constexpr concurrent_object& assign_impl(Other&& other)
+        constexpr synchronizer& assign_impl(Other&& other)
         {
             write([&other](value_type& obj) { assign_value(obj, cpp_forward(other)); });
             return *this;
@@ -71,13 +71,13 @@ namespace stdsharp
         struct write_fn
         {
             template<typename Func>
-            constexpr void operator()(concurrent_object&& instance, Func&& func) const
+            constexpr void operator()(synchronizer&& instance, Func&& func) const
             {
                 std::invoke(cpp_forward(func), cpp_move(instance).object_);
             }
 
             template<typename Func>
-            constexpr void operator()(concurrent_object& instance, Func&& func) const
+            constexpr void operator()(synchronizer& instance, Func&& func) const
             {
                 const std::unique_lock lock{instance.lockable()};
                 std::invoke(cpp_forward(func), instance.object_);
@@ -87,18 +87,18 @@ namespace stdsharp
     public:
         using lock_type = Lockable;
 
-        concurrent_object() = default;
+        synchronizer() = default;
 
         template<typename... Args>
             requires std::constructible_from<T, Args...> && std::default_initializable<Lockable>
-        explicit constexpr concurrent_object(Args&&... t_arg): object_(cpp_forward(t_arg)...)
+        explicit constexpr synchronizer(Args&&... t_arg): object_(cpp_forward(t_arg)...)
         {
         }
 
         template<typename... TArgs, typename... LockArgs>
             requires std::constructible_from<T, TArgs...> &&
                          std::constructible_from<Lockable, LockArgs...>
-        explicit constexpr concurrent_object(
+        explicit constexpr synchronizer(
             const std::piecewise_construct_t tag,
             std::tuple<TArgs...> t_arg,
             std::tuple<LockArgs...> lock_arg
@@ -109,48 +109,48 @@ namespace stdsharp
 
         template<typename Other>
             requires(other_assignable<Other>)
-        constexpr concurrent_object(Other&& other): concurrent_object(empty, cpp_forward(other))
+        constexpr synchronizer(Other&& other): synchronizer(empty, cpp_forward(other))
         {
         }
 
-        constexpr concurrent_object(const concurrent_object& other)
+        constexpr synchronizer(const synchronizer& other)
             requires copy_assignable
-            : concurrent_object(empty, other)
+            : synchronizer(empty, other)
         {
         }
 
-        constexpr concurrent_object(concurrent_object&& other) noexcept(false)
+        constexpr synchronizer(synchronizer&& other) noexcept(false)
             requires move_assignable
-            : concurrent_object(empty, cpp_move(other))
+            : synchronizer(empty, cpp_move(other))
         {
         }
 
         template<typename Other>
             requires(other_assignable<Other>)
-        constexpr concurrent_object& operator=(Other&& other)
+        constexpr synchronizer& operator=(Other&& other)
         {
             assign_impl(cpp_forward(other));
             return *this;
         }
 
-        constexpr concurrent_object& operator=(const concurrent_object& other)
+        constexpr synchronizer& operator=(const synchronizer& other)
             requires copy_assignable
         {
             if(this != &other) assign_impl(other);
             return *this;
         }
 
-        constexpr concurrent_object& operator=(concurrent_object&& other) noexcept(false)
+        constexpr synchronizer& operator=(synchronizer&& other) noexcept(false)
             requires move_assignable
         {
             if(this != &other) assign_impl(cpp_move(other));
             return *this;
         }
 
-        ~concurrent_object() = default;
+        ~synchronizer() = default;
 
         template<typename OtherLockable>
-        constexpr void swap(concurrent_object<T, OtherLockable>& other) //
+        constexpr void swap(synchronizer<T, OtherLockable>& other) //
             requires std::swappable_with<
                 value_type,
                 typename std::remove_reference_t<decltype(other)>::value_type // clang-format off
@@ -171,7 +171,7 @@ namespace stdsharp
         template<std::invocable<const value_type> Func>
         constexpr void read(Func&& func) const&&
         {
-            read_fn{}(static_cast<const concurrent_object&&>(*this), cpp_forward(func));
+            read_fn{}(static_cast<const synchronizer&&>(*this), cpp_forward(func));
         }
 
         template<std::invocable<value_type&> Func>
@@ -196,40 +196,32 @@ namespace stdsharp
     };
 
     template<typename T>
-    concurrent_object(T&&) -> concurrent_object<std::decay_t<T>>;
+    synchronizer(T&&) -> synchronizer<std::decay_t<T>>;
 
     namespace reflection
     {
         template<typename T, typename U>
-        inline constexpr auto function<concurrent_object<T, U>> =
-            member<concurrent_object<T, U>>::template func_reflect<"read"_ltr, "write"_ltr>(
+        inline constexpr auto function<synchronizer<T, U>> =
+            member<synchronizer<T, U>>::template func_reflect<"read"_ltr, "write"_ltr>(
                 [](auto&& v, auto&&... args) //
                 noexcept( //
-                    noexcept(
-                        cast_fwd<concurrent_object<T, U>>(cpp_forward(v)).read(cpp_forward(args)...)
+                    noexcept(cast_fwd<synchronizer<T, U>>(cpp_forward(v)).read(cpp_forward(args)...)
                     )
                 ) -> //
                 decltype( //
-                    cast_fwd<concurrent_object<T, U>>(cpp_forward(v)).read(cpp_forward(args)...)
+                    cast_fwd<synchronizer<T, U>>(cpp_forward(v)).read(cpp_forward(args)...)
                 ) //
-                {
-                    return cast_fwd<concurrent_object<T, U>>(cpp_forward(v))
-                        .read(cpp_forward(args)...);
-                },
+                { return cast_fwd<synchronizer<T, U>>(cpp_forward(v)).read(cpp_forward(args)...); },
                 [](auto&& v, auto&&... args) //
                 noexcept( //
                     noexcept( //
-                        cast_fwd<concurrent_object<T, U>>(cpp_forward(v))
-                            .write(cpp_forward(args)...)
+                        cast_fwd<synchronizer<T, U>>(cpp_forward(v)).write(cpp_forward(args)...)
                     )
                 ) -> //
                 decltype( //
-                    cast_fwd<concurrent_object<T, U>>(cpp_forward(v)).write(cpp_forward(args)...)
+                    cast_fwd<synchronizer<T, U>>(cpp_forward(v)).write(cpp_forward(args)...)
                 ) //
-                {
-                    return cast_fwd<concurrent_object<T, U>>(cpp_forward(v))
-                        .write(cpp_forward(args)...);
-                }
+                { return cast_fwd<synchronizer<T, U>>(cpp_forward(v)).write(cpp_forward(args)...); }
             );
     }
 }

tests/CMakeLists.txt

@@ -26,8 +26,8 @@ set(src
     src/type_traits/type_sequence_test.cpp
     src/type_traits/value_sequence_test.cpp
     src/utility/utility_test.cpp
-    src/concurrent_object_test.cpp
-    src/pattern_match_test.cpp)
+    src/pattern_match_test.cpp
+    src/synchronizer_test.cpp)
 
 config_lib(${PROJECT_NAME}Lib INTERFACE)
 

tests/src/concurrent_object_test.cpp

@@ -0,0 +1,50 @@
+#include "test.h"
+#include "stdsharp/synchronizer.h"
+
+using namespace std;
+using namespace fmt;
+using namespace stdsharp;
+
+SCENARIO("synchronizer", "[synchronizer]") // NOLINT
+{
+    struct my_mutex
+    {
+        static constexpr void lock() {}
+
+        static constexpr void unlock() {}
+
+        static constexpr void lock_shared() {}
+
+        static constexpr bool try_lock_shared() { return true; }
+
+        static constexpr void unlock_shared() {}
+    };
+
+    STATIC_REQUIRE(copyable<synchronizer<int>>);
+    STATIC_REQUIRE(movable<synchronizer<int>>);
+
+    STATIC_REQUIRE(default_initializable<synchronizer<int>>);
+    STATIC_REQUIRE(constructible_from<synchronizer<int>, synchronizer<int, my_mutex>>);
+    STATIC_REQUIRE(constructible_from<synchronizer<int>, const synchronizer<int, my_mutex>&>);
+
+    STATIC_REQUIRE(assignable<synchronizer<int>&, synchronizer<int, my_mutex>>);
+    STATIC_REQUIRE(assignable<synchronizer<int>&, const synchronizer<int, my_mutex>&>);
+}
+
+SCENARIO("synchronizer reflection support", "[synchronizer]") // NOLINT
+{
+    using namespace reflection;
+    using namespace stdsharp::literals;
+
+    using concurrent_object_t = synchronizer<int>;
+
+    using function = reflection::function_t<concurrent_object_t>;
+
+    STATIC_REQUIRE( //
+        invocable<
+            function::member_of_t<to_array("read")>,
+            concurrent_object_t,
+            void(const ::std::optional<int>) // clang-format off
+        > // clang-format on
+    );
+}