C++11 JNI开发中RAII的应用(一)--制作基础工具

    // *操作符，返回T对象引用
    T& operator*() noexcept
    { return get();}    
    /* 根据 T类型不同选择不同的->操作符模板 */
    template<typename _T=T>
    typename std::enable_if<std::is_pointer<_T>::value,_T>::type operator->() const noexcept
    { return resource;}//T为指针时直接返回指针本身
    template<typename _T=T>
    typename std::enable_if<std::is_class<_T>::value,_T*>::type operator->() const noexcept
    { return std::addressof(resource);}// T是class/struct时返回resource的地址
//这里->操作符使用了函数模板实现，用到了is_pointer和is_class两个type_trait来判断T的类型，
//如果T不是指针，也不是class/struct,则没有->操作符实现

    /* 根据 _T类型不同选择不同的函数模板 */
    template<typename _T=T>
    typename std::enable_if<!std::is_same<_T,T>::value&&std::is_class<_T>::value,_T&>::type _get() noexcept
    { return static_cast<_T&>(resource); }//T和_T不相等且_T是class/struct时直接将resource转换为_T的引用
    template<typename _T=T>
    typename std::enable_if<!std::is_same<_T,T>::value&&std::is_pointer<_T>::value, _T>::type _get() noexcept
    { return static_cast<_T>(resource); }//T和_T不相等且_T是指针时调用static_cast将resource转换为_T.
//这里用到了is_same来判断模板参数类型是否相同。其实这里应该写得更严谨一些，不仅要判断_T是class，还要判断T也是class,而且T和_T是继承关系,暂时这么写了，以后再改。

/* raii方式管理F(Args...)函数生产的对象
 * 如果调用时指定T类型，则返回的RAII对象类型为T,否则类型为F(Args...)结果类型
 */
template<typename T=void,typename F, typename... Args,
                typename ACQ_RES_TYPE=typename std::result_of<F(Args...)>::type,
                typename TYPE=typename std::conditional<!std::is_same<T,void>::value&&!std::is_same<T,ACQ_RES_TYPE>::value,T,ACQ_RES_TYPE>::type,
                typename REL=std::function<void(TYPE&)> >
raii_var<TYPE>
raii_bind_var(REL rel,F&& f, Args&&... args){
    return raii_var<TYPE>(
            [&]()->TYPE {return static_cast<TYPE>(std::bind(std::forward<F>(f), std::forward<Args>(args)...)());},
            rel);
}
//变参函数模板，可以根据需要加入任意数目的参数

JNIEnv* env;
jobject obj;
{
auto var_class=raii_bind_var(
    [](jclass& clazz){env->DeleteLocalRef(clazz);};
    JNIEnv::GetObjectClass,env,obj);
jclass clazz=*var_class;//获取GetObjectClass的结果。
// do something
}

class jni_utilits {
private:
    static thread_local JNIEnv* const env;
    static void _getJNIEnv(){
        assert(nullptr != JVM);
        //调用JVM::GetEnv获取当前线程的JNIEnv指针
        if (JVM->GetEnv((void **) &const_cast<JNIEnv*&>(env), JNI_VERSION_1_6) != JNI_OK) {
            throw std::logic_error("error for GetEnv");
        }
        assert(nullptr != env);
    }
public:
    static JavaVM * const JVM;
    static JNIEnv* getJNIEnv() {
        if (nullptr == env) {
            _getJNIEnv();//指针为nullptr时调用_getEnv()获取当前线程的指针,每个线程在执行期间只调用一次
        }
        return env;
    }
}

    /* raii方式管理F函数生产的jobject对象局部引用
     * 如果调用时指定T类型，则返回的RAII对象类型为T,否则类型为F(Args...)结果类型
     */
    template<typename T=void,typename F, typename... Args,
            typename ACQ_RES_TYPE=typename std::result_of<F(Args...)>::type,
            typename TYPE=typename std::conditional<!std::is_same<T,void>::value&&!std::is_same<T,ACQ_RES_TYPE>::value,T,ACQ_RES_TYPE>::type>
    static raii_var<TYPE>
    raii_jobject_var(F&& f, Args&&... args){
        static_assert(
                std::is_base_of<typename std::remove_pointer<ACQ_RES_TYPE>::type,
                                        typename std::remove_pointer<TYPE>::type>::value,
                "T is not derived from jobject");
        auto var= raii_bind_var<TYPE>(
                //析构时释放本地引用
                [](TYPE &obj) {if(nullptr!=obj)getJNIEnv()->DeleteLocalRef(obj);},              
                std::forward<F>(f), std::forward<Args>(args)...
                );
        auto env=getJNIEnv();
        auto exec=env->ExceptionOccurred();//判断是否有java异常
        if(exec){
            //env->ExceptionClear();
            env->ExceptionDescribe();
            //env->Throw(exec);
        }
        return std::move(var);
    }

    template<typename T=void,typename F, typename... Args>
    static auto
    raii_jobject_env(F&& f, Args&&... args)->decltype(raii_jobject_var<T>(f,getJNIEnv(),std::forward<Args>(args)...)){
        return raii_jobject_var<T>(f,getJNIEnv(),std::forward<Args>(args)...);
    }
//在调用raii_jobject_var时通过前面所述的jni_utilits::getJNIEnv()函数获取当前线程的JNIEnv指针

jobject obj;
{
auto var_class=raii_jobject_env(&JNIEnv::GetObjectClass, obj);
jclass clazz=*var_class;//获取GetObjectClass的结果。
// do something
}

    static raii_var<jclass> raii_GetObjectClass(jobject obj) {
        assert(nullptr != obj);
        return raii_jobject_env(&JNIEnv::GetObjectClass, obj);
    }

jobject obj;
{
auto var_class=raii_GetObjectClass(obj);
jclass clazz=*var_class;//获取GetObjectClass的结果。
// do something
}