MqContextC_jv.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "MqContextC_jv.c"
 
#include "jni_h/jvmqmsgque_MqContextC.h"
#include "LibMqMsgque_private_jv.h"
 
 
jobject NS(MqContextC_ObjNew) (MK_RT_ARGS JNIEnv *env, MQ_CTX hdl) {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, MqContextC_X2obj(hdl)) : MK_GET__NS_NULL(MqContextC));
}
 
MK_UNUSED
static jobject NS(MqContextC_ObjCreate) (MK_RT_ARGS JNIEnv *env, MQ_CTX hdl) {
  return MK(AtomObjCreate)(MK_RT_CALL env, MqContextC_X2obj(hdl));
}
 
static MK_PTR NS(MqContextC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_MqContextC), NS(MID_MqContextC_INIT), (jlong) obj, JNI_TRUE);
}
 
#define ClassInit \
 
//  printTxt("init: MqContextC");
 
/* LABEL-END */
 
static MK_TYP MqContextCTT = NULL;
 
// [OVERLOAD THREAD]
static void sThreadExit (MK_RT_ARGS int exitnum)
{
#ifndef META_THREAD_POOL
  (*MK(cached_jvm))->DetachCurrentThread(MK(cached_jvm));
#endif // META_THREAD_POOL
}
 
static void sProcessExit (MK_RT_ARGS int exitnum)
{
  SETUP_env;
  (*env)->CallStaticVoidMethod(env, NS(Class_System), NS(MID_System_exit), (jint) exitnum);
error:
  return;
}
 
static void sWaitForPipe (MK_RT_ARGS MQ_CTX const ctx, const struct MkIdS *idP ) {
  switch ((*idP).type) {  
    case MK_ID_PROCESS: { 
      MkSysWaitForProcess(MK_ERROR_IGNORE, (*idP).val);
      break;
    }
    case MK_ID_THREAD: {
      SETUP_env_X(ctx);
      jobject futureO = (jobject) (*idP).val ;
      if (!(*env)->IsSameObject(env,futureO, NULL)) {
        (*env)->CallVoidMethod(env, futureO, MQ(MID_Thread_wait));
      }
      (*env)->DeleteWeakGlobalRef(env,futureO); 
      break;
    }
    case MK_ID_UNUSED: {
      MkPanicC_1("MK_ID_UNUSED never used");
      break;
    }
  }
}
// [OVERLOAD THREAD]
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_INIT (JNIEnv *env, jobject self) 
{
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  if ((*env)->ExceptionOccurred(env)) goto error;
  MkRtSetup_X(hdl);
  MK_PTR call;
 
  // check for Server
  if (OT_LNG_OBJ_CLASS_IS(self, NS(Class_MqServerSetupIF)) == JNI_TRUE) {
    JavaErrorCheckNULL(call = MK(ProcCreate)(MK_RT_CALL env, self, NULL, NS(MID_MqServerSetupIF), false));
    MqConfigSetServerSetup (hdl, NS(ServiceCall), call, NS(ServiceFree), NS(ServiceCopy));
  }
  if (OT_LNG_OBJ_CLASS_IS(self, NS(Class_MqServerCleanupIF)) == JNI_TRUE) {
    JavaErrorCheckNULL(call = MK(ProcCreate)(MK_RT_CALL env, self, NULL, NS(MID_MqServerCleanupIF), false));
    MqConfigSetServerCleanup (hdl, NS(ServiceCall), call, NS(ServiceFree), NS(ServiceCopy));
  }
 
  // check for BgError
  if (OT_LNG_OBJ_CLASS_IS(self, NS(Class_MqBgErrorIF)) == JNI_TRUE) {
    JavaErrorCheckNULL(call = MK(ProcCreate)(MK_RT_CALL env, self, NULL, NS(MID_MqBgErrorIF), false));
    MqConfigSetBgError (hdl, NS(ServiceCall), call, NS(ServiceFree), NS(ServiceCopy));
  }
 
  // check for Event
  if (OT_LNG_OBJ_CLASS_IS(self, NS(Class_MqEventIF)) == JNI_TRUE) {
    JavaErrorCheckNULL(call = MK(ProcCreate)(MK_RT_CALL env, self, NULL, NS(MID_MqEventIF), false));
    MqConfigSetEvent (hdl, NS(ServiceCall), call, NS(ServiceFree), NS(ServiceCopy));
  }
 
error:
  return;
}
 
// BEGIN-MqContextC - created by 'jv_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
// doc-key: MqContextC,MqContextC-Class-Export,sc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  MQ_CTX __retVal__L = MqContextHandleResolve(netHdl);
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// doc-key: MqContextC,MqContextC-Class-Export,om_
 
// skip class-overload: HandleGet = MqContextHandleGet → MkObjectHandleGet
 
// MqContextC_Class_JV_API
 
 
// doc-key: MqContextC,MqContextC-Class-Introspection,oc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_Next (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX __retVal__L = MqContextNext(hdl);
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_Prev (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX __retVal__L = MqContextPrev(hdl);
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-Class-Introspection,sc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_Instances (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MQ_CTX __retVal__L = MqContextInstances();
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MqContextC_Class_JV_API
 
 
// doc-key: MqContextC,MqContextC-Class-Misc,sc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_GetNull (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MQ_CTX __retVal__L = MqContextGetNull();
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MqContextC_Class_JV_API
 
 
// doc-key: MqContextC,MqContextC-ClassApi-Class,oc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ClassFactoryGet (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_FCT __retVal__L = MqClassFactoryGet(hdl);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-ClassApi-Class,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ClassFactorySet (JNIEnv *env, jobject self, jobject item)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_FCT item_hdl = (MQ_FCT)pObj2Hdl(env,"MqFactoryC",item);
  JavaErrorCheck;
  enum MkErrorE errVal = MqClassFactorySet(hdl, item_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ClassIdentGet (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqClassIdentGet(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ClassIdentSet (JNIEnv *env, jobject self, jstring ident)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqClassIdentSet(hdl, ident_ptr);
  MkErrorC_Check(hdl, errVal)
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
error:
  return;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ClassOriginalIdentGet (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqClassOriginalIdentGet(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_ClassApi_Class_JV_API
 
 
// doc-key: MqContextC,MqContextC-ConfigApi-Get,oco
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ConfigGetIoTcpL (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL vals_out;
  enum MkErrorE errVal = MqConfigGetIoTcpL(hdl, &vals_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,vals_out);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-ConfigApi-Get,om_
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_ConfigGetBuffersize (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 __retVal__L = MqConfigGetBuffersize(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ConfigGetIdentFrom (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MqIdentE __retVal__L = MqConfigGetIdentFrom(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,MQ(Class_MqIdentE),"Ljvmqmsgque/MqIdentE;",MqIdentE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_ConfigGetIoPipe (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_SOCK_HDL __retVal__L = MqConfigGetIoPipe(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ConfigGetIoUds (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqConfigGetIoUds(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ConfigGetIsParent (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqConfigGetIsParent(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ConfigGetIsServer (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqConfigGetIsServer(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ConfigGetIsString (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqConfigGetIsString(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ConfigGetName (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqConfigGetName(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_ConfigGetPkgsize (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 __retVal__L = MqConfigGetPkgsize(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ConfigGetPostfix (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqConfigGetPostfix(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ConfigGetPrefix (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqConfigGetPrefix(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ConfigGetStartAs (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MqStartE __retVal__L = MqConfigGetStartAs(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,MQ(Class_MqStartE),"Ljvmqmsgque/MqStartE;",MqStartE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ConfigGetStatusIs (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MqStatusIsEF __retVal__L = MqConfigGetStatusIs(hdl);
  jobject __retVal__S = MK(pGetEnumFlagFromInt)(env,MQ(Class_MqStatusIsEF),__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ConfigGetStorage (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqConfigGetStorage(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvmqmsgque_MqContextC_ConfigGetTimeout (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_TIME_T __retVal__L = MqConfigGetTimeout(hdl);
  jlong __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetConfigFile (JNIEnv *env, jobject self, jstring filename)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN filename_ptr = (filename?(*env)->GetStringUTFChars(env,filename,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqConfigSetConfigFile(hdl, filename_ptr);
  MkErrorC_Check(hdl, errVal)
  if (filename_ptr) (*env)->ReleaseStringUTFChars(env,filename,filename_ptr);
error:
  return;
}
 
// doc-key: MqContextC,MqContextC-ConfigApi-Get,omo
 
JNIEXPORT jobjectArray JNICALL Java_jvmqmsgque_MqContextC_ConfigGetIoTcp (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN host_out;
  MK_STRN port_out;
  MK_STRN myhost_out;
  MK_STRN myport_out;
  enum MkErrorE errVal = MqConfigGetIoTcp(hdl, &host_out, &port_out, &myhost_out, &myport_out);
  MkErrorC_Check(hdl, errVal)
  jobjectArray __retVal__L = (jobjectArray)(*env)->NewObjectArray(env,4,MK(Class_String),NULL);
  (*env)->SetObjectArrayElement(env,__retVal__L,0,(*env)->NewStringUTF(env,host_out));
  (*env)->SetObjectArrayElement(env,__retVal__L,1,(*env)->NewStringUTF(env,port_out));
  (*env)->SetObjectArrayElement(env,__retVal__L,2,(*env)->NewStringUTF(env,myhost_out));
  (*env)->SetObjectArrayElement(env,__retVal__L,3,(*env)->NewStringUTF(env,myport_out));
  jobjectArray __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_ConfigApi_Get_JV_API
 
 
// doc-key: MqContextC,MqContextC-ConfigApi-Misc,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigReset (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqConfigReset(hdl);
error:
  return;
}
 
// MqContextC_ConfigApi_Misc_JV_API
 
 
// doc-key: MqContextC,MqContextC-ConfigApi-Set,om_
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ConfigCheckStartAs (JNIEnv *env, jobject self, jobject data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MqStartE data_e = MK(pGetEnumFromObj)(env, NS(Class_MqStartE), data);
  JavaErrorCheck;
  MK_BOOL __retVal__L = MqConfigCheckStartAs(hdl, data_e);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetAllDebug (JNIEnv *env, jobject self, jint data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqConfigSetAllDebug(hdl, data);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetBuffersize (JNIEnv *env, jobject self, jint data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqConfigSetBuffersize(hdl, data);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetDaemon (JNIEnv *env, jobject self, jstring pidfile)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN pidfile_ptr = (pidfile?(*env)->GetStringUTFChars(env,pidfile,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqConfigSetDaemon(hdl, pidfile_ptr);
  MkErrorC_Check(hdl, errVal)
  if (pidfile_ptr) (*env)->ReleaseStringUTFChars(env,pidfile,pidfile_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetIdentFrom (JNIEnv *env, jobject self, jobject data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MqIdentE data_e = MK(pGetEnumFromObj)(env, NS(Class_MqIdentE), data);
  JavaErrorCheck;
  MqConfigSetIdentFrom(hdl, data_e);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetIgnoreExit (JNIEnv *env, jobject self, jboolean data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqConfigSetIgnoreExit(hdl, data);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetIoPipe (JNIEnv *env, jobject self, jint fh)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqConfigSetIoPipe(hdl, fh);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetIoTcp__Ljava_lang_String_2Ljava_lang_String_2Ljava_lang_String_2Ljava_lang_String_2 (JNIEnv *env, jobject self, jstring host, jstring port, jstring myhost, jstring myport)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN host_ptr = (host?(*env)->GetStringUTFChars(env,host,NULL):NULL);
  JavaErrorCheck;
  MK_STRN port_ptr = (port?(*env)->GetStringUTFChars(env,port,NULL):NULL);
  JavaErrorCheck;
  MK_STRN myhost_ptr = (myhost?(*env)->GetStringUTFChars(env,myhost,NULL):NULL);
  JavaErrorCheck;
  MK_STRN myport_ptr = (myport?(*env)->GetStringUTFChars(env,myport,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqConfigSetIoTcp(hdl, host_ptr, port_ptr, myhost_ptr, myport_ptr);
  MkErrorC_Check(hdl, errVal)
  if (host_ptr) (*env)->ReleaseStringUTFChars(env,host,host_ptr);
  if (port_ptr) (*env)->ReleaseStringUTFChars(env,port,port_ptr);
  if (myhost_ptr) (*env)->ReleaseStringUTFChars(env,myhost,myhost_ptr);
  if (myport_ptr) (*env)->ReleaseStringUTFChars(env,myport,myport_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetIoTcp__Ljvmkkernel_MkBufferListC_2 (JNIEnv *env, jobject self, jobject vals)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL vals_hdl = (MK_BFL)pObj2Hdl(env,"MkBufferListC",vals);
  JavaErrorCheck;
  enum MkErrorE errVal = MqConfigSetIoTcpL(hdl, vals_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetIoUds (JNIEnv *env, jobject self, jstring file)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN file_ptr = (file?(*env)->GetStringUTFChars(env,file,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqConfigSetIoUds(hdl, file_ptr);
  MkErrorC_Check(hdl, errVal)
  if (file_ptr) (*env)->ReleaseStringUTFChars(env,file,file_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetIsServer (JNIEnv *env, jobject self, jboolean data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqConfigSetIsServer(hdl, data);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetIsString (JNIEnv *env, jobject self, jboolean data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqConfigSetIsString(hdl, data);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetName (JNIEnv *env, jobject self, jstring data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN data_ptr = (data?(*env)->GetStringUTFChars(env,data,NULL):NULL);
  JavaErrorCheck;
  MqConfigSetName(hdl, data_ptr);
  if (data_ptr) (*env)->ReleaseStringUTFChars(env,data,data_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetPkgsize (JNIEnv *env, jobject self, jint data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqConfigSetPkgsize(hdl, data);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetPostfix (JNIEnv *env, jobject self, jstring data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN data_ptr = (data?(*env)->GetStringUTFChars(env,data,NULL):NULL);
  JavaErrorCheck;
  MqConfigSetPostfix(hdl, data_ptr);
  if (data_ptr) (*env)->ReleaseStringUTFChars(env,data,data_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetPrefix (JNIEnv *env, jobject self, jstring data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN data_ptr = (data?(*env)->GetStringUTFChars(env,data,NULL):NULL);
  JavaErrorCheck;
  MqConfigSetPrefix(hdl, data_ptr);
  if (data_ptr) (*env)->ReleaseStringUTFChars(env,data,data_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetStartAs (JNIEnv *env, jobject self, jobject data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MqStartE data_e = MK(pGetEnumFromObj)(env, NS(Class_MqStartE), data);
  JavaErrorCheck;
  enum MkErrorE errVal = MqConfigSetStartAs(hdl, data_e);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetStartAsString (JNIEnv *env, jobject self, jstring data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN data_ptr = (data?(*env)->GetStringUTFChars(env,data,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqConfigSetStartAsString(hdl, data_ptr);
  MkErrorC_Check(hdl, errVal)
  if (data_ptr) (*env)->ReleaseStringUTFChars(env,data,data_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetStorage (JNIEnv *env, jobject self, jstring data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN data_ptr = (data?(*env)->GetStringUTFChars(env,data,NULL):NULL);
  JavaErrorCheck;
  MqConfigSetStorage(hdl, data_ptr);
  if (data_ptr) (*env)->ReleaseStringUTFChars(env,data,data_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ConfigSetTimeout (JNIEnv *env, jobject self, jlong data)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqConfigSetTimeout(hdl, data);
error:
  return;
}
 
// MqContextC_ConfigApi_Set_JV_API
 
 
// doc-key: MqContextC,MqContextC-EnvApi-Env,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_EnvProtect (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqEnvProtect(hdl);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_EnvRestore (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqEnvRestore(hdl);
error:
  return;
}
 
// MqContextC_EnvApi_Env_JV_API
 
 
// doc-key: MqContextC,MqContextC-ErrorApi-Error,oc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ErrorFORMAT (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl__null_allow(env,self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_ERR __retVal__L = MqContextErrorFORMAT(hdl);
  jobject __retVal__S = MK(MkErrorC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-ErrorApi-Error,om_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ErrorCopy (JNIEnv *env, jobject self, jobject sourceCtx)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTXN sourceCtx_hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",sourceCtx);
  JavaErrorCheck;
  enum MkErrorE errVal = MqContextErrorCopy(hdl, sourceCtx_hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkErrorE),"Ljvmqmsgque/MkErrorE;",MkErrorE_ToString(errVal));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ErrorMove (JNIEnv *env, jobject self, jobject sourceCtx)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTXN sourceCtx_hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",sourceCtx);
  JavaErrorCheck;
  enum MkErrorE errVal = MqContextErrorMove(hdl, sourceCtx_hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkErrorE),"Ljvmqmsgque/MkErrorE;",MkErrorE_ToString(errVal));
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_ErrorApi_Error_JV_API
 
 
// doc-key: MqContextC,MqContextC-LinkApi-Link,oc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_LinkGetParent (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX __retVal__L = MqLinkGetParent(hdl);
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-LinkApi-Link,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LinkConnect (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqLinkConnect(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LinkCreate (JNIEnv *env, jobject self, jobject args)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BAC args_hdl = (MK_BAC)pObj2Hdl__null_allow(env,args);
  JavaErrorCheck;
  enum MkErrorE errVal = MqLinkCreate(hdl, args_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LinkCreateChild (JNIEnv *env, jobject self, jobject parent, jobject args)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX parent_hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",parent);
  JavaErrorCheck;
  MK_BAC args_hdl = (MK_BAC)pObj2Hdl__null_allow(env,args);
  JavaErrorCheck;
  enum MkErrorE errVal = MqLinkCreateChild(hdl, parent_hdl, args_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LinkDelete (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqLinkDelete(hdl);
error:
  return;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_LinkGetCtxId (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_NUM __retVal__L = MqLinkGetCtxId(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_LinkGetTargetIdent (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqLinkGetTargetIdent(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_LinkIsConnected (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqLinkIsConnected(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_LinkIsParent (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqLinkIsParent(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LinkShutdown (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqLinkShutdown(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// MqContextC_LinkApi_Link_JV_API
 
 
// doc-key: MqContextC,MqContextC-LogApi-Log,om_
 
// skip class-overload: Log = MqContextLog → MkObjectLog
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LogConfig (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeGetDebug())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MqContextLogConfig(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LogEnv (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeGetDebug())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MqContextLogEnv(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LogLink (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeGetDebug())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MqContextLogLink(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LogSetup (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeGetDebug())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MqContextLogSetup(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LogShort (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl, jstring label)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeGetDebug())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MK_STRN label_ptr = (label?(*env)->GetStringUTFChars(env,label,NULL):NULL);
  JavaErrorCheck;
  MqContextLogShort(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl, label_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
  if (label_ptr) (*env)->ReleaseStringUTFChars(env,label,label_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_LogType (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_OBJN fmtobj_hdl = (MK_OBJN)pObj2Hdl__null_allow(env,fmtobj);
  JavaErrorCheck;
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  if (debug > (jint)(MkRuntimeGetDebug())) {return;}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MqContextLogType(hdl, fmtobj_hdl, debug, callfunc_ptr, lvl);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_LogParentOrChild (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqLogParentOrChild(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_LogServerOrClient (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN __retVal__L = MqLogServerOrClient(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_LogApi_Log_JV_API
 
 
// doc-key: MqContextC,MqContextC-MiscApi-Misc,oc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_GetBuffer (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF __retVal__L = MqContextGetBuffer(hdl);
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_GetRoot (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX __retVal__L = MqGetRoot(hdl);
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-MiscApi-Misc,om_
 
// skip class-overload: ToString = MqContextToString → MkObjectToString
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_Exit (JNIEnv *env, jobject self, jstring callfunc, jstring callfile, jint callline)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  if (callline == -1 && callfile == NULL && callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callline == -1) {callline = MK(pGetCallerLine)(env);}
  if (callfile == NULL) {callfile = MK(pGetCallerFile)(env);}
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  MK_STRN callfile_ptr = (callfile?(*env)->GetStringUTFChars(env,callfile,NULL):NULL);
  JavaErrorCheck;
  MqExit(hdl, callfunc_ptr, callfile_ptr, callline);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
  if (callfile_ptr) (*env)->ReleaseStringUTFChars(env,callfile,callfile_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ProcessEvent (JNIEnv *env, jobject self, jobject wait, jlong timeout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MqWaitOnEventE wait_e = MK(pGetEnumFromObj)(env, NS(Class_MqWaitOnEventE), wait);
  JavaErrorCheck;
  enum MkErrorE errVal = MqProcessEvent(hdl, wait_e, timeout);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// MqContextC_MiscApi_Misc_JV_API
 
 
// doc-key: MqContextC,MqContextC-ProxyApi-Proxy,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ProxyForward (JNIEnv *env, jobject self, jobject targetCtx, jobject dump, jlong timeout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX targetCtx_hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",targetCtx);
  JavaErrorCheck;
  MQ_DMP dump_hdl = (MQ_DMP)pObj2Hdl__null_allow(env,dump);
  JavaErrorCheck;
  enum MkErrorE errVal = MqProxyForward(hdl, targetCtx_hdl, dump_hdl, timeout);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ProxyItem (JNIEnv *env, jobject self, jobject targetCtx)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX targetCtx_hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",targetCtx);
  JavaErrorCheck;
  enum MkErrorE errVal = MqProxyItem(hdl, targetCtx_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// MqContextC_ProxyApi_Proxy_JV_API
 
 
// doc-key: MqContextC,MqContextC-ReadApi-Atom,oci
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ReadALL (JNIEnv *env, jobject self, jobject val_inout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL val_inout_hdl = (MK_BFL)pObj2Hdl__null_allow(env,val_inout);
  JavaErrorCheck;
  enum MkErrorE errVal = MqReadALL(hdl, &val_inout_hdl);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,val_inout_hdl);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-ReadApi-Atom,oco
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ReadBFL (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL val_out;
  enum MkErrorE errVal = MqReadBFL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ReadBUF (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF val_out;
  enum MkErrorE errVal = MqReadBUF(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferC_ObjNew)(MK_RT_CALL env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-ReadApi-Atom,omo
 
JNIEXPORT jbyteArray JNICALL Java_jvmqmsgque_MqContextC_ReadBIN (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBinaryR val_out_ref;
  enum MkErrorE errVal = MqReadBIN(hdl, &val_out_ref);
  MkErrorC_Check(hdl, errVal)
  const jsize val_out_size = (jsize) val_out_ref.size;
  const jbyte *val_out_byte = (jbyte*) val_out_ref.data;
  jbyteArray val_out = (*env)->NewByteArray(env, val_out_size);
  JavaErrorCheck;
  (*env)->SetByteArrayRegion(env,val_out,0,val_out_size,val_out_byte);
  JavaErrorCheck;
  jbyteArray __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ReadBOL (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOL val_out;
  enum MkErrorE errVal = MqReadBOL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jboolean __retVal__S = val_out != 0;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jbyteArray JNICALL Java_jvmqmsgque_MqContextC_ReadBinaryR (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkBinaryR val_out_ref;
  enum MkErrorE errVal = MqReadBinaryR(hdl, &val_out_ref);
  MkErrorC_Check(hdl, errVal)
  const jsize val_out_size = (jsize) val_out_ref.size;
  const jbyte *val_out_byte = (jbyte*) val_out_ref.data;
  jbyteArray val_out = (*env)->NewByteArray(env, val_out_size);
  JavaErrorCheck;
  (*env)->SetByteArrayRegion(env,val_out,0,val_out_size,val_out_byte);
  JavaErrorCheck;
  jbyteArray __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jdouble JNICALL Java_jvmqmsgque_MqContextC_ReadDBL (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_DBL val_out;
  enum MkErrorE errVal = MqReadDBL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jdouble __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jfloat JNICALL Java_jvmqmsgque_MqContextC_ReadFLT (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_FLT val_out;
  enum MkErrorE errVal = MqReadFLT(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jfloat __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_ReadHDL (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_HDL val_out;
  enum MkErrorE errVal = MqReadHDL(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jshort JNICALL Java_jvmqmsgque_MqContextC_ReadI16 (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I16 val_out;
  enum MkErrorE errVal = MqReadI16(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jshort __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_ReadI32 (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 val_out;
  enum MkErrorE errVal = MqReadI32(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvmqmsgque_MqContextC_ReadI64 (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I64 val_out;
  enum MkErrorE errVal = MqReadI64(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jlong __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jbyte JNICALL Java_jvmqmsgque_MqContextC_ReadI8 (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I8 val_out;
  enum MkErrorE errVal = MqReadI8(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jbyte __retVal__S = (jbyte)val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT MK_NAT_LIST JNICALL ReadLIST (JNIEnv *env, jobject self); // skip template-required
 
JNIEXPORT jlong JNICALL Java_jvmqmsgque_MqContextC_ReadLONG (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_LONG val_out;
  enum MkErrorE errVal = MqReadLONG(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jlong __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT MK_NAT_OBJECT JNICALL ReadNEXT (JNIEnv *env, jobject self); // skip template-required
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ReadSTR (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_out;
  enum MkErrorE errVal = MqReadSTR(hdl, &val_out);
  MkErrorC_Check(hdl, errVal)
  jstring __retVal__S = JC2O(env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ReadStringR (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkStringR val_out_ref;
  enum MkErrorE errVal = MqReadStringR(hdl, &val_out_ref);
  MkErrorC_Check(hdl, errVal)
  jstring val_out = (*env)->NewStringUTF(env, val_out_ref.ptr);
  JavaErrorCheck;
  jstring __retVal__S = val_out;
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_ReadApi_Atom_JV_API
 
 
// doc-key: MqContextC,MqContextC-ReadApi-Block,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ReadL_1END (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqReadL_END(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ReadL_1START (JNIEnv *env, jobject self, jobject buf)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUF buf_hdl = (MK_BUF)pObj2Hdl__null_allow(env,buf);
  JavaErrorCheck;
  enum MkErrorE errVal = MqReadL_START(hdl, buf_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ReadT_1END (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqReadT_END(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ReadT_1START (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqReadT_START(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// MqContextC_ReadApi_Block_JV_API
 
 
// doc-key: MqContextC,MqContextC-ReadApi-Misc,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ReadDbg (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MqReadDbg(hdl);
error:
  return;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_ReadGetNextType (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkTypeE __retVal__L = MqReadGetNextType(hdl);
  jobject __retVal__S = MK(pGetEnumFromString)(env,MK(Class_MkTypeE),"Ljvmqmsgque/MkTypeE;",MkTypeE_ToString(__retVal__L));
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_ReadGetNumItems (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_NUM __retVal__L = MqReadGetNumItems(hdl);
  jint __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ReadItemExists (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqReadItemExists(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ReadUndo (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqReadUndo(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// MqContextC_ReadApi_Misc_JV_API
 
 
// doc-key: MqContextC,MqContextC-RouteApi-Route,oco
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_RouteGetTree (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFL treeP_out;
  enum MkErrorE errVal = MqRouteGetTree(hdl, &treeP_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MK(MkBufferListC_ObjNew)(MK_RT_CALL env,treeP_out);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-RouteApi-Route,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_RouteCreate (JNIEnv *env, jobject self, jstring route, jstring service, jboolean overwrite)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN route_ptr = (route?(*env)->GetStringUTFChars(env,route,NULL):NULL);
  JavaErrorCheck;
  MK_STRN service_ptr = (service?(*env)->GetStringUTFChars(env,service,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqRouteCreate(hdl, route_ptr, service_ptr, overwrite);
  MkErrorC_Check(hdl, errVal)
  if (route_ptr) (*env)->ReleaseStringUTFChars(env,route,route_ptr);
  if (service_ptr) (*env)->ReleaseStringUTFChars(env,service,service_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_RouteDelete (JNIEnv *env, jobject self, jstring route, jstring service, jboolean overwrite)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN route_ptr = (route?(*env)->GetStringUTFChars(env,route,NULL):NULL);
  JavaErrorCheck;
  MK_STRN service_ptr = (service?(*env)->GetStringUTFChars(env,service,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqRouteDelete(hdl, route_ptr, service_ptr, overwrite);
  MkErrorC_Check(hdl, errVal)
  if (route_ptr) (*env)->ReleaseStringUTFChars(env,route,route_ptr);
  if (service_ptr) (*env)->ReleaseStringUTFChars(env,service,service_ptr);
error:
  return;
}
 
JNIEXPORT jobjectArray JNICALL Java_jvmqmsgque_MqContextC_RouteResolve (JNIEnv *env, jobject self, jstring ident, jint retnum)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  MQ_CTX_A __retVal__L = MqRouteResolve(hdl, ident_ptr, retnum);
  jobjectArray ret = (*env)->NewObjectArray(env, (jsize)__retVal__L.size, MQ(Class_ME_CCC_MqContextC), NULL);
  for (MK_NUM num=0; num<__retVal__L.size; num++) {
    (*env)->SetObjectArrayElement(env, ret, num, MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L.data[num]));
  }
  jobjectArray __retVal__S = ret;
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_RouteTraverse (JNIEnv *env, jobject self, jstring service, jobject args)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BAC args_hdl = (MK_BAC)pObj2Hdl__null_allow(env,args);
  JavaErrorCheck;
  MK_STRN service_ptr = (service?(*env)->GetStringUTFChars(env,service,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqRouteTraverse(hdl, service_ptr, args_hdl);
  MkErrorC_Check(hdl, errVal)
  if (service_ptr) (*env)->ReleaseStringUTFChars(env,service,service_ptr);
error:
  return;
}
 
// doc-key: MqContextC,MqContextC-RouteApi-Route,omo
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_RouteGetPath (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN path_out;
  enum MkErrorE errVal = MqRouteGetPath(hdl, &path_out);
  MkErrorC_Check(hdl, errVal)
  jstring __retVal__S = JC2O(env,path_out);
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_RouteApi_Route_JV_API
 
 
// doc-key: MqContextC,MqContextC-SendApi-Atom,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendBFL (JNIEnv *env, jobject self, jobject val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFLN val_hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",val);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendBFL(hdl, val_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendBIN (JNIEnv *env, jobject self, jbyteArray val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BINN val_data = (MK_BINN) (*env)->GetByteArrayElements(env, val, NULL);
  JavaErrorCheck;
  MK_SIZE val_size = (MK_SIZE) (*env)->GetArrayLength (env, val);
  JavaErrorCheck;
  MkBinaryR val_ref = MkBinaryCreate(val_size,val_data);
  enum MkErrorE errVal = MqSendBIN(hdl, val_ref);
  MkErrorC_Check(hdl, errVal)
  (*env)->ReleaseByteArrayElements(env, val, (jbyte*)val_data, JNI_ABORT);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendBOL (JNIEnv *env, jobject self, jboolean val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendBOL(hdl, (MK_BOL)(val?1:0));
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendBUF (JNIEnv *env, jobject self, jobject val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUFN val_hdl = (MK_BUFN)pObj2Hdl(env,"MkBufferC",val);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendBUF(hdl, val_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendBUS_1FLAT (JNIEnv *env, jobject self, jobject val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BUSN val_hdl = (MK_BUSN)pObj2Hdl(env,"MkBufferStreamC",val);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendBUS_FLAT(hdl, val_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendBinaryR (JNIEnv *env, jobject self, jbyteArray val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BINN val_data = (MK_BINN) (*env)->GetByteArrayElements(env, val, NULL);
  JavaErrorCheck;
  MK_SIZE val_size = (MK_SIZE) (*env)->GetArrayLength (env, val);
  JavaErrorCheck;
  MkBinaryR val_ref = MkBinaryCreate(val_size,val_data);
  enum MkErrorE errVal = MqSendBinaryR(hdl, val_ref);
  MkErrorC_Check(hdl, errVal)
  (*env)->ReleaseByteArrayElements(env, val, (jbyte*)val_data, JNI_ABORT);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendDBL (JNIEnv *env, jobject self, jdouble val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendDBL(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendFLT (JNIEnv *env, jobject self, jfloat val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendFLT(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendHDL (JNIEnv *env, jobject self, jint val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendHDL(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendI16 (JNIEnv *env, jobject self, jshort val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendI16(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendI32 (JNIEnv *env, jobject self, jint val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendI32(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendI64 (JNIEnv *env, jobject self, jlong val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendI64(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendI8 (JNIEnv *env, jobject self, jbyte val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendI8(hdl, (MK_I8)(val));
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendLONG (JNIEnv *env, jobject self, jlong val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendLONG(hdl, val);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendLTR (JNIEnv *env, jobject self, jint transLId)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendLTR(hdl, transLId);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendL_1FLAT (JNIEnv *env, jobject self, jobject val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BFLN val_hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",val);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendL_FLAT(hdl, val_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendSTR (JNIEnv *env, jobject self, jstring val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN val_ptr = (val?(*env)->GetStringUTFChars(env,val,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendSTR(hdl, val_ptr);
  MkErrorC_Check(hdl, errVal)
  if (val_ptr) (*env)->ReleaseStringUTFChars(env,val,val_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendStringR (JNIEnv *env, jobject self, jstring val)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MkStringR val_ref = MkStringCreate((*env)->GetStringUTFLength(env,val),(val?(*env)->GetStringUTFChars(env,val,NULL):NULL));
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendStringR(hdl, val_ref);
  MkErrorC_Check(hdl, errVal)
  if (val_ref.ptr) (*env)->ReleaseStringUTFChars(env,val,val_ref.ptr);
error:
  return;
}
 
// MqContextC_SendApi_Atom_JV_API
 
 
// doc-key: MqContextC,MqContextC-SendApi-Basics,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendEND (JNIEnv *env, jobject self, jstring token, jlong timeout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendEND(hdl, token_ptr, timeout);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendEND_1AND_1CALLBACK (JNIEnv *env, jobject self, jstring token, jobject callback, jlong timeout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  MK_CBP callback_ptr = MK(ProcCreate)(MK_RT_CALL env, callback, NULL, NS(MID_callback), true);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendEND_AND_CALLBACK(hdl, token_ptr, NS(ServiceCall), callback_ptr, NS(ServiceFree), timeout);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendEND_1AND_1SUB (JNIEnv *env, jobject self, jstring token, jobject callback, jlong timeout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  MK_CBP callback_ptr = MK(ProcCreate)(MK_RT_CALL env, callback, NULL, NS(MID_callback), true);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendEND_AND_SUB(hdl, token_ptr, NS(ServiceCall), callback_ptr, NS(ServiceFree), timeout);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendEND_1AND_1TRANSACTION (JNIEnv *env, jobject self, jstring token, jstring callback, jlong timeout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  MQ_TOK callback_ptr = (callback?(*env)->GetStringUTFChars(env,callback,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendEND_AND_TRANSACTION(hdl, token_ptr, callback_ptr, timeout);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
  if (callback_ptr) (*env)->ReleaseStringUTFChars(env,callback,callback_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendEND_1AND_1WAIT (JNIEnv *env, jobject self, jstring token, jlong timeout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSendEND_AND_WAIT(hdl, token_ptr, timeout);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendSTART (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendSTART(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendSYNC (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendSYNC(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// MqContextC_SendApi_Basics_JV_API
 
 
// doc-key: MqContextC,MqContextC-SendApi-Block,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendL_1END (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendL_END(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendL_1START (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendL_START(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendT_1END (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendT_END(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendT_1START (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendT_START(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// MqContextC_SendApi_Block_JV_API
 
 
// doc-key: MqContextC,MqContextC-SendApi-Return,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendERROR (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendERROR(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendRETURN (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendRETURN(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SendRETURN_1SUB (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSendRETURN_SUB(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
// MqContextC_SendApi_Return_JV_API
 
 
// doc-key: MqContextC,MqContextC-ServiceApi-Service,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ServiceCreate (JNIEnv *env, jobject self, jstring token, jobject callback)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  MK_CBP callback_ptr = MK(ProcCreate)(MK_RT_CALL env, callback, NULL, NS(MID_callback), true);
  JavaErrorCheck;
  enum MkErrorE errVal = MqServiceCreate(hdl, token_ptr, NS(ServiceCall), callback_ptr, NS(ServiceFree), NULL);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ServiceDelete (JNIEnv *env, jobject self, jstring token)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqServiceDelete(hdl, token_ptr);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ServiceIsTransaction (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqServiceIsTransaction(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ServiceProxy (JNIEnv *env, jobject self, jstring token, jint id)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqServiceProxy(hdl, token_ptr, id);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ServiceProxyCtx (JNIEnv *env, jobject self, jstring token, jobject target)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX target_hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",target);
  JavaErrorCheck;
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqServiceProxyCtx(hdl, token_ptr, target_hdl);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ServiceProxyCtxExists (JNIEnv *env, jobject self, jstring token, jobject target)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX target_hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",target);
  JavaErrorCheck;
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  MK_BOOL __retVal__L = MqServiceProxyCtxExists(hdl, token_ptr, target_hdl);
  jboolean __retVal__S = __retVal__L;
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ServiceProxyRoundRobin (JNIEnv *env, jobject self, jstring token, jstring ident)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqServiceProxyRoundRobin(hdl, token_ptr, ident_ptr);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_ServiceStorage (JNIEnv *env, jobject self, jstring token)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqServiceStorage(hdl, token_ptr);
  MkErrorC_Check(hdl, errVal)
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
error:
  return;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ServiceTokenCheck (JNIEnv *env, jobject self, jstring token)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  MK_BOOL __retVal__L = MqServiceTokenCheck(hdl, token_ptr);
  jboolean __retVal__S = __retVal__L;
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_ServiceTokenExists (JNIEnv *env, jobject self, jstring token)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK token_ptr = (token?(*env)->GetStringUTFChars(env,token,NULL):NULL);
  JavaErrorCheck;
  MK_BOOL __retVal__L = MqServiceTokenExists(hdl, token_ptr);
  jboolean __retVal__S = __retVal__L;
  if (token_ptr) (*env)->ReleaseStringUTFChars(env,token,token_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqContextC_ServiceTokenGet (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_TOK __retVal__L = MqServiceTokenGet(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_ServiceApi_Service_JV_API
 
 
// doc-key: MqContextC,MqContextC-SlaveApi-Slave,oc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_SlaveGetMaster (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX __retVal__L = MqSlaveGetMaster(hdl);
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-SlaveApi-Slave,oco
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_SlaveGet (JNIEnv *env, jobject self, jint id)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX ctx_out;
  enum MkErrorE errVal = MqSlaveGet(hdl, id, &ctx_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,ctx_out);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_SlaveGetFilter (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX ctx_out;
  enum MkErrorE errVal = MqSlaveGetFilter(hdl, &ctx_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,ctx_out);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_SlaveGetProxy (JNIEnv *env, jobject self, jint id)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX ctx_out;
  enum MkErrorE errVal = MqSlaveGetProxy(hdl, id, &ctx_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,ctx_out);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-SlaveApi-Slave,om_
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_SlaveCheck (JNIEnv *env, jobject self, jint id)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqSlaveCheck(hdl, id);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SlaveCreate (JNIEnv *env, jobject self, jint id, jobject slave)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX slave_hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",slave);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSlaveCreate(hdl, id, slave_hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SlaveDelete (JNIEnv *env, jobject self, jint id)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqSlaveDelete(hdl, id);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT jboolean JNICALL Java_jvmqmsgque_MqContextC_SlaveIs (JNIEnv *env, jobject self)  {
  MQ_CTXN hdl = (MQ_CTXN)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BOOL __retVal__L = MqSlaveIs(hdl);
  jboolean __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_SlaveWorker (JNIEnv *env, jobject self, jint id, jstring fct, jobject args)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_BAC args_hdl = (MK_BAC)pObj2Hdl__null_allow(env,args);
  JavaErrorCheck;
  MK_STRN fct_ptr = (fct?(*env)->GetStringUTFChars(env,fct,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqSlaveWorker(hdl, id, fct_ptr, args_hdl);
  MkErrorC_Check(hdl, errVal)
  if (fct_ptr) (*env)->ReleaseStringUTFChars(env,fct,fct_ptr);
error:
  return;
}
 
// MqContextC_SlaveApi_Slave_JV_API
 
 
// doc-key: MqContextC,MqContextC-StorageApi-Storage,oci
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_StorageDelete (JNIEnv *env, jobject self, jint transLIdP_inout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqStorageDelete(hdl, &transLIdP_inout);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = transLIdP_inout;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_StorageImport (JNIEnv *env, jobject self, jint transLIdP_inout)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqStorageImport(hdl, &transLIdP_inout);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = transLIdP_inout;
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqContextC,MqContextC-StorageApi-Storage,om_
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_StorageClose (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqStorageClose(hdl);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_StorageDecrRef (JNIEnv *env, jobject self, jint transLId)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqStorageDecrRef(hdl, transLId);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_StorageIncrRef (JNIEnv *env, jobject self, jint transLId)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  enum MkErrorE errVal = MqStorageIncrRef(hdl, transLId);
  MkErrorC_Check(hdl, errVal)
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_StorageLog (JNIEnv *env, jobject self, jstring callfunc)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  if (callfunc == NULL) {
    (*env)->CallStaticVoidMethod(env,MK(Class_MkKernel),MK(MID_MkKernel_getCallerStack));
  }
  if (callfunc == NULL) {callfunc = MK(pGetCallerProc)(env);}
  MK_STRN callfunc_ptr = (callfunc?(*env)->GetStringUTFChars(env,callfunc,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqStorageLog(hdl, callfunc_ptr);
  MkErrorC_Check(hdl, errVal)
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_StorageOpen (JNIEnv *env, jobject self, jstring storageFile)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_STRN storageFile_ptr = (storageFile?(*env)->GetStringUTFChars(env,storageFile,NULL):NULL);
  JavaErrorCheck;
  enum MkErrorE errVal = MqStorageOpen(hdl, storageFile_ptr);
  MkErrorC_Check(hdl, errVal)
  if (storageFile_ptr) (*env)->ReleaseStringUTFChars(env,storageFile,storageFile_ptr);
error:
  return;
}
 
// doc-key: MqContextC,MqContextC-StorageApi-Storage,omo
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_StorageCount (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_LTR cnt_out;
  enum MkErrorE errVal = MqStorageCount(hdl, &cnt_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = cnt_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_StorageErrCnt (JNIEnv *env, jobject self, jint transLId)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MK_I32 cnt_out;
  enum MkErrorE errVal = MqStorageErrCnt(hdl, transLId, &cnt_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = cnt_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jint JNICALL Java_jvmqmsgque_MqContextC_StorageExport (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_LTR ltid_out;
  enum MkErrorE errVal = MqStorageExport(hdl, &ltid_out);
  MkErrorC_Check(hdl, errVal)
  jint __retVal__S = ltid_out;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobjectArray JNICALL Java_jvmqmsgque_MqContextC_StorageResolve (JNIEnv *env, jobject self)  {
  MQ_CTX hdl = (MQ_CTX)pObj2Hdl(env,"MqContextC",self);
  JavaErrorCheck;
  MkRtSetup_X(hdl);
  MQ_CTX otherCtxP_out;
  MQ_LTR otherLIdP_out;
  enum MkErrorE errVal = MqStorageResolve(hdl, &otherCtxP_out, &otherLIdP_out);
  MkErrorC_Check(hdl, errVal)
  jobjectArray __retVal__L = (jobjectArray)(*env)->NewObjectArray(env,2,MK(Class_Object),NULL);
  (*env)->SetObjectArrayElement(env,__retVal__L,0,MQ(MqContextC_ObjNew)(MK_RT_CALL env,otherCtxP_out));
  (*env)->SetObjectArrayElement(env,__retVal__L,1,pNewIntObj(env,otherLIdP_out));
  jobjectArray __retVal__S = __retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_StorageApi_Storage_JV_API
 
 
// doc-key: MqContextC,MqContextC-TOR,sCc
 
JNIEXPORT jlong JNICALL Java_jvmqmsgque_MqContextC_CTOR (JNIEnv *env, jclass class, jobject tmpl)  {
  MkRtSetup_NULL;
  MQ_CTX tmpl_hdl = (MQ_CTX)pObj2Hdl__null_allow(env,tmpl);
  JavaErrorCheck;
  MQ_CTX __retVal__L = MqContextCreate(MqContextCTT, tmpl_hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MqContextC.CTOR");
    goto error;
  }
  jlong __retVal__S = (jlong)__retVal__L;
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqContextC_Create (JNIEnv *env, jclass class, jobject tmpl)  {
  MkRtSetup_NULL;
  MQ_CTX tmpl_hdl = (MQ_CTX)pObj2Hdl__null_allow(env,tmpl);
  JavaErrorCheck;
  MQ_CTX __retVal__L = MqContextCreate(MqContextCTT, tmpl_hdl);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MqContextC.Create");
    goto error;
  }
  jobject __retVal__S = MQ(MqContextC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// MqContextC_TOR_JV_API
 
// END-MqContextC - created by 'jv_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
void NS(MqContextC_Init)(MK_RT_ARGS_ONLY) {
  MQ_STATIC_RT;
  ClassInit
 
  // define type
  MqContextCTT = MkTypeDup2(MqContextC_TT,"javamsgue_MqContextC");
  MqContextCTT->selfCreate          =  NS(MqContextC_selfCreate) ;
  MqContextCTT->selfUnlink          =  MK(AtomSelfUnlink) ;
  MqContextCT->argvFix              =  true ;
  MqContextCT->MqProcessExitCB      =  sProcessExit ;
  MqContextCT->MqThreadExitCB       =  sThreadExit ;
  MqContextCT->MqWaitForPipeCB      =  sWaitForPipe ;
  MqContextCT->Child.fCreate        =  MqLinkDefault_RT ;
  MqContextCT->Parent.fCreate       =  MqLinkDefault_RT ;
  MqContextCT->ignoreFork           =  true ;
  MqContextCT->ignoreDisasterSetup  =  true ;
}