ownership.hpp

Go to the documentation of this file.

#pragma once

#include <jni/types.hpp>
#include <jni/wrapping.hpp>
#include <jni/typed_methods.hpp>

namespace jni
   {
    struct LocalFrameDeleter
       {
        void operator()(JNIEnv* env) const
           {
            if (env)
               {
                env->PopLocalFrame(nullptr);
               }
           }
       };

    using UniqueLocalFrame = std::unique_ptr< JNIEnv, LocalFrameDeleter >;


    using RefDeletionMethod = void (JNIEnv::*)(::jobject);

    template < RefDeletionMethod DeleteRef >
    class DefaultRefDeleter
       {
        private:
            JNIEnv* env = nullptr;

        public:
            DefaultRefDeleter() = default;
            DefaultRefDeleter(JNIEnv& e) : env(&e) {}

            void operator()(jobject* p) const
               {
                if (p)
                   {
                    assert(env);
                    (env->*DeleteRef)(Unwrap(p));
                   }
               }
       };


    template < class T, template < RefDeletionMethod > class Deleter = DefaultRefDeleter >
    using UniqueGlobalRef = std::unique_ptr< T, Deleter<&JNIEnv::DeleteGlobalRef> >;

    template < class T, template < RefDeletionMethod > class Deleter = DefaultRefDeleter >
    using UniqueWeakGlobalRef = std::unique_ptr< T, Deleter<&JNIEnv::DeleteWeakGlobalRef> >;

    // Not parameterized by Deleter because local references should be short-lived enough
    // that DefaultRefDeleter suffices in all cases.
    template < class T >
    using UniqueLocalRef = std::unique_ptr< T, DefaultRefDeleter<&JNIEnv::DeleteLocalRef> >;


    class StringCharsDeleter
       {
        private:
            JNIEnv* env = nullptr;
            jstring* string = nullptr;

        public:
            StringCharsDeleter() = default;
            StringCharsDeleter(JNIEnv& e, jstring& s) : env(&e), string(&s) {}

            void operator()(const char16_t* p) const
               {
                if (p)
                   {
                    assert(env);
                    assert(string);
                    env->ReleaseStringChars(Unwrap(string), Unwrap(p));
                   }
               }
       };

    using UniqueStringChars = std::unique_ptr< const char16_t, StringCharsDeleter >;


    class StringUTFCharsDeleter
       {
        private:
            JNIEnv* env = nullptr;
            jstring* string = nullptr;

        public:
            StringUTFCharsDeleter() = default;
            StringUTFCharsDeleter(JNIEnv& e, jstring& s) : env(&e), string(&s) {}

            void operator()(const char* p) const
               {
                if (p)
                   {
                    assert(env);
                    assert(string);
                    env->ReleaseStringUTFChars(Unwrap(string), p);
                   }
               }
       };

    using UniqueStringUTFChars = std::unique_ptr< const char, StringUTFCharsDeleter >;


    class StringCriticalDeleter
       {
        private:
            JNIEnv* env = nullptr;
            jstring* string = nullptr;

        public:
            StringCriticalDeleter() = default;
            StringCriticalDeleter(JNIEnv& e, jstring& s) : env(&e), string(&s) {}

            void operator()(const char16_t* p) const
               {
                if (p)
                   {
                    assert(env);
                    assert(string);
                    env->ReleaseStringCritical(Unwrap(string), Unwrap(p));
                   }
               }
       };

    using UniqueStringCritical = std::unique_ptr< const char16_t, StringCriticalDeleter >;


    template < class E >
    class ArrayElementsDeleter
       {
        private:
            JNIEnv* env = nullptr;
            jarray<E>* array = nullptr;

        public:
            ArrayElementsDeleter() = default;
            ArrayElementsDeleter(JNIEnv& e, jarray<E>& a) : env(&e), array(&a) {}

            void operator()(E* p) const
               {
                if (p)
                   {
                    assert(env);
                    assert(array);
                    (env->*(TypedMethods<E>::ReleaseArrayElements))(Unwrap(array), p, JNI_ABORT);
                   }
               }
       };

    template < class E >
    using UniqueArrayElements = std::unique_ptr< E, ArrayElementsDeleter<E> >;


    template < class E >
    class PrimitiveArrayCriticalDeleter
       {
        private:
            JNIEnv* env = nullptr;
            jarray<E>* array = nullptr;

        public:
            PrimitiveArrayCriticalDeleter() = default;
            PrimitiveArrayCriticalDeleter(JNIEnv& e, jarray<E>& a) : env(&e), array(&a) {}

            void operator()(void* p) const
               {
                if (p)
                   {
                    assert(env);
                    assert(array);
                    env->ReleasePrimitiveArrayCritical(Unwrap(array), p, JNI_ABORT);
                   }
               }
       };

    template < class E >
    using UniquePrimitiveArrayCritical = std::unique_ptr< void, PrimitiveArrayCriticalDeleter<E> >;


    class MonitorDeleter
       {
        private:
            JNIEnv* env = nullptr;

        public:
            MonitorDeleter() = default;
            MonitorDeleter(JNIEnv& e) : env(&e) {}

            void operator()(jobject* p) const
               {
                if (p)
                   {
                    assert(env);
                    env->MonitorExit(Unwrap(p));
                   }
               }
       };

    using UniqueMonitor = std::unique_ptr< jobject, MonitorDeleter >;


    class JNIEnvDeleter
       {
        private:
            JavaVM* vm = nullptr;

        public:
            JNIEnvDeleter() = default;
            JNIEnvDeleter(JavaVM& v) : vm(&v) {}

            void operator()(JNIEnv* p) const
               {
                if (p)
                   {
                    assert(vm);
                    vm->DetachCurrentThread();
                   }
               }
       };

    using UniqueEnv = std::unique_ptr< JNIEnv, JNIEnvDeleter >;
   }