Add Local ref methods and wrappers

Author: kkaefer

include/jni/functions.hpp

@@ -145,14 +145,18 @@ namespace jni
 
 
     template < class T >
-    T* NewLocalRef(JNIEnv& env, T* ref)
+    UniqueLocalRef<T> NewLocalRef(JNIEnv& env, T* t)
        {
-        return CheckJavaException(env, Wrap<T*>(env.NewLocalRef(Unwrap(ref))));
+        jobject* obj = Wrap<jobject*>(env.NewLocalRef(Unwrap(t)));
+        CheckJavaException(env);
+        if (t && !obj)
+            throw std::bad_alloc();
+        return UniqueLocalRef<T>(reinterpret_cast<T*>(obj), LocalRefDeleter(env));
        }
 
-    inline void DeleteLocalRef(JNIEnv& env, jobject* localRef)
+    inline void DeleteLocalRef(JNIEnv& env, UniqueLocalRef<jobject>&& ref)
        {
-        env.DeleteLocalRef(Unwrap(localRef));
+        env.DeleteLocalRef(Unwrap(ref.release()));
         CheckJavaException(env);
        }
 

include/jni/object.hpp

@@ -32,6 +32,12 @@ namespace jni
     template < class TagType = ObjectTag >
     using UniqueWeakObject = std::unique_ptr< const Object<TagType>, WeakObjectRefDeleter<TagType> >;
 
+    template < class TagType >
+    class LocalObjectRefDeleter;
+
+    template < class TagType = ObjectTag >
+    using UniqueLocalObject = std::unique_ptr< const Object<TagType>, LocalObjectRefDeleter<TagType> >;
+
     template < class TheTag = ObjectTag >
     class Object
        {
@@ -141,6 +147,11 @@ namespace jni
                 return SeizeWeakRef(env, Object(jni::NewWeakGlobalRef(env, obj).release()));
                }
 
+            UniqueLocalObject<TagType> NewLocalRef(JNIEnv& env) const
+               {
+                return SeizeLocalRef(env, Object(jni::NewLocalRef(env, obj).release()));
+               }
+
             template < class OtherTag >
             bool IsInstanceOf(JNIEnv& env, const Class<OtherTag>& clazz) const
                {
@@ -204,6 +215,34 @@ namespace jni
         return UniqueWeakObject<TagType>(PointerToValue<Object<TagType>>(std::move(object)), WeakObjectRefDeleter<TagType>(env));
        };
 
+    template < class TagType >
+    class LocalObjectRefDeleter
+       {
+        private:
+            JNIEnv* env = nullptr;
+
+        public:
+            using pointer = PointerToValue< Object<TagType> >;
+
+            LocalObjectRefDeleter() = default;
+            LocalObjectRefDeleter(JNIEnv& e) : env(&e) {}
+
+            void operator()(pointer p) const
+               {
+                if (p)
+                   {
+                    assert(env);
+                    env->DeleteLocalRef(Unwrap(p->Get()));
+                   }
+               }
+       };
+
+    template < class TagType >
+    UniqueLocalObject<TagType> SeizeLocalRef(JNIEnv& env, Object<TagType>&& object)
+       {
+        return UniqueLocalObject<TagType>(PointerToValue<Object<TagType>>(std::move(object)), LocalObjectRefDeleter<TagType>(env));
+       };
+
 
     template < class OutTagType, class InTagType >
     Object<OutTagType> Cast(JNIEnv& env, const Object<InTagType>& object, const Class<OutTagType>& clazz)

include/jni/ownership.hpp

@@ -66,6 +66,29 @@ namespace jni
     using UniqueWeakGlobalRef = std::unique_ptr< T, WeakGlobalRefDeleter >;
 
 
+    class LocalRefDeleter
+       {
+        private:
+            JNIEnv* env = nullptr;
+
+        public:
+            LocalRefDeleter() = default;
+            LocalRefDeleter(JNIEnv& e) : env(&e) {}
+
+            void operator()(jobject* p) const
+               {
+                if (p)
+                   {
+                    assert(env);
+                    env->DeleteLocalRef(Unwrap(p));
+                   }
+               }
+       };
+
+    template < class T >
+    using UniqueLocalRef = std::unique_ptr< T, LocalRefDeleter >;
+
+
     class StringCharsDeleter
        {
         private:

test/high_level.cpp

@@ -72,6 +72,7 @@ int main()
 
     static bool calledNewGlobalRef = false;
     static bool calledNewWeakGlobalRef = false;
+    static bool calledNewLocalRef = false;
 
     env.functions->NewGlobalRef = [] (JNIEnv*, jobject obj) -> jobject
        {
@@ -93,6 +94,16 @@ int main()
        {
        };
 
+    env.functions->NewLocalRef = [] (JNIEnv*, jobject obj) -> jobject
+       {
+        calledNewLocalRef = true;
+        return obj;
+       };
+
+    env.functions->DeleteLocalRef = [] (JNIEnv*, jobject) -> void
+       {
+       };
+
     testClass.NewGlobalRef(env);
     assert(calledNewGlobalRef);
 
@@ -102,10 +113,12 @@ int main()
     jni::Object<Test> object { objectValue.Ptr() };
     object.NewGlobalRef(env);
     object.NewWeakGlobalRef(env);
+    object.NewLocalRef(env);
 
     jni::String string { stringValue.Ptr() };
     string.NewGlobalRef(env);
     string.NewWeakGlobalRef(env);
+    string.NewLocalRef(env);
 
 
     /// Constructor