🎨 Add ct_string deduction guide for {atomic_}bitset

Author: elbeno

include/stdx/atomic_bitset.hpp

@@ -4,6 +4,7 @@
 #include <stdx/bitset.hpp>
 #include <stdx/compiler.hpp>
 #include <stdx/concepts.hpp>
+#include <stdx/ct_string.hpp>
 #include <stdx/detail/bitset_common.hpp>
 #include <stdx/type_traits.hpp>
 #include <stdx/udls.hpp>
@@ -17,49 +18,52 @@
 
 namespace stdx {
 inline namespace v1 {
-namespace detail {
-template <std::size_t N, typename StorageElem> class atomic_bitset {
-    constexpr static auto bit = StorageElem{1U};
+template <auto Size, typename StorageElem =
+                         decltype(smallest_uint<to_underlying(Size), void>())>
+class atomic_bitset {
+    constexpr static std::size_t N = to_underlying(Size);
+    using elem_t = StorageElem;
 
-    static_assert(N <= std::numeric_limits<StorageElem>::digits,
+    constexpr static auto bit = elem_t{1U};
+
+    static_assert(N <= std::numeric_limits<elem_t>::digits,
                   "atomic_bitset is limited to a single storage element");
-    static_assert(std::atomic<StorageElem>::is_always_lock_free,
-                  "atomic_bitset must always be lock free");
-    std::atomic<StorageElem> storage{};
+    std::atomic<elem_t> storage{};
 
-    constexpr static auto mask = bit_mask<StorageElem, N - 1>();
-    StorageElem salient_value(std::memory_order order) const {
+    constexpr static auto mask = bit_mask<elem_t, N - 1>();
+    elem_t salient_value(std::memory_order order) const {
         return storage.load(order) & mask;
     }
 
-    [[nodiscard]] static constexpr auto
-    value_from_string(std::string_view str, std::size_t pos, std::size_t n,
-                      char one) -> StorageElem {
-        StorageElem ret{};
+    [[nodiscard]] static constexpr auto value_from_string(std::string_view str,
+                                                          std::size_t pos,
+                                                          std::size_t n,
+                                                          char one) -> elem_t {
+        elem_t ret{};
         auto const len = std::min(n, str.size() - pos);
         auto const s = str.substr(pos, std::min(len, N));
         auto i = bit;
         for (auto it = std::rbegin(s); it != std::rend(s); ++it) {
             if (*it == one) {
                 ret |= i;
             }
-            i = static_cast<StorageElem>(i << 1u);
+            i = static_cast<elem_t>(i << 1u);
         }
         return ret;
     }
 
-    using bitset_t = bitset<N, StorageElem>;
+    using bitset_t = bitset<Size, elem_t>;
 
   public:
     constexpr atomic_bitset() = default;
     constexpr explicit atomic_bitset(std::uint64_t value)
-        : storage{static_cast<StorageElem>(value & mask)} {}
+        : storage{static_cast<elem_t>(value & mask)} {}
 
     template <typename... Bs>
     constexpr explicit atomic_bitset(place_bits_t, Bs... bs)
-        : storage{static_cast<StorageElem>(
-              (StorageElem{} | ... |
-               static_cast<StorageElem>(bit << to_underlying(bs))))} {}
+        : storage{static_cast<elem_t>(
+              (elem_t{} | ... |
+               static_cast<elem_t>(bit << to_underlying(bs))))} {}
 
     constexpr explicit atomic_bitset(all_bits_t) : storage{mask} {}
 
@@ -68,6 +72,11 @@ template <std::size_t N, typename StorageElem> class atomic_bitset {
                                      char one = '1')
         : storage{value_from_string(str, pos, n, one)} {}
 
+#if __cplusplus >= 202002L
+    constexpr explicit atomic_bitset(ct_string<N + 1> s)
+        : atomic_bitset{static_cast<std::string_view>(s)} {}
+#endif
+
     template <typename T>
     [[nodiscard]] auto
     to(std::memory_order order = std::memory_order_seq_cst) const -> T {
@@ -93,13 +102,13 @@ template <std::size_t N, typename StorageElem> class atomic_bitset {
     }
     auto store(bitset_t b,
                std::memory_order order = std::memory_order_seq_cst) {
-        storage.store(b.template to<StorageElem>(), order);
+        storage.store(b.template to<elem_t>(), order);
     }
 
     constexpr static std::integral_constant<std::size_t, N> size{};
 
     constexpr static std::bool_constant<
-        std::atomic<StorageElem>::is_always_lock_free>
+        std::atomic<elem_t>::is_always_lock_free>
         is_always_lock_free{};
 
     template <typename T> [[nodiscard]] auto operator[](T idx) const -> bool {
@@ -113,17 +122,17 @@ template <std::size_t N, typename StorageElem> class atomic_bitset {
         auto const pos = static_cast<std::size_t>(to_underlying(idx));
         if (value) {
             return bitset_t{
-                storage.fetch_or(static_cast<StorageElem>(bit << pos), order)};
+                storage.fetch_or(static_cast<elem_t>(bit << pos), order)};
         }
         return bitset_t{
-            storage.fetch_and(static_cast<StorageElem>(~(bit << pos)), order)};
+            storage.fetch_and(static_cast<elem_t>(~(bit << pos)), order)};
     }
 
     auto set(lsb_t lsb, msb_t msb, bool value = true,
              std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
         auto const l = to_underlying(lsb);
         auto const m = to_underlying(msb);
-        auto const shifted_value = bit_mask<StorageElem>(m, l);
+        auto const shifted_value = bit_mask<elem_t>(m, l);
         if (value) {
             return bitset_t{storage.fetch_or(shifted_value, order)};
         }
@@ -145,13 +154,12 @@ template <std::size_t N, typename StorageElem> class atomic_bitset {
 
     template <typename T> auto reset(T idx) -> bitset_t {
         auto const pos = static_cast<std::size_t>(to_underlying(idx));
-        return bitset_t{
-            storage.fetch_and(static_cast<StorageElem>(~(bit << pos)))};
+        return bitset_t{storage.fetch_and(static_cast<elem_t>(~(bit << pos)))};
     }
 
     auto reset(std::memory_order order = std::memory_order_seq_cst)
         LIFETIMEBOUND -> atomic_bitset & {
-        storage.store(StorageElem{}, order);
+        storage.store(elem_t{}, order);
         return *this;
     }
 
@@ -172,7 +180,7 @@ template <std::size_t N, typename StorageElem> class atomic_bitset {
               std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
         auto const pos = static_cast<std::size_t>(to_underlying(idx));
         return bitset_t{
-            storage.fetch_xor(static_cast<StorageElem>(bit << pos), order)};
+            storage.fetch_xor(static_cast<elem_t>(bit << pos), order)};
     }
 
     auto flip(std::memory_order order = std::memory_order_seq_cst) -> bitset_t {
@@ -198,10 +206,9 @@ template <std::size_t N, typename StorageElem> class atomic_bitset {
         return static_cast<std::size_t>(popcount(salient_value(order)));
     }
 };
-} // namespace detail
 
-template <auto N, typename StorageElem = void>
-using atomic_bitset = detail::atomic_bitset<
-    to_underlying(N), decltype(smallest_uint<to_underlying(N), StorageElem>())>;
+#if __cplusplus >= 202002L
+template <std::size_t N> atomic_bitset(ct_string<N>) -> atomic_bitset<N - 1>;
+#endif
 } // namespace v1
 } // namespace stdx

include/stdx/bitset.hpp

@@ -3,6 +3,7 @@
 #include <stdx/bit.hpp>
 #include <stdx/compiler.hpp>
 #include <stdx/concepts.hpp>
+#include <stdx/ct_string.hpp>
 #include <stdx/detail/bitset_common.hpp>
 #include <stdx/type_traits.hpp>
 #include <stdx/udls.hpp>
@@ -18,25 +19,29 @@
 
 namespace stdx {
 inline namespace v1 {
-namespace detail {
-template <std::size_t N, typename StorageElem> class bitset {
+template <auto Size, typename StorageElem =
+                         decltype(smallest_uint<to_underlying(Size), void>())>
+class bitset {
+    constexpr static std::size_t N = to_underlying(Size);
+    using elem_t = StorageElem;
+
     constexpr static auto storage_elem_size =
-        std::numeric_limits<StorageElem>::digits;
+        std::numeric_limits<elem_t>::digits;
     constexpr static auto storage_size =
         (N + storage_elem_size - 1) / storage_elem_size;
-    constexpr static auto bit = StorageElem{1U};
-    constexpr static auto allbits = std::numeric_limits<StorageElem>::max();
+    constexpr static auto bit = elem_t{1U};
+    constexpr static auto allbits = std::numeric_limits<elem_t>::max();
 
-    std::array<StorageElem, storage_size> storage{};
+    std::array<elem_t, storage_size> storage{};
 
-    constexpr static auto lastmask = []() -> StorageElem {
+    constexpr static auto lastmask = []() -> elem_t {
         if constexpr (N % storage_elem_size != 0) {
             return allbits >> (storage_elem_size - N % storage_elem_size);
         } else {
             return allbits;
         }
     }();
-    constexpr auto highbits() const -> StorageElem {
+    constexpr auto highbits() const -> elem_t {
         return storage.back() & lastmask;
     }
 
@@ -99,21 +104,21 @@ template <std::size_t N, typename StorageElem> class bitset {
         for (auto e : storage) {
             while (e != 0) {
                 auto const offset = static_cast<std::size_t>(countr_zero(e));
-                e &= static_cast<StorageElem>(~(bit << offset));
+                e &= static_cast<elem_t>(~(bit << offset));
                 f(i + offset);
             }
-            i += std::numeric_limits<StorageElem>::digits;
+            i += std::numeric_limits<elem_t>::digits;
         }
         return std::forward<F>(f);
     }
 
-    template <typename F, std::size_t M, typename... S>
+    template <typename F, auto M, typename... S>
     friend constexpr auto for_each(F &&f, bitset<M, S> const &...bs) -> F;
 
   public:
     constexpr bitset() = default;
     constexpr explicit bitset(std::uint64_t value) {
-        if constexpr (std::is_same_v<StorageElem, std::uint64_t>) {
+        if constexpr (std::is_same_v<elem_t, std::uint64_t>) {
             storage[0] = value;
         } else {
             for (auto &elem : storage) {
@@ -151,14 +156,19 @@ template <std::size_t N, typename StorageElem> class bitset {
         }
     }
 
+#if __cplusplus >= 202002L
+    constexpr explicit bitset(ct_string<N + 1> s)
+        : bitset{static_cast<std::string_view>(s)} {}
+#endif
+
     template <typename T> [[nodiscard]] constexpr auto to() const -> T {
         using U = underlying_type_t<T>;
         static_assert(
             unsigned_integral<U>,
             "Conversion must be to an unsigned integral type or enum!");
         static_assert(N <= std::numeric_limits<U>::digits,
                       "Bitset too big for conversion to T");
-        if constexpr (std::is_same_v<StorageElem, U>) {
+        if constexpr (std::is_same_v<elem_t, U>) {
             return static_cast<T>(storage[0] & lastmask);
         } else {
             U result{highbits()};
@@ -191,9 +201,9 @@ template <std::size_t N, typename StorageElem> class bitset {
         auto const pos = static_cast<std::size_t>(to_underlying(idx));
         auto const [index, offset] = indices(pos);
         if (value) {
-            storage[index] |= static_cast<StorageElem>(bit << offset);
+            storage[index] |= static_cast<elem_t>(bit << offset);
         } else {
-            storage[index] &= static_cast<StorageElem>(~(bit << offset));
+            storage[index] &= static_cast<elem_t>(~(bit << offset));
         }
         return *this;
     }
@@ -205,25 +215,25 @@ template <std::size_t N, typename StorageElem> class bitset {
         auto [l_index, l_offset] = indices(l);
         auto const [m_index, m_offset] = indices(m);
 
-        using setfn = auto (*)(StorageElem *, StorageElem)->void;
+        using setfn = auto (*)(elem_t *, elem_t)->void;
         auto const fn = [&]() -> setfn {
             if (value) {
-                return [](StorageElem *ptr, StorageElem val) { *ptr |= val; };
+                return [](elem_t *ptr, elem_t val) { *ptr |= val; };
             }
-            return [](StorageElem *ptr, StorageElem val) { *ptr &= ~val; };
+            return [](elem_t *ptr, elem_t val) { *ptr &= ~val; };
         }();
 
-        auto l_mask = std::numeric_limits<StorageElem>::max() << l_offset;
+        auto l_mask = std::numeric_limits<elem_t>::max() << l_offset;
         if (l_index != m_index) {
-            fn(&storage[l_index++], static_cast<StorageElem>(l_mask));
-            l_mask = std::numeric_limits<StorageElem>::max();
+            fn(&storage[l_index++], static_cast<elem_t>(l_mask));
+            l_mask = std::numeric_limits<elem_t>::max();
         }
         while (l_index != m_index) {
-            fn(&storage[l_index++], static_cast<StorageElem>(l_mask));
+            fn(&storage[l_index++], static_cast<elem_t>(l_mask));
         }
-        auto const m_mask = std::numeric_limits<StorageElem>::max() >>
+        auto const m_mask = std::numeric_limits<elem_t>::max() >>
                             (storage_elem_size - m_offset - 1);
-        fn(&storage[l_index], static_cast<StorageElem>(l_mask & m_mask));
+        fn(&storage[l_index], static_cast<elem_t>(l_mask & m_mask));
         return *this;
     }
 
@@ -245,7 +255,7 @@ template <std::size_t N, typename StorageElem> class bitset {
     constexpr auto reset(T idx) LIFETIMEBOUND -> bitset & {
         auto const pos = static_cast<std::size_t>(to_underlying(idx));
         auto const [index, offset] = indices(pos);
-        storage[index] &= static_cast<StorageElem>(~(bit << offset));
+        storage[index] &= static_cast<elem_t>(~(bit << offset));
         return *this;
     }
 
@@ -267,7 +277,7 @@ template <std::size_t N, typename StorageElem> class bitset {
     template <typename T> constexpr auto flip(T idx) LIFETIMEBOUND -> bitset & {
         auto const pos = static_cast<std::size_t>(to_underlying(idx));
         auto const [index, offset] = indices(pos);
-        storage[index] ^= static_cast<StorageElem>(bit << offset);
+        storage[index] ^= static_cast<elem_t>(bit << offset);
         return *this;
     }
 
@@ -310,10 +320,10 @@ template <std::size_t N, typename StorageElem> class bitset {
         std::size_t i = 0;
         for (auto e : storage) {
             if (auto offset = static_cast<std::size_t>(countr_one(e));
-                offset != std::numeric_limits<StorageElem>::digits) {
+                offset != std::numeric_limits<elem_t>::digits) {
                 return i + offset;
             }
-            i += std::numeric_limits<StorageElem>::digits;
+            i += std::numeric_limits<elem_t>::digits;
         }
         return i;
     }
@@ -358,13 +368,13 @@ template <std::size_t N, typename StorageElem> class bitset {
         } else {
             auto const borrow_shift = storage_elem_size - pos;
             for (auto i = start; i > std::size_t{}; --i) {
-                storage[dst] = static_cast<StorageElem>(storage[i] << pos);
+                storage[dst] = static_cast<elem_t>(storage[i] << pos);
                 storage[dst] |=
-                    static_cast<StorageElem>(storage[i - 1] >> borrow_shift);
+                    static_cast<elem_t>(storage[i - 1] >> borrow_shift);
                 --dst;
             }
         }
-        storage[dst] = static_cast<StorageElem>(storage.front() << pos);
+        storage[dst] = static_cast<elem_t>(storage.front() << pos);
         while (dst > std::size_t{}) {
             storage[--dst] = 0;
         }
@@ -384,21 +394,21 @@ template <std::size_t N, typename StorageElem> class bitset {
         } else {
             auto const borrow_shift = storage_elem_size - pos;
             for (auto i = start; i < storage_size - 1; ++i) {
-                storage[dst] = static_cast<StorageElem>(storage[i] >> pos);
+                storage[dst] = static_cast<elem_t>(storage[i] >> pos);
                 storage[dst] |=
-                    static_cast<StorageElem>(storage[i + 1] << borrow_shift);
+                    static_cast<elem_t>(storage[i + 1] << borrow_shift);
                 ++dst;
             }
         }
-        storage[dst++] = static_cast<StorageElem>(storage.back() >> pos);
+        storage[dst++] = static_cast<elem_t>(storage.back() >> pos);
         while (dst < storage_size) {
             storage[dst++] = 0;
         }
         return *this;
     }
 };
 
-template <typename F, std::size_t M, typename... S>
+template <typename F, auto M, typename... S>
 constexpr auto for_each(F &&f, bitset<M, S> const &...bs) -> F {
     if constexpr (sizeof...(bs) == 1) {
         return (bs.for_each(std::forward<F>(f)), ...);
@@ -407,12 +417,9 @@ constexpr auto for_each(F &&f, bitset<M, S> const &...bs) -> F {
         return f;
     }
 }
-} // namespace detail
-
-template <auto N, typename StorageElem = void>
-using bitset =
-    detail::bitset<to_underlying(N),
-                   decltype(smallest_uint<to_underlying(N), StorageElem>())>;
 
+#if __cplusplus >= 202002L
+template <std::size_t N> bitset(ct_string<N>) -> bitset<N - 1>;
+#endif
 } // namespace v1
 } // namespace stdx