LibMqMsgque_jv.c

Go to the documentation of this file.

 
/* LABEL-NO */
 
#define META_FILE_NAME "LibMqMsgque_jv.c"
 
#include "jni_h/jvmqmsgque_MqMsgque.h"
#include "LibMqMsgque_private_jv.h"
 
jclass      jclass_List;
jfieldID    jfieldID_List;
jmethodID   jmethodID_List;
 
#define defDebug0
#define defClass(v,n)     jclass     v;
#define defOAtr(v,c,n,s)  jfieldID   v;
#define defSAtr(v,c,n,s)  jfieldID   v;
#define defOMth(v,c,n,s)  jmethodID  v;
#define defSMth(v,c,n,s)  jmethodID  v;
 
#include "MqDefs_jv.h"
 
#undef defDebug0
#undef defClass
#undef defOAtr
#undef defSAtr
#undef defOMth
#undef defSMth
 
#define MqCleanupTmpl() 
#define MqSetupTmpl() 
 
// BEGIN-MqMsgque - created by 'jv_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
// doc-key: MqMsgque,MqMsgque-Enum,sco
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqMsgque_IdentE_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MqIdentE value_out;
  enum MkErrorE errVal = MqIdentE_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFromString)(env,MQ(Class_MqIdentE),"Ljvmqmsgque/MqIdentE;",MqIdentE_ToString(value_out));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqMsgque_SlaveE_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MqSlaveE value_out;
  enum MkErrorE errVal = MqSlaveE_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFromString)(env,MQ(Class_MqSlaveE),"Ljvmqmsgque/MqSlaveE;",MqSlaveE_ToString(value_out));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqMsgque_StartE_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MqStartE value_out;
  enum MkErrorE errVal = MqStartE_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFromString)(env,MQ(Class_MqStartE),"Ljvmqmsgque/MqStartE;",MqStartE_ToString(value_out));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqMsgque_StatusIsEF_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MqStatusIsEF value_out;
  enum MkErrorE errVal = MqStatusIsEF_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFlagFromInt)(env,MQ(Class_MqStatusIsEF),value_out);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqMsgque_WaitOnEventE_1FromInt (JNIEnv *env, jclass class, jint value)  {
  MkRtSetup_NULL;
  enum MqWaitOnEventE value_out;
  enum MkErrorE errVal = MqWaitOnEventE_FromInt(value, &value_out);
  MkErrorC_Check(NULL, errVal)
  jobject __retVal__S = MK(pGetEnumFromString)(env,MQ(Class_MqWaitOnEventE),"Ljvmqmsgque/MqWaitOnEventE;",MqWaitOnEventE_ToString(value_out));
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqMsgque,MqMsgque-Enum,sm_
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqMsgque_IdentE_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqIdentE value_e = MK(pGetEnumFromObj)(env, NS(Class_MqIdentE), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MqIdentE_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqMsgque_IdentE_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqIdentE value_e = MK(pGetEnumFromObj)(env, NS(Class_MqIdentE), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MqIdentE_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqMsgque_SlaveE_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqSlaveE value_e = MK(pGetEnumFromObj)(env, NS(Class_MqSlaveE), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MqSlaveE_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqMsgque_SlaveE_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqSlaveE value_e = MK(pGetEnumFromObj)(env, NS(Class_MqSlaveE), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MqSlaveE_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqMsgque_StartE_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqStartE value_e = MK(pGetEnumFromObj)(env, NS(Class_MqStartE), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MqStartE_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqMsgque_StartE_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqStartE value_e = MK(pGetEnumFromObj)(env, NS(Class_MqStartE), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MqStartE_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqMsgque_StatusIsEF_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqStatusIsEF value_e = MK(pGetEnumFromObj)(env, NS(Class_MqStatusIsEF), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MqStatusIsEF_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqMsgque_StatusIsEF_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqStatusIsEF value_e = MK(pGetEnumFromObj)(env, NS(Class_MqStatusIsEF), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MqStatusIsEF_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqMsgque_WaitOnEventE_1ToInt (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqWaitOnEventE value_e = MK(pGetEnumFromObj)(env, NS(Class_MqWaitOnEventE), value);
  JavaErrorCheck;
  MK_I32 __retVal__L = MqWaitOnEventE_ToInt(value_e);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqMsgque_WaitOnEventE_1ToString (JNIEnv *env, jclass class, jobject value)  {
  MkRtSetup_NULL;
  enum MqWaitOnEventE value_e = MK(pGetEnumFromObj)(env, NS(Class_MqWaitOnEventE), value);
  JavaErrorCheck;
  MK_STRN __retVal__L = MqWaitOnEventE_ToString(value_e);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// MqMsgque_Enum_JV_API
 
 
// doc-key: MqMsgque,MqMsgque-Help,sm_
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqMsgque_Help (JNIEnv *env, jclass class, jstring tool)  {
  MkRtSetup_NULL;
  MK_STRN tool_ptr = (tool?(*env)->GetStringUTFChars(env,tool,NULL):NULL);
  JavaErrorCheck;
  MK_STR __retVal__L = MqHelp(tool_ptr);
  jstring __retVal__S = JC2O(env,__retVal__L);
  if (tool_ptr) (*env)->ReleaseStringUTFChars(env,tool,tool_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqMsgque_HelpMsgque (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_STR __retVal__L = MqHelpMsgque();
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
}
 
// MqMsgque_Help_JV_API
 
 
// doc-key: MqMsgque,MqMsgque-Init,sm_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqMsgque_InitGetArg0 (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_BFL __retVal__L = MqInitGetArg0();
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqMsgque_InitResetArg0 (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_BFL __retVal__L = MqInitResetArg0();
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqMsgque_InitSetArg0 (JNIEnv *env, jclass class, jobject bfl)  {
  MkRtSetup_NULL;
  MK_BAC bfl_hdl = (MK_BAC)pObj2Hdl__null_allow(env,bfl);
  JavaErrorCheck;
  MqInitSetArg0(bfl_hdl);
error:
  return;
}
 
// MqMsgque_Init_JV_API
 
 
// doc-key: MqMsgque,MqMsgque-Setup,sm_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqMsgque_Cleanup (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MqCleanupTmpl();
}
 
JNIEXPORT void JNICALL Setup (JNIEnv *env, jclass class) {
  MkRtSetup_NULL;
  MqSetupTmpl();
}
 
// MqMsgque_Setup_JV_API
 
// END-MqMsgque - created by 'jv_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// OVERLOAD
 
#ifdef META_THREAD_POOL
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqMsgque_MqSysServerThreadMain
  (JNIEnv * env, jclass cls, jlong mainL) 
{
  MqSysServerThreadMain( (struct MqSysServerThreadMainS *) mainL );
}
 
//MkObjectC.DbgM("============================================================================");
//MkObjectC.DbgM($"Thread MAIN  -> mkrt=0x{mkrt}");
//MkObjectC.DbgM($"Thread START -> mkrt=0x{Mk.MkRuntimeGet()}, tId={System.Environment.CurrentManagedThreadId}");
//MkObjectC.DbgM($"Thread END   -> mkrt=0x{Mk.MkRuntimeGet()}, tId={System.Environment.CurrentManagedThreadId}");
//MkObjectC.DbgM($"Start Task -> idP={Convert.ToString((long)idP, 16)}, val={(*idP).val}");
//MkObjectC.DbgM($"Start Wait -> idP={Convert.ToString((long)idP, 16)}, val={(*idP).val}, type={(*idP).type}");
 
// more info: https://stackoverflow.com/questions/12900695/how-to-obtain-jni-interface-pointer-jnienv-for-asynchronous-calls
static enum MkErrorE NS(MqSysServerThreadCB) ( 
  MK_RT_ARGS
  MQ_CTX const    ctx,
  struct MqSysServerThreadMainS * const   argP,
  MK_STRN         name,
  int             state,
  struct MkIdS *  idP
) {
  SETUP_env;
 
  if (env == NULL)
    return MkErrorSetV_1E("[%s] 'env' pointer is NULL",name);
 
  if (idP->ioIsPipe) {
    jobject runnableO = (*env)->CallStaticObjectMethod(env, MQ(Class_MqMsgque), MQ(MID_Thread_Pipe_callback), (jlong) argP);
 
    if((*env)->ExceptionCheck(env) == JNI_TRUE) {
      OT_ERROR_LNG_2_META(ctx);
      goto error;
    }
 
    idP->type = MK_ID_THREAD;
    idP->val  = (MK_IDNT) (*env)->NewWeakGlobalRef(env,runnableO);
    idP->setByExtern = true;
 
  } else {
    (*env)->CallStaticObjectMethod(env, MQ(Class_MqMsgque), MQ(MID_Thread_Work_callback), (jlong) argP);
 
    if((*env)->ExceptionCheck(env) == JNI_TRUE) {
      OT_ERROR_LNG_2_META(ctx);
      goto error;
    }
 
    idP->type = MK_ID_THREAD;
    idP->val  = (MK_IDNT) 0x1;
  }
 
error:
  return MkErrorStack_0E_Check();
}
 
/*
replaced by sThreadExit/sProcessExit and "true" return
 
static void NS(MkSysExitCB) ( MK_RT_ARGS int isThread, int num ) {
  MkRtSetup_NULL_RT;
  SETUP_env;
  if (isThread) {
#ifndef META_THREAD_POOL
    // 1. do nothing, end of "MqSysServerThreadMain" finish thread
    // 2. "sThreadExit" already detach the thread
    //(*MK(cached_jvm))->DetachCurrentThread(MK(cached_jvm));
#endif
  } else {
    (*env)->CallStaticVoidMethod(env, NS(Class_System), NS(MID_System_exit), (jint) num);
  }
  // FINISH
error:
  return;
}
*/
 
#endif // META_THREAD_POOL
 
// MODULE
 
static void NS(sMqRuntimeCallback) ( MK_RT_ARGS_ONLY ) {
  MQ_STATIC_RT;
 
  // BEGIN-INIT - created by 'jv_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  NS(MqContextC_Init) (MQ_RT_CALL_ONLY) ;
  NS(MqDumpC_Init)    (MQ_RT_CALL_ONLY) ;
  NS(MqFactoryC_Init) (MQ_RT_CALL_ONLY) ;
 
  // END-INIT - created by 'jv_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
}
 
static struct MkRuntimeCallbackS sMqRuntimeCallback = {0};
 
bool MqRuntimeThreadPoolUse = true;
 
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *jvm, void *reserved)
{
  JNIEnv *env;
 
  JavaErrorCheck0 ((*jvm)->GetEnv(jvm, (void*) &env, JNI_VERSION_10));
 
  // init "LibMqMsgque"
  MqSetup();
  AllRtSetup_NULL;
 
  MkSysPipeHandler(MK_PIPE_KEEP);
 
  JavaErrorCheck0 ((*env)->EnsureLocalCapacity(env, 50));
 
  jclass cls;
  #define check(v,c) if ((v=(c))==NULL) return JNI_ERR
#define defClass(v,n)     check(cls, (*env)->FindClass(env, n));\
                          JavaErrorCheck; \
                          check(v, (*env)->NewGlobalRef(env, cls)); \
                          JavaErrorCheck;
#define defOAtr(v,c,n,s)  check(v, (*env)->GetFieldID(env,c,n,s)); \
                          JavaErrorCheck;
#define defSAtr(v,c,n,s)  check(v, (*env)->GetStaticFieldID(env,c,n,s)); \
                          JavaErrorCheck;
#define defOMth(v,c,n,s)  check(v, (*env)->GetMethodID(env,c,n,s)); \
                          JavaErrorCheck;
#define defSMth(v,c,n,s)  check(v, (*env)->GetStaticMethodID(env,c,n,s)); \
                          JavaErrorCheck;
#define defDebug0         MB;
 
#include "MqDefs_jv.h"
 
#undef defDebug0
#undef defClass
#undef defOAtr
#undef defSAtr
#undef defOMth
#undef defSMth
 
  // class specific initialization
  MkRuntimeCallbackAdd( MK_RT_CALL &sMqRuntimeCallback, NS(sMqRuntimeCallback), "JvMqMsgque" );
 
#ifdef META_THREAD_POOL
  MqLal.MqSysServerThreadCB = NS(MqSysServerThreadCB);
  //MkLal.MkSysExitCB         = NS(MkSysExitCB);
#endif // META_THREAD_POOL
 
  return JNI_VERSION_10;
error:
  return JNI_ERR; /* JNI version not supported */
}
 
JNIEXPORT void JNICALL
JNI_OnUnload(JavaVM *jvm, void *reserved)
{
  JNIEnv *env;
  void *val;
  if ((*jvm)->GetEnv(jvm, &val, JNI_VERSION_10)) {
    return;
  }
 
  MkRtSetup_NULL;
 
  // cleanup global variables
  env = (JNIEnv*) val;
 
#define defDebug0
#define defClass(v,n)     (*env)->DeleteGlobalRef(env, v);
#define defOAtr(v,c,n,s)
#define defSAtr(v,c,n,s)
#define defOMth(v,c,n,s)
#define defSMth(v,c,n,s)
 
#include "MqDefs_jv.h"
 
#undef defDebug0
#undef defClass
#undef defOAtr
#undef defSAtr
#undef defOMth
#undef defSMth
 
  MkRuntimeCallbackDel( MK_RT_CALL &sMqRuntimeCallback );
 
  MqCleanup();
 
  return;
}