#pragma once #include "common/RhoStd.h" #include "logging/RhoLog.h" #include "rhodes/JNIRhodes.h" #include "MethodExecutorJni.h" #include "MethodResultJni.h" namespace rho { using rho::apiGenerator::MethodResultJni; using rho::apiGenerator::MethodExecutorJni; class CNewORMModelBase : public MethodExecutorJni { protected: DEFINE_LOGCLASS; static const char* const FACTORY_SINGLETON_CLASS; static jclass s_clsFactorySingleton; static jmethodID s_midFactorySetInstance; static jmethodID s_midFactoryGetInstance; //INewORMModelFactory staff static const char* const IFACTORY_CLASS; static jclass s_clsIFactory; static jmethodID s_midGetApiSingleton; static jmethodID s_midGetApiObject; //NewORMModelSingletonBase staff static const char* const SINGLETON_BASE_CLASS; static jclass s_clsSingletonBase; //NewORMModelBase staff static const char* const OBJECT_BASE_CLASS; static jclass s_clsObjectBase; //Method tasks static const char* const GETLOADED_TASK_CLASS; static jclass s_clsgetLoadedTask; static jmethodID s_midgetLoadedTask; static const char* const SETLOADED_TASK_CLASS; static jclass s_clssetLoadedTask; static jmethodID s_midsetLoadedTask; static const char* const GETMODEL_NAME_TASK_CLASS; static jclass s_clsgetModel_nameTask; static jmethodID s_midgetModel_nameTask; static const char* const SETMODEL_NAME_TASK_CLASS; static jclass s_clssetModel_nameTask; static jmethodID s_midsetModel_nameTask; static const char* const GETSYNC_TYPE_TASK_CLASS; static jclass s_clsgetSync_typeTask; static jmethodID s_midgetSync_typeTask; static const char* const SETSYNC_TYPE_TASK_CLASS; static jclass s_clssetSync_typeTask; static jmethodID s_midsetSync_typeTask; static const char* const GETSYNC_PRIORITY_TASK_CLASS; static jclass s_clsgetSync_priorityTask; static jmethodID s_midgetSync_priorityTask; static const char* const SETSYNC_PRIORITY_TASK_CLASS; static jclass s_clssetSync_priorityTask; static jmethodID s_midsetSync_priorityTask; static const char* const GETPARTITION_TASK_CLASS; static jclass s_clsgetPartitionTask; static jmethodID s_midgetPartitionTask; static const char* const SETPARTITION_TASK_CLASS; static jclass s_clssetPartitionTask; static jmethodID s_midsetPartitionTask; static const char* const GETSOURCE_ID_TASK_CLASS; static jclass s_clsgetSource_idTask; static jmethodID s_midgetSource_idTask; static const char* const SETSOURCE_ID_TASK_CLASS; static jclass s_clssetSource_idTask; static jmethodID s_midsetSource_idTask; static const char* const GETFIXED_SCHEMA_TASK_CLASS; static jclass s_clsgetFixed_schemaTask; static jmethodID s_midgetFixed_schemaTask; static const char* const SETFIXED_SCHEMA_TASK_CLASS; static jclass s_clssetFixed_schemaTask; static jmethodID s_midsetFixed_schemaTask; static const char* const GETFREEZED_TASK_CLASS; static jclass s_clsgetFreezedTask; static jmethodID s_midgetFreezedTask; static const char* const SETFREEZED_TASK_CLASS; static jclass s_clssetFreezedTask; static jmethodID s_midsetFreezedTask; static const char* const GETASSOCIATIONS_TASK_CLASS; static jclass s_clsgetAssociationsTask; static jmethodID s_midgetAssociationsTask; static const char* const SETASSOCIATIONS_TASK_CLASS; static jclass s_clssetAssociationsTask; static jmethodID s_midsetAssociationsTask; static const char* const ENUMERATE_TASK_CLASS; static jclass s_clsenumerateTask; static jmethodID s_midenumerateTask; static const char* const GETMODEL_TASK_CLASS; static jclass s_clsgetModelTask; static jmethodID s_midgetModelTask; static const char* const INIT_TASK_CLASS; static jclass s_clsinitTask; static jmethodID s_midinitTask; static const char* const INITMODEL_TASK_CLASS; static jclass s_clsinitModelTask; static jmethodID s_midinitModelTask; static const char* const SETBELONGSTO_TASK_CLASS; static jclass s_clssetBelongsToTask; static jmethodID s_midsetBelongsToTask; static const char* const GETBELONGSTO_TASK_CLASS; static jclass s_clsgetBelongsToTask; static jmethodID s_midgetBelongsToTask; static const char* const SET_TASK_CLASS; static jclass s_clssetTask; static jmethodID s_midsetTask; static const char* const ENABLE_TASK_CLASS; static jclass s_clsenableTask; static jmethodID s_midenableTask; static const char* const SETMODELPROPERTY_TASK_CLASS; static jclass s_clssetModelPropertyTask; static jmethodID s_midsetModelPropertyTask; static const char* const GETMODELPROPERTY_TASK_CLASS; static jclass s_clsgetModelPropertyTask; static jmethodID s_midgetModelPropertyTask; static const char* const SETSCHEMAINDEX_TASK_CLASS; static jclass s_clssetSchemaIndexTask; static jmethodID s_midsetSchemaIndexTask; static const char* const DESTROY_TASK_CLASS; static jclass s_clsdestroyTask; static jmethodID s_middestroyTask; static const char* const CREATEOBJECT_TASK_CLASS; static jclass s_clscreateObjectTask; static jmethodID s_midcreateObjectTask; static const char* const CREATEINSTANCE_TASK_CLASS; static jclass s_clscreateInstanceTask; static jmethodID s_midcreateInstanceTask; static const char* const ANYCHANGEDOBJECTS_TASK_CLASS; static jclass s_clsanyChangedObjectsTask; static jmethodID s_midanyChangedObjectsTask; static const char* const HASCHANGES_TASK_CLASS; static jclass s_clshasChangesTask; static jmethodID s_midhasChangesTask; static const char* const CANMODIFY_TASK_CLASS; static jclass s_clscanModifyTask; static jmethodID s_midcanModifyTask; static const char* const UPDATEOBJECT_TASK_CLASS; static jclass s_clsupdateObjectTask; static jmethodID s_midupdateObjectTask; static const char* const SAVEOBJECT_TASK_CLASS; static jclass s_clssaveObjectTask; static jmethodID s_midsaveObjectTask; static const char* const DELETEOBJECT_TASK_CLASS; static jclass s_clsdeleteObjectTask; static jmethodID s_middeleteObjectTask; static const char* const DELETEOBJECTS_TASK_CLASS; static jclass s_clsdeleteObjectsTask; static jmethodID s_middeleteObjectsTask; static const char* const DELETEOBJECTSPROPERTYBAGBYCONDHASH_TASK_CLASS; static jclass s_clsdeleteObjectsPropertyBagByCondHashTask; static jmethodID s_middeleteObjectsPropertyBagByCondHashTask; static const char* const DELETEOBJECTSPROPERTYBAGBYCONDARRAY_TASK_CLASS; static jclass s_clsdeleteObjectsPropertyBagByCondArrayTask; static jmethodID s_middeleteObjectsPropertyBagByCondArrayTask; static const char* const GETCOUNT_TASK_CLASS; static jclass s_clsgetCountTask; static jmethodID s_midgetCountTask; static const char* const GETBACKENDREFRESHTIME_TASK_CLASS; static jclass s_clsgetBackendRefreshTimeTask; static jmethodID s_midgetBackendRefreshTimeTask; static const char* const FINDOBJECTS_TASK_CLASS; static jclass s_clsfindObjectsTask; static jmethodID s_midfindObjectsTask; static const char* const FINDOBJECTSPROPERTYBAGBYCONDHASH_TASK_CLASS; static jclass s_clsfindObjectsPropertyBagByCondHashTask; static jmethodID s_midfindObjectsPropertyBagByCondHashTask; static const char* const FINDOBJECTSPROPERTYBAGBYCONDARRAY_TASK_CLASS; static jclass s_clsfindObjectsPropertyBagByCondArrayTask; static jmethodID s_midfindObjectsPropertyBagByCondArrayTask; static const char* const FIND_BY_SQL_TASK_CLASS; static jclass s_clsfind_by_sqlTask; static jmethodID s_midfind_by_sqlTask; static const char* const VALIDATEFREEZEDATTRIBUTE_TASK_CLASS; static jclass s_clsvalidateFreezedAttributeTask; static jmethodID s_midvalidateFreezedAttributeTask; static const char* const VALIDATEFREEZEDATTRIBUTES_TASK_CLASS; static jclass s_clsvalidateFreezedAttributesTask; static jmethodID s_midvalidateFreezedAttributesTask; static const char* const BUILDCOMPLEXWHERECOND_TASK_CLASS; static jclass s_clsbuildComplexWhereCondTask; static jmethodID s_midbuildComplexWhereCondTask; static const char* const BUILDFINDLIMITS_TASK_CLASS; static jclass s_clsbuildFindLimitsTask; static jmethodID s_midbuildFindLimitsTask; static const char* const BUILDFINDORDER_TASK_CLASS; static jclass s_clsbuildFindOrderTask; static jmethodID s_midbuildFindOrderTask; static const char* const BUILDSIMPLEWHERECOND_TASK_CLASS; static jclass s_clsbuildSimpleWhereCondTask; static jmethodID s_midbuildSimpleWhereCondTask; static const char* const CLEAR_TASK_CLASS; static jclass s_clsclearTask; static jmethodID s_midclearTask; static const char* const ONSYNCDELETEERROR_TASK_CLASS; static jclass s_clsonSyncDeleteErrorTask; static jmethodID s_midonSyncDeleteErrorTask; static const char* const ONSYNCUPDATEERROR_TASK_CLASS; static jclass s_clsonSyncUpdateErrorTask; static jmethodID s_midonSyncUpdateErrorTask; static const char* const ONSYNCCREATEERROR_TASK_CLASS; static jclass s_clsonSyncCreateErrorTask; static jmethodID s_midonSyncCreateErrorTask; static const char* const PUSHCHANGES_TASK_CLASS; static jclass s_clspushChangesTask; static jmethodID s_midpushChangesTask; static const char* const GETPROPERTY_TASK_CLASS; static jclass s_clsgetPropertyTask; static jmethodID s_midgetPropertyTask; static const char* const GETPROPERTIES_TASK_CLASS; static jclass s_clsgetPropertiesTask; static jmethodID s_midgetPropertiesTask; static const char* const GETALLPROPERTIES_TASK_CLASS; static jclass s_clsgetAllPropertiesTask; static jmethodID s_midgetAllPropertiesTask; static const char* const SETPROPERTY_TASK_CLASS; static jclass s_clssetPropertyTask; static jmethodID s_midsetPropertyTask; static const char* const SETPROPERTIES_TASK_CLASS; static jclass s_clssetPropertiesTask; static jmethodID s_midsetPropertiesTask; static JNIEnv* jniInit(JNIEnv* env); static JNIEnv* jniInit(); static jobject getFactory(JNIEnv* env); static jobject getSingleton(JNIEnv* env); rho::String m_id; jobject getObject(JNIEnv* env); public: static void setJavaFactory(JNIEnv* env, jobject jFactory); CNewORMModelBase(const rho::String& id) : MethodExecutorJni(), m_id(id) {} virtual ~CNewORMModelBase() {} }; template class CNewORMModelProxy : public CNewORMModelBase { public: CNewORMModelProxy(const rho::String& id) : CNewORMModelBase(id) {} virtual ~CNewORMModelProxy() {} void getLoaded(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getLoaded"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetLoadedTask, s_midgetLoadedTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setLoaded(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setLoaded"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'loaded' must be set ^^^"; result.setArgError("Wrong number of arguments: 'loaded' must be set"); return; } jholder< jboolean > jhloaded = rho_cast< jboolean >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetLoadedTask, s_midsetLoadedTask, jhObject.get(), jhloaded.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getModel_name(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getModel_name"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetModel_nameTask, s_midgetModel_nameTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setModel_name(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setModel_name"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'model_name' must be set ^^^"; result.setArgError("Wrong number of arguments: 'model_name' must be set"); return; } jholder< jstring > jhmodel_name = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetModel_nameTask, s_midsetModel_nameTask, jhObject.get(), jhmodel_name.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getSync_type(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getSync_type"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetSync_typeTask, s_midgetSync_typeTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setSync_type(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setSync_type"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jholder< jstring > jhsync_type = (argsAdapter.size() <= 0) ? rho_cast(env, "none") : rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetSync_typeTask, s_midsetSync_typeTask, jhObject.get(), jhsync_type.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getSync_priority(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getSync_priority"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetSync_priorityTask, s_midgetSync_priorityTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setSync_priority(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setSync_priority"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jholder< jint > jhsync_priority = (argsAdapter.size() <= 0) ? rho_cast(env, static_cast(1000)) : rho_cast< jint >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetSync_priorityTask, s_midsetSync_priorityTask, jhObject.get(), jhsync_priority.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getPartition(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getPartition"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetPartitionTask, s_midgetPartitionTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setPartition(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setPartition"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'partition' must be set ^^^"; result.setArgError("Wrong number of arguments: 'partition' must be set"); return; } jholder< jstring > jhpartition = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetPartitionTask, s_midsetPartitionTask, jhObject.get(), jhpartition.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getSource_id(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getSource_id"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetSource_idTask, s_midgetSource_idTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setSource_id(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setSource_id"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'source_id' must be set ^^^"; result.setArgError("Wrong number of arguments: 'source_id' must be set"); return; } jholder< jint > jhsource_id = rho_cast< jint >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetSource_idTask, s_midsetSource_idTask, jhObject.get(), jhsource_id.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getFixed_schema(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getFixed_schema"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetFixed_schemaTask, s_midgetFixed_schemaTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setFixed_schema(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setFixed_schema"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'fixed_schema' must be set ^^^"; result.setArgError("Wrong number of arguments: 'fixed_schema' must be set"); return; } jholder< jboolean > jhfixed_schema = rho_cast< jboolean >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetFixed_schemaTask, s_midsetFixed_schemaTask, jhObject.get(), jhfixed_schema.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getFreezed(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getFreezed"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetFreezedTask, s_midgetFreezedTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setFreezed(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setFreezed"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'freezed' must be set ^^^"; result.setArgError("Wrong number of arguments: 'freezed' must be set"); return; } jholder< jboolean > jhfreezed = rho_cast< jboolean >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetFreezedTask, s_midsetFreezedTask, jhObject.get(), jhfreezed.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getAssociations(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getAssociations"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetAssociationsTask, s_midgetAssociationsTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setAssociations(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setAssociations"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'associations' must be set ^^^"; result.setArgError("Wrong number of arguments: 'associations' must be set"); return; } jholder< jstring > jhassociations = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetAssociationsTask, s_midsetAssociationsTask, jhObject.get(), jhassociations.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } static void enumerate(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "enumerate"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getSingleton(env); jhobject jhTask = env->NewObject(s_clsenumerateTask, s_midenumerateTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } static void getModel(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getModel"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getSingleton(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'modelName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'modelName' must be set"); return; } jholder< jstring > jhmodelName = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsgetModelTask, s_midgetModelTask, jhObject.get(), jhmodelName.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void init(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "init"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'modelName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'modelName' must be set"); return; } jholder< jstring > jhmodelName = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsinitTask, s_midinitTask, jhObject.get(), jhmodelName.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void initModel(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "initModel"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsinitModelTask, s_midinitModelTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setBelongsTo(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setBelongsTo"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyName' must be set"); return; } jholder< jstring > jhpropertyName = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'sourceName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'sourceName' must be set"); return; } jholder< jstring > jhsourceName = rho_cast< jstring >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clssetBelongsToTask, s_midsetBelongsToTask, jhObject.get(), jhpropertyName.get(), jhsourceName.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getBelongsTo(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getBelongsTo"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyName' must be set"); return; } jholder< jstring > jhpropertyName = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsgetBelongsToTask, s_midgetBelongsToTask, jhObject.get(), jhpropertyName.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void set(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "set"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyName' must be set"); return; } jholder< jstring > jhpropertyName = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'propertyValue' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyValue' must be set"); return; } jholder< jstring > jhpropertyValue = rho_cast< jstring >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clssetTask, s_midsetTask, jhObject.get(), jhpropertyName.get(), jhpropertyValue.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void enable(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "enable"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyName' must be set"); return; } jholder< jstring > jhpropertyName = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsenableTask, s_midenableTask, jhObject.get(), jhpropertyName.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setModelProperty(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setModelProperty"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyName' must be set"); return; } jholder< jstring > jhpropertyName = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'propertyType' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyType' must be set"); return; } jholder< jstring > jhpropertyType = rho_cast< jstring >(env, argsAdapter[1]); jholder< jstring > jhpropOption = (argsAdapter.size() <= 2) ? rho_cast(env, "") : rho_cast< jstring >(env, argsAdapter[2]); jhobject jhTask = env->NewObject(s_clssetModelPropertyTask, s_midsetModelPropertyTask, jhObject.get(), jhpropertyName.get(), jhpropertyType.get(), jhpropOption.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getModelProperty(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getModelProperty"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyName' must be set"); return; } jholder< jstring > jhpropertyName = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsgetModelPropertyTask, s_midgetModelPropertyTask, jhObject.get(), jhpropertyName.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setSchemaIndex(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setSchemaIndex"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'indexName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'indexName' must be set"); return; } jholder< jstring > jhindexName = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'indexCols' must be set ^^^"; result.setArgError("Wrong number of arguments: 'indexCols' must be set"); return; } jholder< jobject > jhindexCols = rho_cast< jobject >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'is_unique' must be set ^^^"; result.setArgError("Wrong number of arguments: 'is_unique' must be set"); return; } jholder< jboolean > jhis_unique = rho_cast< jboolean >(env, argsAdapter[2]); jhobject jhTask = env->NewObject(s_clssetSchemaIndexTask, s_midsetSchemaIndexTask, jhObject.get(), jhindexName.get(), jhindexCols.get(), jhis_unique.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void destroy(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "destroy"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsdestroyTask, s_middestroyTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void createObject(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "createObject"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'attrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrs' must be set"); return; } jholder< jobject > jhattrs = rho_cast< jobject >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clscreateObjectTask, s_midcreateObjectTask, jhObject.get(), jhattrs.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void createInstance(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "createInstance"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'attrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrs' must be set"); return; } jholder< jobject > jhattrs = rho_cast< jobject >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clscreateInstanceTask, s_midcreateInstanceTask, jhObject.get(), jhattrs.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void anyChangedObjects(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "anyChangedObjects"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsanyChangedObjectsTask, s_midanyChangedObjectsTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void hasChanges(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "hasChanges"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'objId' must be set ^^^"; result.setArgError("Wrong number of arguments: 'objId' must be set"); return; } jholder< jstring > jhobjId = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clshasChangesTask, s_midhasChangesTask, jhObject.get(), jhobjId.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void canModify(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "canModify"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'objId' must be set ^^^"; result.setArgError("Wrong number of arguments: 'objId' must be set"); return; } jholder< jstring > jhobjId = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clscanModifyTask, s_midcanModifyTask, jhObject.get(), jhobjId.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void updateObject(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "updateObject"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'objId' must be set ^^^"; result.setArgError("Wrong number of arguments: 'objId' must be set"); return; } jholder< jstring > jhobjId = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'oldAttrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'oldAttrs' must be set"); return; } jholder< jobject > jholdAttrs = rho_cast< jobject >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'newAttrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'newAttrs' must be set"); return; } jholder< jobject > jhnewAttrs = rho_cast< jobject >(env, argsAdapter[2]); jhobject jhTask = env->NewObject(s_clsupdateObjectTask, s_midupdateObjectTask, jhObject.get(), jhobjId.get(), jholdAttrs.get(), jhnewAttrs.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void saveObject(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "saveObject"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'objId' must be set ^^^"; result.setArgError("Wrong number of arguments: 'objId' must be set"); return; } jholder< jstring > jhobjId = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'attrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrs' must be set"); return; } jholder< jobject > jhattrs = rho_cast< jobject >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clssaveObjectTask, s_midsaveObjectTask, jhObject.get(), jhobjId.get(), jhattrs.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void deleteObject(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "deleteObject"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'objId' must be set ^^^"; result.setArgError("Wrong number of arguments: 'objId' must be set"); return; } jholder< jstring > jhobjId = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsdeleteObjectTask, s_middeleteObjectTask, jhObject.get(), jhobjId.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void deleteObjects(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "deleteObjects"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'strOptions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'strOptions' must be set"); return; } jholder< jobject > jhstrOptions = rho_cast< jobject >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'quests' must be set ^^^"; result.setArgError("Wrong number of arguments: 'quests' must be set"); return; } jholder< jobject > jhquests = rho_cast< jobject >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clsdeleteObjectsTask, s_middeleteObjectsTask, jhObject.get(), jhstrOptions.get(), jhquests.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void deleteObjectsPropertyBagByCondHash(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "deleteObjectsPropertyBagByCondHash"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'conditions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'conditions' must be set"); return; } jholder< jobject > jhconditions = rho_cast< jobject >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'strOptions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'strOptions' must be set"); return; } jholder< jobject > jhstrOptions = rho_cast< jobject >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clsdeleteObjectsPropertyBagByCondHashTask, s_middeleteObjectsPropertyBagByCondHashTask, jhObject.get(), jhconditions.get(), jhstrOptions.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void deleteObjectsPropertyBagByCondArray(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "deleteObjectsPropertyBagByCondArray"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'conditions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'conditions' must be set"); return; } jholder< jstring > jhconditions = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'quests' must be set ^^^"; result.setArgError("Wrong number of arguments: 'quests' must be set"); return; } jholder< jobject > jhquests = rho_cast< jobject >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'strOptions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'strOptions' must be set"); return; } jholder< jobject > jhstrOptions = rho_cast< jobject >(env, argsAdapter[2]); jhobject jhTask = env->NewObject(s_clsdeleteObjectsPropertyBagByCondArrayTask, s_middeleteObjectsPropertyBagByCondArrayTask, jhObject.get(), jhconditions.get(), jhquests.get(), jhstrOptions.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getCount(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getCount"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetCountTask, s_midgetCountTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getBackendRefreshTime(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getBackendRefreshTime"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetBackendRefreshTimeTask, s_midgetBackendRefreshTimeTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void findObjects(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "findObjects"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'whatParam' must be set ^^^"; result.setArgError("Wrong number of arguments: 'whatParam' must be set"); return; } jholder< jstring > jhwhatParam = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'strOptions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'strOptions' must be set"); return; } jholder< jobject > jhstrOptions = rho_cast< jobject >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'quests' must be set ^^^"; result.setArgError("Wrong number of arguments: 'quests' must be set"); return; } jholder< jobject > jhquests = rho_cast< jobject >(env, argsAdapter[2]); if(argsAdapter.size() <= 3) { LOG(ERROR) + "Wrong number of arguments: 'selectAttrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'selectAttrs' must be set"); return; } jholder< jobject > jhselectAttrs = rho_cast< jobject >(env, argsAdapter[3]); if(argsAdapter.size() <= 4) { LOG(ERROR) + "Wrong number of arguments: 'orderAttrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'orderAttrs' must be set"); return; } jholder< jobject > jhorderAttrs = rho_cast< jobject >(env, argsAdapter[4]); jhobject jhTask = env->NewObject(s_clsfindObjectsTask, s_midfindObjectsTask, jhObject.get(), jhwhatParam.get(), jhstrOptions.get(), jhquests.get(), jhselectAttrs.get(), jhorderAttrs.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void findObjectsPropertyBagByCondHash(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "findObjectsPropertyBagByCondHash"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'whatParam' must be set ^^^"; result.setArgError("Wrong number of arguments: 'whatParam' must be set"); return; } jholder< jstring > jhwhatParam = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'conditions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'conditions' must be set"); return; } jholder< jobject > jhconditions = rho_cast< jobject >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'strOptions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'strOptions' must be set"); return; } jholder< jobject > jhstrOptions = rho_cast< jobject >(env, argsAdapter[2]); if(argsAdapter.size() <= 3) { LOG(ERROR) + "Wrong number of arguments: 'selectAttrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'selectAttrs' must be set"); return; } jholder< jobject > jhselectAttrs = rho_cast< jobject >(env, argsAdapter[3]); jhobject jhTask = env->NewObject(s_clsfindObjectsPropertyBagByCondHashTask, s_midfindObjectsPropertyBagByCondHashTask, jhObject.get(), jhwhatParam.get(), jhconditions.get(), jhstrOptions.get(), jhselectAttrs.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void findObjectsPropertyBagByCondArray(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "findObjectsPropertyBagByCondArray"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'whatParam' must be set ^^^"; result.setArgError("Wrong number of arguments: 'whatParam' must be set"); return; } jholder< jstring > jhwhatParam = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'conditions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'conditions' must be set"); return; } jholder< jstring > jhconditions = rho_cast< jstring >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'quests' must be set ^^^"; result.setArgError("Wrong number of arguments: 'quests' must be set"); return; } jholder< jobject > jhquests = rho_cast< jobject >(env, argsAdapter[2]); if(argsAdapter.size() <= 3) { LOG(ERROR) + "Wrong number of arguments: 'strOptions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'strOptions' must be set"); return; } jholder< jobject > jhstrOptions = rho_cast< jobject >(env, argsAdapter[3]); if(argsAdapter.size() <= 4) { LOG(ERROR) + "Wrong number of arguments: 'selectAttrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'selectAttrs' must be set"); return; } jholder< jobject > jhselectAttrs = rho_cast< jobject >(env, argsAdapter[4]); jhobject jhTask = env->NewObject(s_clsfindObjectsPropertyBagByCondArrayTask, s_midfindObjectsPropertyBagByCondArrayTask, jhObject.get(), jhwhatParam.get(), jhconditions.get(), jhquests.get(), jhstrOptions.get(), jhselectAttrs.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void find_by_sql(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "find_by_sql"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'sqlQuery' must be set ^^^"; result.setArgError("Wrong number of arguments: 'sqlQuery' must be set"); return; } jholder< jstring > jhsqlQuery = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsfind_by_sqlTask, s_midfind_by_sqlTask, jhObject.get(), jhsqlQuery.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void validateFreezedAttribute(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "validateFreezedAttribute"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'attrName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrName' must be set"); return; } jholder< jstring > jhattrName = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsvalidateFreezedAttributeTask, s_midvalidateFreezedAttributeTask, jhObject.get(), jhattrName.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void validateFreezedAttributes(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "validateFreezedAttributes"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'attrHash' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrHash' must be set"); return; } jholder< jobject > jhattrHash = rho_cast< jobject >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsvalidateFreezedAttributesTask, s_midvalidateFreezedAttributesTask, jhObject.get(), jhattrHash.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void buildComplexWhereCond(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "buildComplexWhereCond"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'attrKey' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrKey' must be set"); return; } jholder< jstring > jhattrKey = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'attrValues' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrValues' must be set"); return; } jholder< jobject > jhattrValues = rho_cast< jobject >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'valOp' must be set ^^^"; result.setArgError("Wrong number of arguments: 'valOp' must be set"); return; } jholder< jstring > jhvalOp = rho_cast< jstring >(env, argsAdapter[2]); if(argsAdapter.size() <= 3) { LOG(ERROR) + "Wrong number of arguments: 'valFunc' must be set ^^^"; result.setArgError("Wrong number of arguments: 'valFunc' must be set"); return; } jholder< jstring > jhvalFunc = rho_cast< jstring >(env, argsAdapter[3]); jhobject jhTask = env->NewObject(s_clsbuildComplexWhereCondTask, s_midbuildComplexWhereCondTask, jhObject.get(), jhattrKey.get(), jhattrValues.get(), jhvalOp.get(), jhvalFunc.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void buildFindLimits(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "buildFindLimits"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'whatArg' must be set ^^^"; result.setArgError("Wrong number of arguments: 'whatArg' must be set"); return; } jholder< jstring > jhwhatArg = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'hashArgs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'hashArgs' must be set"); return; } jholder< jobject > jhhashArgs = rho_cast< jobject >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clsbuildFindLimitsTask, s_midbuildFindLimitsTask, jhObject.get(), jhwhatArg.get(), jhhashArgs.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void buildFindOrder(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "buildFindOrder"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'order_attrs' must be set ^^^"; result.setArgError("Wrong number of arguments: 'order_attrs' must be set"); return; } jholder< jobject > jhorder_attrs = rho_cast< jobject >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'order_ops' must be set ^^^"; result.setArgError("Wrong number of arguments: 'order_ops' must be set"); return; } jholder< jobject > jhorder_ops = rho_cast< jobject >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clsbuildFindOrderTask, s_midbuildFindOrderTask, jhObject.get(), jhorder_attrs.get(), jhorder_ops.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void buildSimpleWhereCond(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "buildSimpleWhereCond"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'what' must be set ^^^"; result.setArgError("Wrong number of arguments: 'what' must be set"); return; } jholder< jstring > jhwhat = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'conditions' must be set ^^^"; result.setArgError("Wrong number of arguments: 'conditions' must be set"); return; } jholder< jobject > jhconditions = rho_cast< jobject >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clsbuildSimpleWhereCondTask, s_midbuildSimpleWhereCondTask, jhObject.get(), jhwhat.get(), jhconditions.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } static void clear(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "clear"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getSingleton(env); jhobject jhTask = env->NewObject(s_clsclearTask, s_midclearTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void onSyncDeleteError(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "onSyncDeleteError"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'objId' must be set ^^^"; result.setArgError("Wrong number of arguments: 'objId' must be set"); return; } jholder< jstring > jhobjId = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'attrHash' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrHash' must be set"); return; } jholder< jobject > jhattrHash = rho_cast< jobject >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'action' must be set ^^^"; result.setArgError("Wrong number of arguments: 'action' must be set"); return; } jholder< jstring > jhaction = rho_cast< jstring >(env, argsAdapter[2]); jhobject jhTask = env->NewObject(s_clsonSyncDeleteErrorTask, s_midonSyncDeleteErrorTask, jhObject.get(), jhobjId.get(), jhattrHash.get(), jhaction.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void onSyncUpdateError(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "onSyncUpdateError"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'objId' must be set ^^^"; result.setArgError("Wrong number of arguments: 'objId' must be set"); return; } jholder< jstring > jhobjId = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'attrHash' must be set ^^^"; result.setArgError("Wrong number of arguments: 'attrHash' must be set"); return; } jholder< jobject > jhattrHash = rho_cast< jobject >(env, argsAdapter[1]); if(argsAdapter.size() <= 2) { LOG(ERROR) + "Wrong number of arguments: 'rollbackHash' must be set ^^^"; result.setArgError("Wrong number of arguments: 'rollbackHash' must be set"); return; } jholder< jobject > jhrollbackHash = rho_cast< jobject >(env, argsAdapter[2]); if(argsAdapter.size() <= 3) { LOG(ERROR) + "Wrong number of arguments: 'action' must be set ^^^"; result.setArgError("Wrong number of arguments: 'action' must be set"); return; } jholder< jstring > jhaction = rho_cast< jstring >(env, argsAdapter[3]); jhobject jhTask = env->NewObject(s_clsonSyncUpdateErrorTask, s_midonSyncUpdateErrorTask, jhObject.get(), jhobjId.get(), jhattrHash.get(), jhrollbackHash.get(), jhaction.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void onSyncCreateError(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "onSyncCreateError"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'objects' must be set ^^^"; result.setArgError("Wrong number of arguments: 'objects' must be set"); return; } jholder< jobject > jhobjects = rho_cast< jobject >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'action' must be set ^^^"; result.setArgError("Wrong number of arguments: 'action' must be set"); return; } jholder< jstring > jhaction = rho_cast< jstring >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clsonSyncCreateErrorTask, s_midonSyncCreateErrorTask, jhObject.get(), jhobjects.get(), jhaction.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void pushChanges(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "pushChanges"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clspushChangesTask, s_midpushChangesTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getProperty(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getProperty"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyName' must be set"); return; } jholder< jstring > jhpropertyName = rho_cast< jstring >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsgetPropertyTask, s_midgetPropertyTask, jhObject.get(), jhpropertyName.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getProperties(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getProperties"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'arrayofNames' must be set ^^^"; result.setArgError("Wrong number of arguments: 'arrayofNames' must be set"); return; } jholder< jobject > jharrayofNames = rho_cast< jobject >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clsgetPropertiesTask, s_midgetPropertiesTask, jhObject.get(), jharrayofNames.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void getAllProperties(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "getAllProperties"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); jhobject jhTask = env->NewObject(s_clsgetAllPropertiesTask, s_midgetAllPropertiesTask, jhObject.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setProperty(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setProperty"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyName' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyName' must be set"); return; } jholder< jstring > jhpropertyName = rho_cast< jstring >(env, argsAdapter[0]); if(argsAdapter.size() <= 1) { LOG(ERROR) + "Wrong number of arguments: 'propertyValue' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyValue' must be set"); return; } jholder< jstring > jhpropertyValue = rho_cast< jstring >(env, argsAdapter[1]); jhobject jhTask = env->NewObject(s_clssetPropertyTask, s_midsetPropertyTask, jhObject.get(), jhpropertyName.get(), jhpropertyValue.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } void setProperties(const T& argsAdapter, MethodResultJni& result) { LOG(TRACE) + "setProperties"; JNIEnv *env = jniInit(); if (!env) { LOG(FATAL) + "JNI initialization failed"; return; } jhobject jhObject = getObject(env); if(argsAdapter.size() <= 0) { LOG(ERROR) + "Wrong number of arguments: 'propertyMap' must be set ^^^"; result.setArgError("Wrong number of arguments: 'propertyMap' must be set"); return; } jholder< jobject > jhpropertyMap = rho_cast< jobject >(env, argsAdapter[0]); jhobject jhTask = env->NewObject(s_clssetPropertiesTask, s_midsetPropertiesTask, jhObject.get(), jhpropertyMap.get(), static_cast(result)); run(env, jhTask.get(), result, rho::apiGenerator::NOT_FORCE_THREAD); if(env->ExceptionCheck() == JNI_TRUE) { rho::String message = rho::common::clearException(env); LOG(ERROR) + message; result.setError(message); } } }; }