feat: Add overload versions of store/compare_exchange of primitive

Author: FrozenLemonTee

src/primitive/impl.cppm

@@ -22,38 +22,48 @@ private:
       policy::resolve_policy_t<policy::category::type, Policies...>;
   using value_rep_type = underlying::traits<value_type>::rep_type;
 
-  template <underlying_type U>
-  static constexpr bool cross_underlying_constructible_v = [] {
-    using source_value_type = std::remove_cv_t<U>;
+  template <underlying_type Source, underlying_type Target>
+  static constexpr bool policy_allows_underlying_bridge_v = [] {
     using source_rep_type =
-      underlying::traits<source_value_type>::rep_type;
-
+        underlying::traits<std::remove_cv_t<Source>>::rep_type;
+    using target_rep_type =
+        underlying::traits<std::remove_cv_t<Target>>::rep_type;
     if constexpr (std::same_as<type_policy_t, policy::type::strict>) {
       return false;
     } else if constexpr (std::same_as<type_policy_t, policy::type::compatible>) {
-      return underlying::traits<source_value_type>::kind ==
-                 underlying::traits<value_type>::kind &&
-             has_common_rep<source_rep_type, value_rep_type> &&
-             !std::same_as<common_rep_t<source_rep_type, value_rep_type>, void>;
+      return underlying::traits<std::remove_cv_t<Source>>::kind ==
+                 underlying::traits<std::remove_cv_t<Target>>::kind &&
+             has_common_rep<source_rep_type, target_rep_type> &&
+             !std::same_as<common_rep_t<source_rep_type, target_rep_type>, void>;
     } else if constexpr (std::same_as<type_policy_t,
                                       policy::type::transparent>) {
-      return has_common_rep<source_rep_type, value_rep_type> &&
-             !std::same_as<common_rep_t<source_rep_type, value_rep_type>, void>;
+      return has_common_rep<source_rep_type, target_rep_type> &&
+             !std::same_as<common_rep_t<source_rep_type, target_rep_type>, void>;
     } else {
       return false;
     }
   }();
 
   template <underlying_type U>
-  static constexpr auto convert_cross_underlying_(U u) noexcept -> value_type {
-    using source_value_type = std::remove_cv_t<U>;
-    using source_rep_type =
-      underlying::traits<source_value_type>::rep_type;
+  static constexpr bool cross_underlying_constructible_v =
+      policy_allows_underlying_bridge_v<U, value_type>;
 
-    auto const source_rep = underlying::traits<source_value_type>::to_rep(u);
-    auto const target_rep = static_cast<value_rep_type>(
+  template <underlying_type U>
+  static constexpr bool cross_underlying_exchangeable_v =
+      cross_underlying_constructible_v<U> &&
+      policy_allows_underlying_bridge_v<value_type, U>;
+
+  template <underlying_type Target, underlying_type Source>
+  static constexpr auto convert_underlying_(Source source) noexcept -> Target {
+    using source_value_type = std::remove_cv_t<Source>;
+    using source_rep_type = underlying::traits<source_value_type>::rep_type;
+    using target_rep_type =
+        underlying::traits<std::remove_cv_t<Target>>::rep_type;
+
+    auto const source_rep = underlying::traits<source_value_type>::to_rep(source);
+    auto const target_rep = static_cast<target_rep_type>(
         static_cast<source_rep_type>(source_rep));
-    return underlying::traits<value_type>::from_rep(target_rep);
+    return underlying::traits<std::remove_cv_t<Target>>::from_rep(target_rep);
   }
 
 public:
@@ -65,7 +75,7 @@ public:
     requires(!std::same_as<U, value_type> &&
              cross_underlying_constructible_v<U>)
   constexpr explicit primitive(U u) noexcept
-      : value_(convert_cross_underlying_<U>(u)) {}
+      : value_(convert_underlying_<value_type>(u)) {}
 
   constexpr primitive(primitive const &other) noexcept {
     if consteval {
@@ -79,7 +89,7 @@ public:
     requires(!std::same_as<U, value_type>)
   explicit constexpr primitive(primitive<U, Policies...> const &other) noexcept
       requires(cross_underlying_constructible_v<U>)
-      : value_(convert_cross_underlying_<U>(other.load())) {}
+      : value_(convert_underlying_<value_type>(other.load())) {}
 
   constexpr auto operator=(primitive const &other) noexcept -> primitive & {
     if (this == &other) {
@@ -99,7 +109,7 @@ public:
   constexpr auto
   operator=(primitive<U, Policies...> const &other) noexcept -> primitive &
       requires(cross_underlying_constructible_v<U>) {
-    store(convert_cross_underlying_<U>(other.load()));
+    store(convert_underlying_<value_type>(other.load()));
     return *this;
   }
 
@@ -115,7 +125,7 @@ public:
     requires(!std::same_as<U, value_type>)
   explicit constexpr primitive(primitive<U, Policies...> &&other) noexcept
       requires(cross_underlying_constructible_v<U>)
-      : value_(convert_cross_underlying_<U>(other.load())) {}
+      : value_(convert_underlying_<value_type>(other.load())) {}
 
   constexpr auto operator=(primitive &&other) noexcept -> primitive & {
     if (this == &other) {
@@ -135,7 +145,7 @@ public:
   constexpr auto operator=(primitive<U, Policies...> &&other) noexcept
       -> primitive &
       requires(cross_underlying_constructible_v<U>) {
-    store(convert_cross_underlying_<U>(other.load()));
+    store(convert_underlying_<value_type>(other.load()));
     return *this;
   }
 
@@ -155,7 +165,9 @@ public:
     return access_handler_t::load(value_);
   }
 
-  constexpr auto store(value_type desired) noexcept -> void {
+  template <underlying_type U>
+    requires std::same_as<U, value_type>
+  constexpr auto store(U desired) noexcept -> void {
     if consteval {
       value_ = desired;
     } else {
@@ -164,8 +176,16 @@ public:
     }
   }
 
-  constexpr auto compare_exchange(value_type &expected,
-                                  value_type desired) noexcept -> bool {
+  template <underlying_type U>
+    requires(!std::same_as<U, value_type> &&
+             cross_underlying_constructible_v<U>)
+  constexpr auto store(U desired) noexcept -> void {
+    store(convert_underlying_<value_type>(desired));
+  }
+
+  template <underlying_type U>
+    requires std::same_as<U, value_type>
+  constexpr auto compare_exchange(U &expected, U desired) noexcept -> bool {
     if consteval {
       if (value_ != expected) {
         expected = value_;
@@ -179,6 +199,19 @@ public:
     return access_handler_t::compare_exchange(value_, expected, desired);
   }
 
+  template <underlying_type U>
+    requires(!std::same_as<U, value_type> && cross_underlying_exchangeable_v<U>)
+  constexpr auto compare_exchange(U &expected, U desired) noexcept -> bool {
+    auto expected_native = convert_underlying_<value_type>(expected);
+    auto const desired_native = convert_underlying_<value_type>(desired);
+
+    auto const exchanged = compare_exchange(expected_native, desired_native);
+    if (!exchanged) {
+      expected = convert_underlying_<U>(expected_native);
+    }
+    return exchanged;
+  }
+
 private:
   using concurrency_policy_t = policy::resolve_policy_t<
       policy::category::concurrency, Policies...>;