1 files changed, 27 insertions, 4 deletions

diff --git a/src/unique.hpp b/src/unique.hpp
index 27ea71e..c214dbc 100644
--- a/src/unique.hpp
+++ b/src/unique.hpp
@@ -26,11 +26,13 @@ class Unique
     constexpr Unique& operator=(Unique const&) = default;
     constexpr Unique& operator=(Unique&&) = default;
 
-    // Forbid construction with any other class, especially with types that convert naturally to UnderlyingType.
-    // For instance, this prevents construction with a float when UnderlyingType is an integer type.
+    // Forbid construction with any other class, especially with types that convert naturally to T.
+    // For instance, this prevents construction with a float when T is an integer type.
     // Conversion will have to be explicit and the developer will be aware of it.
     // However we want to keep the same-type copy constructors (including with an inherited class), hence the enable_if stuff.
     template <typename AnyOtherClass, std::enable_if_t<!std::is_base_of_v<self, std::decay_t<AnyOtherClass>>, bool> = true>
+    Unique(AnyOtherClass const&) = delete;
+    template <typename AnyOtherClass, std::enable_if_t<!std::is_base_of_v<self, std::decay_t<AnyOtherClass>>, bool> = true>
     Unique(AnyOtherClass&&) = delete;
 
     // can't implicitly affect from base type
@@ -38,8 +40,8 @@ class Unique
     constexpr Unique& operator=(T&&) = delete;
 
     // cast
-    constexpr operator T() const noexcept { return val; }
-    constexpr T value() const noexcept { return val; }
+    constexpr operator T const&() const noexcept { return val; }
+    constexpr T const& value() const noexcept { return val; }
 
     // pre-increment
     auto& operator++() noexcept
@@ -71,12 +73,33 @@ class Unique<T, TAG, std::enable_if_t<!std::is_scalar_v<T>>>
 : public T
 {
     public:
+    using self = Unique<T, TAG, void>;
     using type = T;
     using T::T;
     explicit Unique(T const& b_)
     : T{ b_ }
     {
     }
+
+    // rule of 5
+    constexpr Unique() = default;
+    constexpr Unique(Unique const&) = default;
+    constexpr Unique(Unique&&) = default;
+    constexpr Unique& operator=(Unique const&) = default;
+    constexpr Unique& operator=(Unique&&) = default;
+
+    // Forbid construction with any other class, especially with types that convert naturally to T.
+    // For instance, this prevents construction with a float when T is an integer type.
+    // Conversion will have to be explicit and the developer will be aware of it.
+    // However we want to keep the same-type copy constructors (including with an inherited class), hence the enable_if stuff.
+    template <typename AnyOtherClass, std::enable_if_t<!std::is_base_of_v<self, std::decay_t<AnyOtherClass>>, bool> = true>
+    Unique(AnyOtherClass const&) = delete;
+    template <typename AnyOtherClass, std::enable_if_t<!std::is_base_of_v<self, std::decay_t<AnyOtherClass>>, bool> = true>
+    Unique(AnyOtherClass&&) = delete;
+
+    // can't implicitly affect from base type
+    Unique& operator=(T const&) = delete;
+    constexpr Unique& operator=(T&&) = delete;
 };
 
 #define DECLARE_UNIQUE_TYPE(_name, _type) using _name = Unique<_type, class Unique_##_name##_Tag>