Added "immutable" modifier

Author: rollbear

ChangeLog

@@ -1,3 +1,7 @@
+        * Added modifier strong::immutable, which disables assignment
+          and makes value_of() always return const references. Thanks
+          David Hunder for the discussion that lead to this.
+
 v15 2024-07-07
 
         * CMake package is now ARCH_INDEPENDENT, as it should be when it's

README.md

@@ -185,6 +185,9 @@ the underlying type can be, for compilers and standards that support it.
 
   Available in `strong_type/hashable.hpp`.
 
+* <A name="immutable"/>`strong::immutable`
+  Disables assignment and makes `value_of` return a `const T&` or `const T&&`.
+  Move construction is still supported.
 
 * <A name="implicitly_convertible_to"/>`strong::implicitly_convertible_to<Ts...>`
   provides an `operator Ts() const` for each type `Ts`, providing the underlying

include/strong_type/type.hpp

@@ -46,6 +46,19 @@ struct default_constructible {
     };
 };
 
+struct immutable {
+    template <typename>
+    class modifier {
+    public:
+        modifier() noexcept = default;
+        modifier(const modifier&) = default;
+        modifier(modifier&&) = default;
+        ~modifier() = default;
+        modifier& operator=(const modifier&) = delete;
+        modifier& operator=(modifier&&) = delete;
+    };
+};
+
 namespace impl {
 template<typename T>
 constexpr bool supports_default_construction(
@@ -58,6 +71,18 @@ template<typename T, typename ... V>
 using WhenConstructible = std::enable_if_t<std::is_constructible<T, V...>::value>;
 }
 
+namespace impl {
+template <typename T>
+constexpr bool is_immutable(const ::strong::immutable::modifier<T>*)
+{
+    return true;
+}
+constexpr bool is_immutable(const void*)
+{
+    return false;
+}
+}
+
 template<typename T, typename Tag, typename ... M>
 class type : public modifier<M, type<T, Tag, M...>> ... {
 public:
@@ -109,32 +134,36 @@ class type : public modifier<M, type<T, Tag, M...>> ... {
         swap(a._val, b._val);
     }
 
+    template<typename type_ = type>
     STRONG_NODISCARD
-    constexpr T &value_of() & noexcept
+    constexpr std::enable_if_t<!impl::is_immutable(static_cast<type_*>(nullptr)), T&>value_of() & noexcept
     { return _val; }
 
     STRONG_NODISCARD
     constexpr const T &value_of() const & noexcept
     { return _val; }
 
+    template <typename type_ = type>
     STRONG_NODISCARD
-    constexpr T &&value_of() && noexcept
+    constexpr std::enable_if_t<!impl::is_immutable(static_cast<type_*>(nullptr)), T&&> value_of() && noexcept
     { return std::move(_val); }
 
     STRONG_NODISCARD
     constexpr const T &&value_of() const && noexcept
     { return std::move(_val); }
 
+    template <typename type_ = type>
     STRONG_NODISCARD
-    friend constexpr T &value_of(type &t) noexcept
+    friend constexpr auto value_of(type &t) noexcept -> std::enable_if_t<!impl::is_immutable(static_cast<type_*>(nullptr)), T&>
     { return t._val; }
 
     STRONG_NODISCARD
     friend constexpr const T &value_of(const type &t) noexcept
     { return t._val; }
 
+    template <typename type_ = type>
     STRONG_NODISCARD
-    friend constexpr T &&value_of(type &&t) noexcept
+    friend constexpr auto value_of(type &&t) noexcept -> std::enable_if_t<!impl::is_immutable(static_cast<type_*>(nullptr)), T&&>
     { return std::move(t)._val; }
 
     STRONG_NODISCARD

test/test.cpp

@@ -643,6 +643,23 @@ static_assert(is_divisible<schdi, int>{},"");
 static_assert(std::is_same<int, decltype(scild{3}/scild{2})>{},"");
 static_assert(std::is_same<handle, decltype(schdi{3} / schdi{1})>{},"");
 
+using immutable_int = strong::type<int, struct immutable_int_, strong::immutable>;
+
+static_assert(! std::is_copy_assignable<immutable_int>{},"");
+static_assert(! std::is_move_assignable<immutable_int>{},"");
+static_assert(std::is_nothrow_copy_constructible<immutable_int>{},"");
+static_assert(std::is_nothrow_move_constructible<immutable_int>{},"");
+
+static_assert(std::is_const<std::remove_reference_t<decltype(value_of(std::declval<immutable_int&&>()))>>{},"");
+static_assert(std::is_const<std::remove_reference_t<decltype(std::declval<immutable_int&&>().value_of())>>{},"");
+static_assert(std::is_const<std::remove_reference_t<decltype(value_of(std::declval<immutable_int&>()))>>{},"");
+static_assert(std::is_const<std::remove_reference_t<decltype(std::declval<immutable_int&>().value_of())>>{},"");
+static_assert(std::is_const<std::remove_reference_t<decltype(value_of(std::declval<const immutable_int&&>()))>>{},"");
+static_assert(std::is_const<std::remove_reference_t<decltype(std::declval<const immutable_int&&>().value_of())>>{},"");
+static_assert(std::is_const<std::remove_reference_t<decltype(value_of(std::declval<const immutable_int&>()))>>{},"");
+static_assert(std::is_const<std::remove_reference_t<decltype(std::declval<const immutable_int&>().value_of())>>{},"");
+
+
 #if STRONG_HAS_STD_FORMAT
 TEST_CASE("format")
 {