JavaVoidMethodCaller.h

Go to the documentation of this file.

/*
 *  BEEN: Benchmarking Environment
 *  ==============================
 *
 *  File author: Branislav Repcek
 *
 *  GNU Lesser General Public License Version 2.1
 *  ---------------------------------------------
 *  Copyright (C) 2004-2006 Distributed Systems Research Group,
 *  Faculty of Mathematics and Physics, Charles University in Prague
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 */

#ifndef JAVA_VOID_METHOD_CALLER
#define JAVA_VOID_METHOD_CALLER

// Disable warnings about deprecated "unsecure" functions from STL in Visual Studio 2005+.
#if _MSC_VER >= 1400
#define _SCL_SECURE_NO_DEPRECATE 1
#endif

#include <jni.h>
#include <vector>
#include <algorithm>
#include "String.h"
#include "TypeList.h"
#include "CompileTimeCheck.h"

namespace lm
{
    class JavaVoidMethodCaller
    {
    public:

        /* Let the template meta-programming madness begin! 
         * 
         * This is also warning for those that are brave and try to read and understand this code.
         */

        JavaVoidMethodCaller(JNIEnv *env, jclass java_class, jobject java_object, bool swallow_java_exceptions = true) :
        jni_env(env),
        target_class(java_class),
        object(java_object),
        swallow_exceptions(swallow_java_exceptions)
        {
        }

        ~JavaVoidMethodCaller(void)
        {
        }

        bool Call(const char *method_name, const char *method_signature)
        {
            jmethodID method_id = jni_env->GetMethodID(target_class, method_name, method_signature);

            if (!method_id)
            {
                return false;
            }

            jni_env->CallVoidMethod(object, method_id);

            if (jni_env->ExceptionCheck())
            {
                if (swallow_exceptions)
                {
                    jni_env->ExceptionClear();
                }
                return false;
            }

            return true;
        }

        template< typename T1 > 
        bool Call(const char *method_name, const char *method_signature, T1 param_1)
        {
            const int type_index = ::tl::IndexOf< JavaTypes, T1 >::value;

            COMPILE_TIME_CHECK(type_index >= 0, Parameter_type_is_not_supported);

            jmethodID method_id = jni_env->GetMethodID(target_class, method_name, method_signature);

            if (!method_id)
            {
                return false;
            }

            jni_env->CallVoidMethod(object, method_id, param_1);

            if (jni_env->ExceptionCheck())
            {
                if (swallow_exceptions)
                {
                    jni_env->ExceptionClear();
                }
                return false;
            }

            return true;
        }

        template< typename T1, typename T2 > 
        bool Call(const char *method_name, const char *method_signature, T1 param_1, T2 param_2)
        {
            const int type_index_1 = ::tl::IndexOf< JavaTypes, T1 >::value;
            const int type_index_2 = ::tl::IndexOf< JavaTypes, T2 >::value;

            COMPILE_TIME_CHECK(type_index_1 >= 0, First_parameters_type_is_not_supported);
            COMPILE_TIME_CHECK(type_index_2 >= 0, Second_parameters_type_is_not_supported);

            jmethodID method_id = jni_env->GetMethodID(target_class, method_name, method_signature);

            if (!method_id)
            {
                return false;
            }

            jni_env->CallVoidMethod(object, method_id, param_1, param_2);

            if (jni_env->ExceptionCheck())
            {
                if (swallow_exceptions)
                {
                    jni_env->ExceptionClear();
                }
                return false;
            }

            return true;
        }

        template< typename T1 >
        bool Call(const char *method_name, 
                  const char *method_signature, 
                  const std::vector< T1 > &param_1)
        {
            const int type_index = ::tl::IndexOf< JavaTypes, T1 >::value;

            // Test of type is valid and it is not void
            COMPILE_TIME_CHECK(type_index >= 1, Parameter_type_is_not_supported);

            jmethodID method_id = jni_env->GetMethodID(target_class, method_name, method_signature);

            if (!method_id)
            {
                return false;
            }

            typedef typename ::tl::Get< ArrayMethodAdapters, type_index >::Result AdapterType;

            bool result = true;
            AdapterType adapter(jni_env);

            typename AdapterType::JavaType java_array = adapter.NewArray(static_cast< jsize >(param_1.size()));

            // Copy data from vector to the Java array.
            T1 *array_data = new T1[param_1.size()];

            std::copy(param_1.begin(), param_1.end(), array_data);

            adapter.SetArrayRegion(java_array, 0, static_cast< jsize >(param_1.size()), array_data);

            jni_env->CallVoidMethod(object, method_id, java_array);

            if (jni_env->ExceptionCheck())
            {
                if (swallow_exceptions)
                {
                    jni_env->ExceptionClear();
                }
                result = false;
            }

            adapter.DeleteArray(java_array, array_data); // <- so stupid, I want to free array without copying crap around
            //delete []array_data;

            return result;
        }

        template< typename T1, typename T2 > 
        bool Call(const char *method_name, 
                  const char *method_signature, 
                  const std::vector< T1 > &param_1,
                  const std::vector< T2 > &param_2)
        {
            const int type_index_1 = ::tl::IndexOf< JavaTypes, T1 >::value;
            const int type_index_2 = ::tl::IndexOf< JavaTypes, T2 >::value;

            COMPILE_TIME_CHECK(type_index_1 >= 1, Parameter_type_is_not_supported);
            COMPILE_TIME_CHECK(type_index_2 >= 1, Parameter_type_is_not_supported);

            jmethodID method_id = jni_env->GetMethodID(target_class, method_name, method_signature);

            if (!method_id)
            {
                return false;
            }

            typedef typename ::tl::Get< ArrayMethodAdapters, type_index_1 >::Result AdapterType_1;
            typedef typename ::tl::Get< ArrayMethodAdapters, type_index_2 >::Result AdapterType_2;

            bool result = true;

            AdapterType_1 adapter_1(jni_env);
            AdapterType_2 adapter_2(jni_env);

            typename AdapterType_1::JavaType java_array_1 = adapter_1.NewArray(static_cast< jsize >(param_1.size()));
            typename AdapterType_2::JavaType java_array_2 = adapter_2.NewArray(static_cast< jsize >(param_2.size()));

            // Copy data from first vector to the first Java array.
            T1 *array_data_1 = new T1[param_1.size()];

            std::copy(param_1.begin(), param_1.end(), array_data_1);
            adapter_1.SetArrayRegion(java_array_1, 0, static_cast< jsize >(param_1.size()), array_data_1);

            // Copy data from second vector to the second Java array.
            T2 *array_data_2 = new T2[param_1.size()];

            std::copy(param_2.begin(), param_2.end(), array_data_2);
            adapter_2.SetArrayRegion(java_array_2, 0, static_cast< jsize >(param_2.size()), array_data_2);

            jni_env->CallVoidMethod(object, method_id, java_array_1, java_array_2);

            if (jni_env->ExceptionCheck())
            {
                if (swallow_exceptions)
                {
                    jni_env->ExceptionClear();
                }
                result = false;
            }

            adapter_1.DeleteArray(java_array_1, array_data_1);
            //delete []array_data_1;

            adapter_2.DeleteArray(java_array_2, array_data_2);
            //delete []array_data_2;

            return result;
        }

        bool GetSwallowExceptions(void)
        {
            return swallow_exceptions;
        }

        bool SetSwallowException(bool se)
        {
            bool ose = swallow_exceptions;

            swallow_exceptions = se;

            return ose;
        }

    private:
        JNIEnv  *jni_env;

        jclass  target_class;

        jobject object;

        bool    swallow_exceptions;

        typedef CREATE_TYPE_LIST_09(void, 
                                    jboolean, 
                                    jbyte, 
                                    jchar, 
                                    jshort, 
                                    jint, 
                                    jlong, 
                                    jfloat, 
                                    jdouble) JavaTypes;

        typedef CREATE_TYPE_LIST_09(void, 
                                    jbooleanArray, 
                                    jbyteArray, 
                                    jcharArray, 
                                    jshortArray, 
                                    jintArray, 
                                    jlongArray, 
                                    jfloatArray, 
                                    jdoubleArray) JavaArrayTypes;


#define CREATE_ARRAY_METHOD_ADAPTER_CLASS(NativeType_, middle_name)                                                                 \
        class ArrayMethodAdapter_##middle_name                                                                                      \
        {                                                                                                                           \
        public:                                                                                                                     \
            typedef NativeType_ NativeType;                                                                                         \
            typedef ::tl::Get< JavaArrayTypes, ::tl::IndexOf< JavaTypes, NativeType >::value >::Result JavaType;                    \
            ArrayMethodAdapter_##middle_name(JNIEnv *env) :                                                                         \
            jni_env(env)                                                                                                            \
            {                                                                                                                       \
            }                                                                                                                       \
            ~ArrayMethodAdapter_##middle_name(void)                                                                                 \
            {                                                                                                                       \
            }                                                                                                                       \
            JavaType NewArray(jsize size)                                                                                           \
            {                                                                                                                       \
                return jni_env->New##middle_name##Array(size);                                                                      \
            }                                                                                                                       \
            void DeleteArray(JavaType java_array, NativeType *elements)                                                             \
            {                                                                                                                       \
                jni_env->Release##middle_name##ArrayElements(java_array, elements, 0);                                              \
            }                                                                                                                       \
            void GetArrayRegion(JavaType java_array, jsize start, jsize len, NativeType *buffer)                                    \
            {                                                                                                                       \
                jni_env->Get##middle_name##ArrayRegion(java_array, start, len, buffer);                                             \
            }                                                                                                                       \
            void SetArrayRegion(JavaType java_array, jsize start, jsize len, NativeType *buffer)                                    \
            {                                                                                                                       \
                jni_env->Set##middle_name##ArrayRegion(java_array, start, len, buffer);                                             \
            }                                                                                                                       \
            NativeType *GetArrayElements(JavaType java_array)                                                                       \
            {                                                                                                                       \
                return jni_env->Get##middle_name##ArrayElements(java_array, NULL);                                                  \
            }                                                                                                                       \
            size_t GetArrayLength(jarray java_array)                                                                                \
            {                                                                                                                       \
                return jni_env->GetArrayLength(java_array);                                                                         \
            }                                                                                                                       \
        private:                                                                                                                    \
            JNIEnv  *jni_env;                                                                                                       \
        };

        class ArrayMethodAdapter_String
        {
        public:
            typedef jobjectArray JavaType;

            typedef jstring NativeType;

            ArrayMethodAdapter_String(JNIEnv *env) :
            jni_env(env)
            {
                // Find string class from (java.lang.String).
                string_class = jni_env->FindClass("java/lang/String");
            }

            ~ArrayMethodAdapter_String(void)
            {
            }

            jobjectArray NewArray(jsize size)
            {
                return jni_env->NewObjectArray(size, string_class, NULL);
            }

            void SetElement(jobjectArray java_array, size_t index, const String &value)
            {
#ifdef WIN32
                // Use UNICODE strings on Win
                jstring new_value = jni_env->NewString((jchar *) value.c_str(), static_cast< jsize >(value.length()));
#else
                // ASCII elsewhere
                jstring new_value = jni_env->NewStringUTF(value.c_str());
#endif

                jni_env->SetObjectArrayElement(java_array, static_cast< jsize >(index), new_value);
            }

            size_t GetArrayLength(jarray java_array)
            {
                return jni_env->GetArrayLength(java_array);
            }

        private:
            JNIEnv  *jni_env;
            jclass  string_class;
        };

        CREATE_ARRAY_METHOD_ADAPTER_CLASS(jboolean, Boolean)

        
        CREATE_ARRAY_METHOD_ADAPTER_CLASS(jbyte, Byte)

        CREATE_ARRAY_METHOD_ADAPTER_CLASS(jchar, Char)

        CREATE_ARRAY_METHOD_ADAPTER_CLASS(jshort, Short)

        CREATE_ARRAY_METHOD_ADAPTER_CLASS(jint, Int)

        CREATE_ARRAY_METHOD_ADAPTER_CLASS(jlong, Long)

        CREATE_ARRAY_METHOD_ADAPTER_CLASS(jfloat, Float)

        CREATE_ARRAY_METHOD_ADAPTER_CLASS(jdouble, Double)

        typedef CREATE_TYPE_LIST_09(void,
                                    ArrayMethodAdapter_Boolean,
                                    ArrayMethodAdapter_Byte,
                                    ArrayMethodAdapter_Char,
                                    ArrayMethodAdapter_Short,
                                    ArrayMethodAdapter_Int,
                                    ArrayMethodAdapter_Long,
                                    ArrayMethodAdapter_Float,
                                    ArrayMethodAdapter_Double) ArrayMethodAdapters;
    };

    template< >
    bool JavaVoidMethodCaller::Call< String >(const char *method_name, const char *method_signature, String param_1)
    {
        jmethodID method_id = jni_env->GetMethodID(target_class, method_name, method_signature);

        if (!method_id)
        {
            return false;
        }

#ifdef WIN32
        jstring str_param = jni_env->NewString((jchar *) param_1.c_str(), static_cast< jsize >(param_1.length()));
#else
        jstring str_param = jni_env->NewStringUTF(param_1.c_str());
#endif

        jni_env->CallVoidMethod(object, method_id, str_param);

        if (jni_env->ExceptionCheck())
        {
            if (swallow_exceptions)
            {
                jni_env->ExceptionClear();
            }
            return false;
        }

        return true;
    }

    template< >
    bool JavaVoidMethodCaller::Call< String >(const char *method_name,
                                              const char *method_signature,
                                              const std::vector< String > &param_1)
    {
        jmethodID method_id = jni_env->GetMethodID(target_class, method_name, method_signature);

        if (!method_id)
        {
            return false;
        }

        ArrayMethodAdapter_String adapter(jni_env);

       /* Note: I have no idea if this creates memory leak or not. I was not able to find equivalent of the ReleaseXXXArrayElements
        * method which works for jobjectArrays. So I guess Java will do this automatically.
        */

        ArrayMethodAdapter_String::JavaType java_array = adapter.NewArray(static_cast< jsize >(param_1.size()));

        for (size_t i = 0; i < param_1.size(); ++i)
        {
            adapter.SetElement(java_array, i, param_1[i]);
        }

        jni_env->CallVoidMethod(object, method_id, java_array);

        if (jni_env->ExceptionCheck())
        {
            if (swallow_exceptions)
            {
                jni_env->ExceptionClear();
            }
            return false;
        }

        return true;
    }

} // namespace lm

#endif

---