MqFactoryC_jv.c

Go to the documentation of this file.

 
/* LABEL-START */
#define META_FILE_NAME "MqFactoryC_jv.c"
 
#include "jni_h/jvmqmsgque_MqFactoryC.h"
#include "LibMqMsgque_private_jv.h"
 
 
jobject NS(MqFactoryC_ObjNew) (MK_RT_ARGS JNIEnv *env, MQ_FCT hdl) {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, MqFactoryC_X2obj(hdl)) : MK_GET__NS_NULL(MqFactoryC));
}
 
MK_UNUSED
static jobject NS(MqFactoryC_ObjCreate) (MK_RT_ARGS JNIEnv *env, MQ_FCT hdl) {
  return MK(AtomObjCreate)(MK_RT_CALL env, MqFactoryC_X2obj(hdl));
}
 
static MK_PTR NS(MqFactoryC_selfCreate) (MK_RT_ARGS MK_OBJ obj, MK_PTR envP) {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_MqFactoryC), NS(MID_MqFactoryC_INIT), (jlong) obj, JNI_TRUE);
}
 
#define ClassInit \
 
//  printTxt("init: MqFactoryC");
 
/* LABEL-END */
 
//
//    P R I V A T E
//
 
#include "jni_h/jvmkkernel_MkObjectC.h"
#include "jni_h/jvmqmsgque_MqContextC.h"
 
struct FactoryCallS {
  jclass      class;
  jmethodID   method;
};
 
static MK_PTR NS(sFactorySetup) (
  MK_RT_ARGS
  JNIEnv*   env,
  jclass    class,
  jmethodID method
)
{
  struct FactoryCallS *call = MkSysMalloc(MK_ERROR_PANIC, sizeof(*call));
  JavaErrorCheckNULL (call->class = (*env)->NewGlobalRef(env, class));
  call->method = method;
  return call;
error:
  MkSysFree(call);
  return NULL;
}
 
static void MK_DECL NS(sFactoryDataCopy) (
  MK_RT_ARGS
  MK_PTR *dataP
)
{
  SETUP_env
  struct FactoryCallS * call = (struct FactoryCallS *) *dataP;
  *dataP = NS(sFactorySetup) (MK_RT_CALL env, call->class, call->method);
error:
  return;
}
 
static void MK_DECL NS(sFactoryDataFree) (
  MK_RT_ARGS
  MK_PTR *dataP
)
{
  SETUP_env
  struct FactoryCallS * call = (struct FactoryCallS *) *dataP;
  // this function will be called on !exit! but "java" is already gone -> no java cleanup
  // update windows require this code
  (*env)->DeleteGlobalRef(env, call->class);
error:
  MkSysFree(*dataP);
}
 
static void MK_DECL NS(sFactoryDTor) (
  MK_RT_ARGS
  MQ_CTX context,
  bool dofactoryCleanup,
  MQ_FCT const fct
)
{
  MqContextDelete(context);
}
 
static enum MkErrorE MK_DECL NS(sFactoryCTor) ( MQ_CALLBACK_FACTORY_CTOR_ARGS )
{
  MQ_CTX mqctx = NULL;
  JNIEnv * env = NULL;
  struct FactoryCallS const * const call = (struct FactoryCallS const * const) fct->fct_ctor.data;
  jclass clazz = call->class;
  jmethodID meth = call->method;
 
  // get env
  MkErrorCheck(MK(GetJniEnv)(MK_RT_CALL &env));
 
  jobject tmplO = ( create == MQ_FACTORY_NEW_INIT || tmpl == NULL ? NULL : AtomObjNew_X(env,tmpl) );
  
  // get "class" and "meth" from "parent"
  if (create & (MQ_FACTORY_NEW_CHILD)) {
    JavaErrorCheckNULL(clazz = (*env)->GetObjectClass (env, tmplO));
    JavaErrorCheckNULL(meth  = (*env)->GetMethodID(env,clazz,"<init>","(Ljvmqmsgque/MqContextC;)V"));
  }
 
  // create new object
  {
    jobject obj = (*env)->NewObject(env, clazz, meth, tmplO);
    if (obj == NULL || MkErrorCheckE_0E()) {
      // special:  JAVA does NOT call the destructor of a "broken" instance, this create a "left-over"
      //           MkRuntimeS::cid (not bad but different from other languages)
      // set at:   MqContextInit->MQ_RT_REF.cid = context
      MkRuntimeSetCID(NULL);
      goto error;
    }
    mqctx = (MQ_CTX) pObj2Hdl(env,"MqContextC",obj);
  }
 
  // copy setup data and initialize "setup" data
  if (create & (MQ_FACTORY_NEW_CHILD)) {
    MqSetupDup(mqctx, tmpl);
  }
 
  *contextP = mqctx;
  return MK_OK;
 
error:
  *contextP = NULL;
 
  MqContextDelete (mqctx);
  if((*env)->ExceptionCheck(env) == JNI_TRUE) {
    OT_ERROR_LNG_2_META(NULL);
  }
  return MkErrorStack_0E();
}
 
//
//    P R I V A T E
//
 
// BEGIN-MqFactoryC - created by 'jv_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Export,sc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)  {
  MkRtSetup_NULL;
  MQ_FCT __retVal__L = MqFactoryHandleResolve(netHdl);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// doc-key: MqFactoryC,MqFactoryC-Class-Export,om_
 
// skip class-overload: HandleGet = MqFactoryHandleGet → MkObjectHandleGet
 
// MqFactoryC_Class_JV_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Introspection,oc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_Next (JNIEnv *env, jobject self)  {
  MQ_FCT hdl = (MQ_FCT)pObj2Hdl(env,"MqFactoryC",self);
  JavaErrorCheck;
  MkRtSetup_NULL;
  MQ_FCT __retVal__L = MqFactoryNext(hdl);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_Prev (JNIEnv *env, jobject self)  {
  MQ_FCT hdl = (MQ_FCT)pObj2Hdl(env,"MqFactoryC",self);
  JavaErrorCheck;
  MkRtSetup_NULL;
  MQ_FCT __retVal__L = MqFactoryPrev(hdl);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqFactoryC,MqFactoryC-Class-Introspection,sc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_Instances (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MQ_FCT __retVal__L = MqFactoryInstances();
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MqFactoryC_Class_JV_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Class-Misc,sc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_GetNull (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MQ_FCT __retVal__L = MqFactoryGetNull();
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
}
 
// MqFactoryC_Class_JV_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Get,sc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_Get (JNIEnv *env, jclass class, jstring ident)  {
  MkRtSetup_NULL;
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  MQ_FCT __retVal__L = MqFactoryGet(ident_ptr);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_GetCalled__Ljava_lang_String_2 (JNIEnv *env, jclass class, jstring ident)  {
  MkRtSetup_NULL;
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  MQ_FCT __retVal__L = MqFactoryGetCalled(ident_ptr);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_GetCalled__Ljvmkkernel_MkBufferListC_2 (JNIEnv *env, jclass class, jobject largs)  {
  MkRtSetup_NULL;
  MK_BFLN largs_hdl = (MK_BFLN)pObj2Hdl(env,"MkBufferListC",largs);
  JavaErrorCheck;
  MQ_FCT __retVal__L = MqFactoryGetCalledL(largs_hdl);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqFactoryC,MqFactoryC-Get,om_
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqFactoryC_GetOriginalIdent (JNIEnv *env, jobject self)  {
  MQ_FCTN hdl = (MQ_FCTN)pObj2Hdl(env,"MqFactoryC",self);
  JavaErrorCheck;
  MkRtSetup_NULL;
  MK_STRN __retVal__L = MqFactoryGetOriginalIdent(hdl);
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// MqFactoryC_Get_JV_API
 
 
// doc-key: MqFactoryC,MqFactoryC-Misc,oc_
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_Default (JNIEnv *env, jobject self)  {
  MQ_FCT hdl = (MQ_FCT)pObj2Hdl(env,"MqFactoryC",self);
  JavaErrorCheck;
  MkRtSetup_NULL;
  MQ_FCT __retVal__L = MqFactoryDefault(hdl);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_Initial (JNIEnv *env, jobject self)  {
  MQ_FCT hdl = (MQ_FCT)pObj2Hdl(env,"MqFactoryC",self);
  JavaErrorCheck;
  MkRtSetup_NULL;
  MQ_FCT __retVal__L = MqFactoryInitial(hdl);
  jobject __retVal__S = MQ(MqFactoryC_ObjNew)(MK_RT_CALL env,__retVal__L);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqFactoryC,MqFactoryC-Misc,oco
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_New (JNIEnv *env, jobject self)  {
  MQ_FCT hdl = (MQ_FCT)pObj2Hdl(env,"MqFactoryC",self);
  JavaErrorCheck;
  MkRtSetup_NULL;
  MQ_CTX val_out;
  enum MkErrorE errVal = MqFactoryNew(hdl, NULL, &val_out);
  MkErrorC_Check(hdl, errVal)
  jobject __retVal__S = MQ(MqContextC_ObjNew)(MK_RT_CALL env,val_out);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqFactoryC,MqFactoryC-Misc,om_
 
// skip class-overload: Log = MqFactoryLog → MkObjectLog
 
// doc-key: MqFactoryC,MqFactoryC-Misc,sm_
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqFactoryC_DefaultIdent (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_STRN __retVal__L = MqFactoryDefaultIdent();
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
}
 
JNIEXPORT jstring JNICALL Java_jvmqmsgque_MqFactoryC_InitialIdent (JNIEnv *env, jclass class)  {
  MkRtSetup_NULL;
  MK_STRN __retVal__L = MqFactoryInitialIdent();
  jstring __retVal__S = JC2O(env,__retVal__L);
  return __retVal__S;
}
 
JNIEXPORT void JNICALL Java_jvmqmsgque_MqFactoryC_LogAll (JNIEnv *env, jclass class, jstring callfunc)  {
  MkRtSetup_NULL;
  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;
  MqFactoryLogAll(callfunc_ptr);
  if (callfunc_ptr) (*env)->ReleaseStringUTFChars(env,callfunc,callfunc_ptr);
error:
  return;
}
 
// MqFactoryC_Misc_JV_API
 
 
// doc-key: MqFactoryC,MqFactoryC-TOR,oCx
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_Dup2 (JNIEnv *env, jobject self, jstring ident)  {
  MQ_FCTN hdl = (MQ_FCTN)pObj2Hdl(env,"MqFactoryC",self);
  JavaErrorCheck;
  MkRtSetup_NULL;
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  MQ_FCT __retVal__L = MqFactoryDup2(hdl, ident_ptr);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MqFactoryC.Dup2");
    goto error;
  }
  jobject __retVal__S = MQ(MqFactoryC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// doc-key: MqFactoryC,MqFactoryC-TOR,sCc
 
JNIEXPORT jobject JNICALL Java_jvmqmsgque_MqFactoryC_Add (JNIEnv *env, jclass class, jclass constructor, jstring ident)  {
  MkRtSetup_NULL;
  if (ident == NULL) {ident = (*env)->CallObjectMethod(env,constructor,NS(MID_Class_getSimpleName));JavaErrorCheck;}
  MK_PTR constructor_c = NULL;
  jmethodID cbMeth = (*env)->GetMethodID(env,constructor,"<init>","(Ljvmqmsgque/MqContextC;)V");
  JavaErrorCheck;
  constructor_c = NS(sFactorySetup)(MK_RT_CALL env, constructor, cbMeth);
  JavaErrorCheck;
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  MQ_FCT __retVal__L = MqFactoryAdd(NULL, NS(sFactoryCTor), constructor_c, NS(sFactoryDataFree), NS(sFactoryDataCopy), NS(sFactoryDTor), NULL, NULL, NULL, ident_ptr);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MqFactoryC.Add");
    goto error;
  }
  jobject __retVal__S = MQ(MqFactoryC_ObjCreate)(MK_RT_CALL env,__retVal__L);
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
  return __retVal__S;
error:
  return 0;
}
 
JNIEXPORT jlong JNICALL Java_jvmqmsgque_MqFactoryC_CTOR (JNIEnv *env, jclass class, jclass constructor, jstring ident)  {
  MkRtSetup_NULL;
  if (ident == NULL) {ident = (*env)->CallObjectMethod(env,constructor,NS(MID_Class_getSimpleName));JavaErrorCheck;}
  MK_PTR constructor_c = NULL;
  jmethodID cbMeth = (*env)->GetMethodID(env,constructor,"<init>","(Ljvmqmsgque/MqContextC;)V");
  JavaErrorCheck;
  constructor_c = NS(sFactorySetup)(MK_RT_CALL env, constructor, cbMeth);
  JavaErrorCheck;
  MK_STRN ident_ptr = (ident?(*env)->GetStringUTFChars(env,ident,NULL):NULL);
  JavaErrorCheck;
  MQ_FCT __retVal__L = MqFactoryAdd(NULL, NS(sFactoryCTor), constructor_c, NS(sFactoryDataFree), NS(sFactoryDataCopy), NS(sFactoryDTor), NULL, NULL, NULL, ident_ptr);
  if (__retVal__L == NULL) {
    (*env)->ThrowNew(env, MK(Class_MkInitError), "MqFactoryC.CTOR");
    goto error;
  }
  jlong __retVal__S = (jlong)__retVal__L;
  if (ident_ptr) (*env)->ReleaseStringUTFChars(env,ident,ident_ptr);
  return __retVal__S;
error:
  return 0;
}
 
// MqFactoryC_TOR_JV_API
 
// END-MqFactoryC - created by 'jv_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
void NS(MqFactoryC_Init)(MQ_RT_ARGS_ONLY) {
  ClassInit
 
  MqFactoryC_TT->selfCreate    = NS(MqFactoryC_selfCreate);
  MqFactoryC_TT->selfUnlink    = MK(AtomSelfUnlink);
}