Make Object/Class/Array non-reassignable except by UniquePointerlike

Author: jfirebaugh

include/jni/array.hpp

@@ -30,6 +30,10 @@ namespace jni
         private:
             UntaggedType* array = nullptr;
 
+            template < class T, class D > friend class UniquePointerlike;
+
+            void reset(UntaggedType* a) { array = a; }
+
         public:
             explicit Array(std::nullptr_t = nullptr)
                {}
@@ -42,6 +46,13 @@ namespace jni
                : array(&a)
                {}
 
+            Array(const Array& a)
+               : array(a.array)
+               {}
+
+            // Not reassignable; it would break UniquePointerlike's abstraction.
+            Array& operator=(const Array&) = delete;
+
             explicit operator bool() const { return array; }
 
             operator UntaggedType*() const { return array; }
@@ -103,6 +114,10 @@ namespace jni
         private:
             UntaggedType* array = nullptr;
 
+            template < class T, class D > friend class UniquePointerlike;
+
+            void reset(UntaggedType* a) { array = a; }
+
         public:
             explicit Array(std::nullptr_t = nullptr)
                {}
@@ -115,6 +130,13 @@ namespace jni
                : array(&a)
                {}
 
+            Array(const Array& a)
+               : array(a.array)
+               {}
+
+            // Not reassignable; it would break UniquePointerlike's abstraction.
+            Array& operator=(const Array&) = delete;
+
             explicit operator bool() const { return array; }
 
             operator UntaggedType*() const { return array; }

include/jni/class.hpp

@@ -25,6 +25,10 @@ namespace jni
         private:
             jclass* clazz = nullptr;
 
+            template < class T, class D > friend class UniquePointerlike;
+
+            void reset(jclass* c) { clazz = c; }
+
         public:
             using TagType = TheTag;
 
@@ -35,6 +39,13 @@ namespace jni
                : clazz(&c)
                {}
 
+            Class(const Class& c)
+               : clazz(c.clazz)
+               {}
+
+            // Not reassignable; it would break UniquePointerlike's abstraction.
+            Class& operator=(const Class&) = delete;
+
             explicit operator bool() const { return clazz; }
 
             operator jclass&() const { return *clazz; }

include/jni/object.hpp

@@ -39,6 +39,10 @@ namespace jni
         private:
             UntaggedObjectType* obj = nullptr;
 
+            template < class T, class D > friend class UniquePointerlike;
+
+            void reset(UntaggedObjectType* o) { obj = o; }
+
         public:
             explicit Object(std::nullptr_t = nullptr)
                {}
@@ -51,11 +55,18 @@ namespace jni
                : obj(&o)
                {}
 
+            Object(const Object& o)
+               : obj(o.obj)
+               {}
+
             template < class Tag >
             Object(const Object<Tag>& o, std::enable_if_t< std::is_convertible<Tag, TagType>::value >* = nullptr)
                : obj(o.Get())
                {}
 
+            // Not reassignable; it would break UniquePointerlike's abstraction.
+            Object& operator=(const Object&) = delete;
+
             explicit operator bool() const { return obj; }
 
             operator UntaggedObjectType*() const { return obj; }

include/jni/unique_pointerlike.hpp

@@ -56,7 +56,7 @@ namespace jni
             void reset(T&& t = T())
                {
                 T current = pointerlike;
-                pointerlike = std::move(t);
+                pointerlike.reset(t.Get());
                 if (current)
                    {
                     get_deleter()(current.Get());
@@ -66,7 +66,7 @@ namespace jni
             T release()
                {
                 T current = pointerlike;
-                pointerlike = T();
+                pointerlike.reset(nullptr);
                 return current;
                }
 

test/high_level.cpp

@@ -125,7 +125,6 @@ int main()
 
     jni::Object<Derived> derived;
     jni::Object<Base> base(derived);
-    base = derived;
     (void)[] () -> jni::Object<Base> { return jni::Object<Derived>(); };
     (void)[] () -> jni::Object<> { return jni::String(); };