tag: nhi1-release-250425 More...

#include "jni_h/jvmqmsgque_MqContextC.h"
#include "LibMqMsgque_private_jv.h"

Include dependency graph for MqContextC_jv.c:

Macros
#define	META_FILE_NAME "MqContextC_jv.c"

#define	ClassInit \

Functions
jobject	jvmqmsgque_MqContextC_ObjNew (MK_RT mkrt, JNIEnv *env, MQ_CTX hdl)

static MK_UNUSED jobject	jvmqmsgque_MqContextC_ObjCreate (MK_RT mkrt, JNIEnv *env, MQ_CTX hdl)

static MK_PTR	jvmqmsgque_MqContextC_selfCreate (MK_RT mkrt, MK_OBJ obj, MK_PTR envP)

static int	sThreadExit (MK_RT mkrt, int exitnum)

static int	sProcessExit (MK_RT mkrt, int exitnum)

static bool	sWaitForPipe (MK_RT mkrt, MQ_CTX const ctx, const struct MkIdS *idP)

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_INIT (JNIEnv *env, jobject self)

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_HandleResolve (JNIEnv *env, jclass class, jint netHdl)
	`Java: [static] MqContextC MqContextC.HandleResolve(int netHdl)` → C-API Handle-Resolve-Slot - return a MqContextC from *netHdl* or null if invalid…

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_Next (JNIEnv *env, jobject self)
	`Java: MqContextC ctx.Next()` → C-API get next instance from linked-list of MqContextS type

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_Prev (JNIEnv *env, jobject self)
	`Java: MqContextC ctx.Prev()` → C-API get previous instance from linked-list of MqContextS type

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_Instances (JNIEnv *env, jclass class)
	`Java: [static] MqContextC MqContextC.Instances()` → C-API get head-instance from linked-list of MqContextS type …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_GetNull (JNIEnv *env, jclass class)
	`Java: [static] MqContextC MqContextC.GetNull()` → C-API Null-Slot - return a MqContextC typed `NULL` instance …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ClassFactoryGet (JNIEnv *env, jobject self)
	`Java: MqFactoryC ctx.ClassFactoryGet()` → C-API get the MqFactoryC used by the MqContextC

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ClassFactorySet (JNIEnv *env, jobject self, jobject item)
	`Java: ctx.ClassFactorySet(MqFactoryC item)` → C-API link the MqContextC to a new MqFactoryC

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ClassIdentGet (JNIEnv *env, jobject self)
	`Java: String ctx.ClassIdentGet()` → C-API get the application-identification …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ClassIdentSet (JNIEnv *env, jobject self, jstring ident)
	`Java: ctx.ClassIdentSet(String ident)` → C-API link the MqContextC to a new MqFactoryC identified by ident

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ClassOriginalIdentGet (JNIEnv *env, jobject self)
	`Java: String ctx.ClassOriginalIdentGet()` → C-API get the MqFactoryS::originalIdent from the MqContextC

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetIoTcpL (JNIEnv *env, jobject self)
	`Java: MkBufferListC ctx.ConfigGetIoTcpL()` → C-API get the configuration-data of the tcp-client-server-link as MkBufferListC …

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetBuffersize (JNIEnv *env, jobject self)
	`Java: int ctx.ConfigGetBuffersize()` → C-API get the minimum of the read/send buffersize of the socket

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetIdentFrom (JNIEnv *env, jobject self)
	`Java: MqIdentE ctx.ConfigGetIdentFrom()` → C-API get the MqConfigS::identFrom

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetIoPipe (JNIEnv *env, jobject self)
	`Java: int ctx.ConfigGetIoPipe()` → C-API return the MqIoPipeConfigS

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetIoUds (JNIEnv *env, jobject self)
	`Java: String ctx.ConfigGetIoUds()` → C-API return the MqIoUdsConfigS

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetIsParent (JNIEnv *env, jobject self)
	`Java: boolean ctx.ConfigGetIsParent()` → C-API does the context object is a parent ? An objext is a parent id the MqConfigS::parent attribute is null

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetIsServer (JNIEnv *env, jobject self)
	`Java: boolean ctx.ConfigGetIsServer()` → C-API does the context object is a server ?

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetIsString (JNIEnv *env, jobject self)
	`Java: boolean ctx.ConfigGetIsString()` → C-API does the context object is using the string-mode ?

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetName (JNIEnv *env, jobject self)
	`Java: String ctx.ConfigGetName()` → C-API get the name of the context object

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetPkgsize (JNIEnv *env, jobject self)
	`Java: int ctx.ConfigGetPkgsize()` → C-API get the maximun size of a BDY package

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetPostfix (JNIEnv *env, jobject self)
	`Java: String ctx.ConfigGetPostfix()` → C-API get the MqConfigS::dispPostfix

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetPrefix (JNIEnv *env, jobject self)
	`Java: String ctx.ConfigGetPrefix()` → C-API get the MqConfigS::dispPrefix

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetStartAs (JNIEnv *env, jobject self)
	`Java: MqStartE ctx.ConfigGetStartAs()` → C-API return the MqConfigS::startAs value

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetStatusIs (JNIEnv *env, jobject self)
	`Java: MqStatusIsEF ctx.ConfigGetStatusIs()` → C-API return the MqContextS::statusIs value

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetStorage (JNIEnv *env, jobject self)
	`Java: String ctx.ConfigGetStorage()` → C-API get the storage of the context object

JNIEXPORT jlong JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetTimeout (JNIEnv *env, jobject self)
	`Java: long ctx.ConfigGetTimeout()` → C-API get the timeout value of the context object

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetConfigFile (JNIEnv *env, jobject self, jstring filename)
	`Java: ctx.ConfigSetConfigFile(String filename)` → C-API set the config-file and parse for well-known config-items

JNIEXPORT jobjectArray JNICALL	Java_jvmqmsgque_MqContextC_ConfigGetIoTcp (JNIEnv *env, jobject self)
	`Java: {host:String port:String myhost:String myport:String} ctx.ConfigGetIoTcp()` → C-API get the configuration-data of the tcp-client-server-link …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigReset (JNIEnv *env, jobject self)
	`Java: ctx.ConfigReset()` → C-API clean the MqContextS::config data

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ConfigCheckStartAs (JNIEnv *env, jobject self, jobject data)
	`Java: boolean ctx.ConfigCheckStartAs(MqStartE data)` → C-API check if MqConfigS::startAs can be set to data

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetAllDebug (JNIEnv *env, jobject self, jint data)
	`Java: ctx.ConfigSetAllDebug(int data)` → C-API set the MkRuntimeS::debug value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetBuffersize (JNIEnv *env, jobject self, jint data)
	`Java: ctx.ConfigSetBuffersize(int data)` → C-API set the MqIoConfigS::buffersize value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetDaemon (JNIEnv *env, jobject self, jstring pidfile)
	`Java: ctx.ConfigSetDaemon(String pidfile)` → C-API start the server-context as daemon …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetIdentFrom (JNIEnv *env, jobject self, jobject data)
	`Java: ctx.ConfigSetIdentFrom(MqIdentE data)` → C-API set the MqConfigS::identFrom value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetIgnoreExit (JNIEnv *env, jobject self, jboolean data)
	`Java: ctx.ConfigSetIgnoreExit(boolean data)` → C-API set the MqSetupS::ignoreExit value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetIoPipe (JNIEnv *env, jobject self, jint fh)
	`Java: ctx.ConfigSetIoPipe(int fh)` → C-API set the pipe configuration data …

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)
	`Java: ctx.ConfigSetIoTcp(?String host = null?, ?String port = null?, ?String myhost = null?, ?String myport = null?)` → C-API configure a context to use a tcp-client-server-link …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetIoTcp__Ljvmkkernel_MkBufferListC_2 (JNIEnv *env, jobject self, jobject vals)
	`Java: ctx.ConfigSetIoTcp(MkBufferListC vals)` → C-API configure a context to use a tcp-client-server-link …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetIoUds (JNIEnv *env, jobject self, jstring file)
	`Java: ctx.ConfigSetIoUds(String file)` → C-API configure a context to use a uds-client-server-link …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetIsServer (JNIEnv *env, jobject self, jboolean data)
	`Java: ctx.ConfigSetIsServer(boolean data)` → C-API set the MqSetupS::isServer value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetIsString (JNIEnv *env, jobject self, jboolean data)
	`Java: ctx.ConfigSetIsString(boolean data)` → C-API set the MqConfigS::native value 'S'string or 'L'owEndian or 'B'igEndian

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetName (JNIEnv *env, jobject self, jstring data)
	`Java: ctx.ConfigSetName(String data)` → C-API set the MqConfigS::dispName value and cleanup old value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetPkgsize (JNIEnv *env, jobject self, jint data)
	`Java: ctx.ConfigSetPkgsize(int data)` → C-API set the MqIoConfigS::pkgsize value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetPostfix (JNIEnv *env, jobject self, jstring data)
	`Java: ctx.ConfigSetPostfix(String data)` → C-API set the client-part (2) of the application-identifer MqConfigS::dispName …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetPrefix (JNIEnv *env, jobject self, jstring data)
	`Java: ctx.ConfigSetPrefix(String data)` → C-API set the server-part (1) of the application-identifer MqConfigS::dispName …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetStartAs (JNIEnv *env, jobject self, jobject data)
	`Java: ctx.ConfigSetStartAs(MqStartE data)` → C-API set the MqConfigS::startAs value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetStartAsString (JNIEnv *env, jobject self, jstring data)
	`Java: ctx.ConfigSetStartAsString(String data)` → C-API set the MqConfigS::startAs value using string `default`, `thread`, `fork` or `spawn`

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetStorage (JNIEnv *env, jobject self, jstring data)
	`Java: ctx.ConfigSetStorage(String data)` → C-API set the Storage value and cleanup old value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ConfigSetTimeout (JNIEnv *env, jobject self, jlong data)
	`Java: ctx.ConfigSetTimeout(long data)` → C-API set the MqIoConfigS::timeout value

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_EnvProtect (JNIEnv *env, jobject self)
	`Java: ctx.EnvProtect()` → C-API protect the service-environment

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_EnvRestore (JNIEnv *env, jobject self)
	`Java: ctx.EnvRestore()` → C-API restore the service-environment

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ErrorFORMAT (JNIEnv *env, jobject self)
	`Java: MkErrorC fmtobj.ErrorFORMAT()` → C-API helper used to access MkErrorDEFAULT from MqContextC

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ErrorCopy (JNIEnv *env, jobject self, jobject sourceCtx)
	`Java: MkErrorE targetCtx.ErrorCopy(MqContextC sourceCtx)` → C-API copy a MkErrorS from the sourceCtx to the targetCtx …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ErrorMove (JNIEnv *env, jobject self, jobject sourceCtx)
	`Java: MkErrorE targetCtx.ErrorMove(MqContextC sourceCtx)` → C-API move a MkErrorS from the sourceCtx to the targetCtx …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_LinkGetParent (JNIEnv *env, jobject self)
	`Java: MqContextC ctx.LinkGetParent()` → C-API get the initial parent-context from a client/server link …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LinkConnect (JNIEnv *env, jobject self)
	`Java: ctx.LinkConnect()` → C-API re-connect a client-server-link after a server crash or a network downtime …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LinkCreate (JNIEnv *env, jobject self, jobject args)
	`Java: ctx.LinkCreate(?MkBufferListC args = null?)` → C-API make ctx to a parent-context and setup a new client-server-link …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LinkCreateChild (JNIEnv *env, jobject self, jobject parent, jobject args)
	`Java: ctx.LinkCreateChild(MqContextC parent, ?MkBufferListC args = null?)` → C-API make a context to a child-context on-top of an existing parent-client-server-link …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LinkDelete (JNIEnv *env, jobject self)
	`Java: ctx.LinkDelete()` → C-API close the client-server-link …

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_LinkGetCtxId (JNIEnv *env, jobject self)
	`Java: int ctx.LinkGetCtxId()` → C-API get an identifier which is unique per parent-or-child-context …

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_LinkGetTargetIdent (JNIEnv *env, jobject self)
	`Java: String ctx.LinkGetTargetIdent()` → C-API get the ident of the link-target …

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_LinkIsConnected (JNIEnv *env, jobject self)
	`Java: boolean ctx.LinkIsConnected()` → C-API is the context connected? …

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_LinkIsParent (JNIEnv *env, jobject self)
	`Java: boolean ctx.LinkIsParent()` → C-API is the context a parent-context? …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LinkShutdown (JNIEnv *env, jobject self)
	`Java: ctx.LinkShutdown()` → C-API shutdown the communication with a server

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LogConfig (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)
	`Java: ctx.LogConfig(?MkObjectC fmtobj = null?, ?int debug = 0?, ?String callfunc = null?, ?int lvl = 0?)` → C-API log the MqContextC part MqConfigS …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LogEnv (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)
	`Java: ctx.LogEnv(?MkObjectC fmtobj = null?, ?int debug = 0?, ?String callfunc = null?, ?int lvl = 0?)` → C-API log the MqContextC part MqEnvS …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LogLink (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)
	`Java: ctx.LogLink(?MkObjectC fmtobj = null?, ?int debug = 0?, ?String callfunc = null?, ?int lvl = 0?)` → C-API log the MqContextC part MqLinkS …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LogSetup (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)
	`Java: ctx.LogSetup(?MkObjectC fmtobj = null?, ?int debug = 0?, ?String callfunc = null?, ?int lvl = 0?)` → C-API log the MqContextC part MqSetupS …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LogShort (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl, jstring label)
	`Java: ctx.LogShort(?MkObjectC fmtobj = null?, ?int debug = 0?, ?String callfunc = null?, ?int lvl = 0?, ?String label = null?)` → C-API log the MqContextC with less info then MqContextLog …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_LogType (JNIEnv *env, jobject self, jobject fmtobj, jint debug, jstring callfunc, jint lvl)
	`Java: ctx.LogType(?MkObjectC fmtobj = null?, ?int debug = 0?, ?String callfunc = null?, ?int lvl = 0?)` → C-API log the MqContextC part MkTypeS …

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_LogParentOrChild (JNIEnv *env, jobject self)
	`Java: String ctx.LogParentOrChild()` → C-API is ctx a PARENT or a CHILD ? …

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_LogServerOrClient (JNIEnv *env, jobject self)
	`Java: String ctx.LogServerOrClient()` → C-API is ctx a SERVER or a CLIENT ? …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_GetBuffer (JNIEnv *env, jobject self)
	`Java: MkBufferC ctx.GetBuffer()` → C-API get the MqContextS::ctxbuf object

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_GetRoot (JNIEnv *env, jobject self)
	`Java: MqContextC ctx.GetRoot()` → C-API get the Root (toplevel initial context)

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_Exit (JNIEnv *env, jobject self, jstring callfunc, jstring callfile, jint callline)
	`Java: int ctx.Exit(?String callfunc = null?, ?String callfile = null?, ?int callline = -1?)` → C-API delete the context and exit the current process or thread …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ProcessEvent (JNIEnv *env, jobject self, jobject wait, jlong timeout)
	`Java: ctx.ProcessEvent(?MqWaitOnEventE wait = MQ_WAIT_NO?, ?long timeout = MkTimeoutE.DEFAULT.get()?)` → C-API enter the event-loop and wait for an incoming service-request. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ProxyForward (JNIEnv *env, jobject self, jobject targetCtx, jobject dump, jlong timeout)
	`Java: sourceCtx.ProxyForward(MqContextC targetCtx, ?MqDumpC dump = null?, ?long timeout = MkTimeoutE.DEFAULT.get()?)` → C-API send the entire read-data-package-data to the link-target …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ProxyItem (JNIEnv *env, jobject self, jobject targetCtx)
	`Java: sourceCtx.ProxyItem(MqContextC targetCtx)` → C-API Copy a single-data-item from the sourceCtx to the targetCtx.

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ReadALL (JNIEnv *env, jobject self, jobject val_inout)
	`Java: MkBufferListC ctx.ReadALL(?MkBufferListC val_inout = null?)` → C-API get a temporary MkBufferListC from all data in the read-data-package …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ReadBFL (JNIEnv *env, jobject self)
	`Java: MkBufferListC ctx.ReadBFL()` → C-API get a temporary MkBufferListC from next list-item in the read-data-package …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ReadBUF (JNIEnv *env, jobject self)
	`Java: MkBufferC ctx.ReadBUF()` → C-API get a temporary MkBufferC from the read-data-package …

JNIEXPORT jbyteArray JNICALL	Java_jvmqmsgque_MqContextC_ReadBIN (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadBIN` → C-API generic function to read an MK_BIN object from the read-data-package object …

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ReadBOL (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadBOL` → C-API read a PRIMITIVE TYPE from the read-data-package …

JNIEXPORT jbyteArray JNICALL	Java_jvmqmsgque_MqContextC_ReadBinaryR (JNIEnv *env, jobject self)
	`Java: byte[] ctx.ReadBinaryR()` → C-API read a MkBinaryR from the read-data-package …

JNIEXPORT jdouble JNICALL	Java_jvmqmsgque_MqContextC_ReadDBL (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadDBL` → C-API read a PRIMITIVE TYPE from the read-data-package …

JNIEXPORT jfloat JNICALL	Java_jvmqmsgque_MqContextC_ReadFLT (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadFLT` → C-API read a PRIMITIVE TYPE from the read-data-package …

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_ReadHDL (JNIEnv *env, jobject self)
	`Java: int ctx.ReadHDL()` → C-API read the handle from the read-data-package

JNIEXPORT jshort JNICALL	Java_jvmqmsgque_MqContextC_ReadI16 (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadI16` → C-API read a PRIMITIVE TYPE from the read-data-package …

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_ReadI32 (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadI32` → C-API read a PRIMITIVE TYPE from the read-data-package …

JNIEXPORT jlong JNICALL	Java_jvmqmsgque_MqContextC_ReadI64 (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadI64` → C-API read a PRIMITIVE TYPE from the read-data-package …

JNIEXPORT jbyte JNICALL	Java_jvmqmsgque_MqContextC_ReadI8 (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadI8` → C-API read a PRIMITIVE TYPE from the read-data-package …

JNIEXPORT MK_NAT_LIST JNICALL	ReadLIST (JNIEnv *env, jobject self)
	`Java: List<Object> ctx.ReadLIST()` → C-API get all arguments as native list …

JNIEXPORT jlong JNICALL	Java_jvmqmsgque_MqContextC_ReadLONG (JNIEnv *env, jobject self)
	`Java: long ctx.ReadLONG()` → C-API read the long native object from the read-data-package

JNIEXPORT MK_NAT_OBJECT JNICALL	ReadNEXT (JNIEnv *env, jobject self)
	`Java: Object ctx.ReadNEXT()` → C-API get the next argument as native object …

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ReadSTR (JNIEnv *env, jobject self)
	`Java: doc_mq_jv_ReadSTR` → C-API read a PRIMITIVE TYPE from the read-data-package …

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ReadStringR (JNIEnv *env, jobject self)
	`Java: String ctx.ReadStringR()` → C-API read a MkStringR from the read-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ReadL_1END (JNIEnv *env, jobject self)
	`Java: ctx.ReadL_END()` → C-API finish to extract a list-items from the read-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ReadL_1START (JNIEnv *env, jobject self, jobject buf)
	`Java: ctx.ReadL_START(?MkBufferC buf = null?)` → C-API start to extract a list-items from the read-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ReadT_1END (JNIEnv *env, jobject self)
	`Java: ctx.ReadT_END()` → C-API finish to extract a longterm-transaction-item from the read-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ReadT_1START (JNIEnv *env, jobject self)
	`Java: ctx.ReadT_START()` → C-API start to extract a longterm-transaction-item from the read-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ReadDbg (JNIEnv *env, jobject self)
	ReadDbg

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_ReadGetNextType (JNIEnv *env, jobject self)
	`Java: MkTypeE ctx.ReadGetNextType()` → C-API get the type (MkTypeE) of the next Item in the read-data-buffer or "0" if not available

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_ReadGetNumItems (JNIEnv *env, jobject self)
	`Java: int ctx.ReadGetNumItems()` → C-API get the number of items left in the read-data-package …

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ReadItemExists (JNIEnv *env, jobject self)
	`Java: boolean ctx.ReadItemExists()` → C-API check if an item exists in the read-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ReadUndo (JNIEnv *env, jobject self)
	`Java: ctx.ReadUndo()` → C-API undo the last MqContextC READ API function call …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_RouteGetTree (JNIEnv *env, jobject self)
	`Java: MkBufferListC ctx.RouteGetTree()` → C-API create an overview about all available routing-target and services …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_RouteCreate (JNIEnv *env, jobject self, jstring route, jstring service, jboolean overwrite)
	`Java: ctx.RouteCreate(String route, String service, ?boolean overwrite = false?)` → C-API create/delete a routing-link between context an a service using route

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_RouteDelete (JNIEnv *env, jobject self, jstring route, jstring service, jboolean overwrite)
	`Java: ctx.RouteDelete(String route, String service, ?boolean overwrite = false?)` → C-API delete a routing-link created with MqRouteCreate

JNIEXPORT jobjectArray JNICALL	Java_jvmqmsgque_MqContextC_RouteResolve (JNIEnv *env, jobject self, jstring ident, jint retnum)
	`Java: MqContextC[] ctx.RouteResolve(String ident, ?int retnum = -1?)` → C-API return a list of all context belonging to ident …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_RouteTraverse (JNIEnv *env, jobject self, jstring service, jobject args)
	`Java: ctx.RouteTraverse(String service, ?MkBufferListC args = null?)` → C-API traverse a tree down and call service if available.

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_RouteGetPath (JNIEnv *env, jobject self)
	`Java: String ctx.RouteGetPath()` → C-API return the absolut route-connection-string up to the current ctx …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendBFL (JNIEnv *env, jobject self, jobject val)
	`Java: ctx.SendBFL(MkBufferListC val)` → C-API append a MkBufferListC object to the send-data-package object …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendBIN (JNIEnv *env, jobject self, jbyteArray val)
	`Java: doc_mq_jv_SendBIN` → C-API append a MK_BIN object to the send-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendBOL (JNIEnv *env, jobject self, jboolean val)
	`Java: doc_mq_jv_SendBOL` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendBUF (JNIEnv *env, jobject self, jobject val)
	`Java: ctx.SendBUF(MkBufferC val)` → C-API append a MkBufferC object to the send-data-package object …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendBUS_1FLAT (JNIEnv *env, jobject self, jobject val)
	`Java: ctx.SendBUS_FLAT(MkBufferStreamC val)` → C-API append a MkBufferStreamC object to the send-data-package object …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendBinaryR (JNIEnv *env, jobject self, jbyteArray val)
	`Java: ctx.SendBinaryR(byte[] val)` → C-API append a MkBinaryR object to the send-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendDBL (JNIEnv *env, jobject self, jdouble val)
	`Java: doc_mq_jv_SendDBL` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendFLT (JNIEnv *env, jobject self, jfloat val)
	`Java: doc_mq_jv_SendFLT` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendHDL (JNIEnv *env, jobject self, jint val)
	`Java: ctx.SendHDL(int val)` → C-API send the handle to the send-data-package

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendI16 (JNIEnv *env, jobject self, jshort val)
	`Java: doc_mq_jv_SendI16` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendI32 (JNIEnv *env, jobject self, jint val)
	`Java: doc_mq_jv_SendI32` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendI64 (JNIEnv *env, jobject self, jlong val)
	`Java: doc_mq_jv_SendI64` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendI8 (JNIEnv *env, jobject self, jbyte val)
	`Java: doc_mq_jv_SendI8` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendLONG (JNIEnv *env, jobject self, jlong val)
	`Java: ctx.SendLONG(long val)` → C-API send the long native object to the send-data-package

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendLTR (JNIEnv *env, jobject self, jint transLId)
	SendLTR

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendL_1FLAT (JNIEnv *env, jobject self, jobject val)
	`Java: ctx.SendL_FLAT(MkBufferListC val)` → C-API append a MkBufferListC object as flat list of items to the send-data-package object …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendSTR (JNIEnv *env, jobject self, jstring val)
	`Java: doc_mq_jv_SendSTR` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendStringR (JNIEnv *env, jobject self, jstring val)
	`Java: ctx.SendStringR(String val)` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendEND (JNIEnv *env, jobject self, jstring token, jlong timeout)
	`Java: ctx.SendEND(String token, ?long timeout = MkTimeoutE.DEFAULT.get()?)` → C-API MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendEND_1AND_1CALLBACK (JNIEnv *env, jobject self, jstring token, jobject callback, jlong timeout)
	`Java: ctx.SendEND_AND_CALLBACK(String token, MqServiceIF callback, ?long timeout = MkTimeoutE.DEFAULT.get()?)` → C-API finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendEND_1AND_1SUB (JNIEnv *env, jobject self, jstring token, jobject callback, jlong timeout)
	`Java: ctx.SendEND_AND_SUB(String token, MqServiceIF callback, ?long timeout = MkTimeoutE.DEFAULT.get()?)` → C-API finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendEND_1AND_1TRANSACTION (JNIEnv *env, jobject self, jstring token, jstring callback, jlong timeout)
	`Java: ctx.SendEND_AND_TRANSACTION(String token, String callback, ?long timeout = MkTimeoutE.DEFAULT.get()?)` → C-API finish the send-data-block, call the remote service to do a longterm-transaction-call …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendEND_1AND_1WAIT (JNIEnv *env, jobject self, jstring token, jlong timeout)
	`Java: ctx.SendEND_AND_WAIT(String token, ?long timeout = MkTimeoutE.DEFAULT.get()?)` → C-API finish the send-data-block, call the remote service and wait for result…

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendSTART (JNIEnv *env, jobject self)
	`Java: ctx.SendSTART()` → C-API initialize the send-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendSYNC (JNIEnv *env, jobject self)
	`Java: ctx.SendSYNC()` → C-API garantee that all pending asynchronous-service-calls are processed. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendL_1END (JNIEnv *env, jobject self)
	`Java: ctx.SendL_END()` → C-API finish to append an embedded body-list-item to the send-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendL_1START (JNIEnv *env, jobject self)
	`Java: ctx.SendL_START()` → C-API start to append an embedded body-list-item to the send-data-package. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendT_1END (JNIEnv *env, jobject self)
	`Java: ctx.SendT_END()` → C-API closed a longterm-transaction-item …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendT_1START (JNIEnv *env, jobject self)
	`Java: ctx.SendT_START()` → C-API open a longterm-transaction-item …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendERROR (JNIEnv *env, jobject self)
	`Java: ctx.SendERROR()` → C-API send the data from the MkErrorC to the link target . …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendRETURN (JNIEnv *env, jobject self)
	`Java: ctx.SendRETURN()` → C-API MqContextC - finish the send-data-block on the server and optional return the results. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SendRETURN_1SUB (JNIEnv *env, jobject self)
	`Java: ctx.SendRETURN_SUB()` → C-API return Sub-Data-Blocks required by MqSendEND_AND_SUB …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ServiceCreate (JNIEnv *env, jobject self, jstring token, jobject callback)
	`Java: ctx.ServiceCreate(String token, MqServiceIF callback)` → C-API create a link between a service-token and a service-callback …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ServiceDelete (JNIEnv *env, jobject self, jstring token)
	`Java: ctx.ServiceDelete(String token)` → C-API delete a service. …

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ServiceIsTransaction (JNIEnv *env, jobject self)
	`Java: boolean ctx.ServiceIsTransaction()` → C-API check if the ongoing-service-call belongs to a transaction …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ServiceProxy (JNIEnv *env, jobject self, jstring token, jint id)
	`Java: ctx.ServiceProxy(String token, ?int id = MqSlaveE.OTHER.get()?)` → C-API create a service to link a master-context with a slave-context. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ServiceProxyCtx (JNIEnv *env, jobject self, jstring token, jobject target)
	`Java: ctx.ServiceProxyCtx(String token, MqContextC target)` → C-API same as MqServiceProxy but use an MqContextC as input.

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ServiceProxyCtxExists (JNIEnv *env, jobject self, jstring token, jobject target)
	`Java: boolean ctx.ServiceProxyCtxExists(String token, MqContextC target)` → C-API check if service who belongs to token is a proxy-service

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ServiceProxyRoundRobin (JNIEnv *env, jobject self, jstring token, jstring ident)
	`Java: ctx.ServiceProxyRoundRobin(String token, String ident)` → C-API create a proxy-service using Round-Robin as load-balancer …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_ServiceStorage (JNIEnv *env, jobject self, jstring token)
	`Java: ctx.ServiceStorage(String token)` → C-API setup a service listen on a MqContextC_ServiceApi_Identifer and save all read-data-package into the STORAGE …

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ServiceTokenCheck (JNIEnv *env, jobject self, jstring token)
	`Java: boolean ctx.ServiceTokenCheck(String token)` → C-API in an ongoing-service-call check if the current MqContextC_ServiceApi_Identifer is *token* …

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_ServiceTokenExists (JNIEnv *env, jobject self, jstring token)
	`Java: boolean ctx.ServiceTokenExists(String token)` → C-API check if the MqContextC_ServiceApi_Identifer *token* is defined as *ctx* service …

JNIEXPORT jstring JNICALL	Java_jvmqmsgque_MqContextC_ServiceTokenGet (JNIEnv *env, jobject self)
	`Java: String ctx.ServiceTokenGet()` → C-API in an ongoing-service-call get the current MqContextC_ServiceApi_Identifer …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_SlaveGetMaster (JNIEnv *env, jobject self)
	`Java: MqContextC ctx.SlaveGetMaster()` → C-API opposite function of MqSlaveGetFilter

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_SlaveGet (JNIEnv *env, jobject self, jint id)
	`Java: MqContextC ctx.SlaveGet(int id)` → C-API get the slave-context from a master-context …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_SlaveGetFilter (JNIEnv *env, jobject self)
	`Java: MqContextC ctx.SlaveGetFilter()` → C-API get the filter-ctx or the master-ctx …

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_SlaveGetProxy (JNIEnv *env, jobject self, jint id)
	`Java: MqContextC ctx.SlaveGetProxy(int id)` → C-API on slave return the master and on master return the slave identified by id.

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_SlaveCheck (JNIEnv *env, jobject self, jint id)
	`Java: boolean ctx.SlaveCheck(int id)` → C-API check if slave-id is valid

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SlaveCreate (JNIEnv *env, jobject self, jint id, jobject slave)
	`Java: ctx.SlaveCreate(int id, MqContextC slave)` → C-API create a master/slave link between the master-parent-context and the slave-parent-context …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SlaveDelete (JNIEnv *env, jobject self, jint id)
	`Java: ctx.SlaveDelete(int id)` → C-API Delete a slave object from a master/slave link identified by id. …

JNIEXPORT jboolean JNICALL	Java_jvmqmsgque_MqContextC_SlaveIs (JNIEnv *env, jobject self)
	`Java: boolean ctx.SlaveIs()` → C-API is the context a slave-context ? …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_SlaveWorker (JNIEnv *env, jobject self, jint id, jstring fct, jobject args)
	`Java: ctx.SlaveWorker(int id, ?String fct = "WORKER"?, ?MkBufferListC args = null?)` → C-API create a master/slave link using the image of the ctx object self. …

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_StorageDelete (JNIEnv *env, jobject self, jint transLIdP_inout)
	`Java: int ctx.StorageDelete(?int transLIdP_inout = 0?)` → C-API delete the storage-row identified by the *transLIdP_inout* …

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_StorageImport (JNIEnv *env, jobject self, jint transLIdP_inout)
	`Java: int ctx.StorageImport(?int transLIdP_inout = 0?)` → C-API import the storage-package into the read-data-package …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_StorageClose (JNIEnv *env, jobject self)
	`Java: ctx.StorageClose()` → C-API close the storage. …

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_StorageDecrRef (JNIEnv *env, jobject self, jint transLId)
	`Java: ctx.StorageDecrRef(int transLId)` → C-API decrease the internal refCount lock of the database-entry

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_StorageIncrRef (JNIEnv *env, jobject self, jint transLId)
	`Java: ctx.StorageIncrRef(int transLId)` → C-API increase the internal refCount lock of the database-entry

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_StorageLog (JNIEnv *env, jobject self, jstring callfunc)
	`Java: ctx.StorageLog(?String callfunc = null?)` → C-API log the storage the status of the open transactions

JNIEXPORT void JNICALL	Java_jvmqmsgque_MqContextC_StorageOpen (JNIEnv *env, jobject self, jstring storageFile)
	`Java: ctx.StorageOpen(String storageFile)` → C-API switch to a file-based-transaction-database …

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_StorageCount (JNIEnv *env, jobject self)
	`Java: int ctx.StorageCount()` → C-API count the number of storage-rows …

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_StorageErrCnt (JNIEnv *env, jobject self, jint transLId)
	`Java: int ctx.StorageErrCnt(int transLId)` → C-API increment and return the database row-error-count for the row defined with transLId

JNIEXPORT jint JNICALL	Java_jvmqmsgque_MqContextC_StorageExport (JNIEnv *env, jobject self)
	`Java: int ctx.StorageExport()` → C-API export the read-data-package into the STORAGE …

JNIEXPORT jobjectArray JNICALL	Java_jvmqmsgque_MqContextC_StorageResolve (JNIEnv *env, jobject self)
	`Java: {otherCtxP:MqContextC otherLIdP:int} ctx.StorageResolve()` → C-API extract the `context->link.protect.rmtTransLId` entry from the database

JNIEXPORT jlong JNICALL	Java_jvmqmsgque_MqContextC_CTOR (JNIEnv *env, jclass class, jobject tmpl)
	`Java: [constructor,static] MqContextC MqContextC.Create(?MqContextC tmpl = null?)` → C-API create and initialize the MqContextC ...

JNIEXPORT jobject JNICALL	Java_jvmqmsgque_MqContextC_Create (JNIEnv *env, jclass class, jobject tmpl)
	`Java: [constructor,static] MqContextC MqContextC.Create(?MqContextC tmpl = null?)` → C-API create and initialize the MqContextC ...

void	jvmqmsgque_MqContextC_Init (MK_RT mkrt, MQ_RT mqrt)

Variables
static MK_TYP	MqContextCTT = NULL

Detailed Description

tag: nhi1-release-250425

Copyright: (C) NHI - #1 - Project - Group This software has NO permission to copy, please contact AUTHOR for additional information

Definition in file MqContextC_jv.c.

Macro Definition Documentation

◆ ClassInit

#define ClassInit \

Definition at line 31 of file MqContextC_jv.c.

31#define ClassInit \

32

◆ META_FILE_NAME

#define META_FILE_NAME "MqContextC_jv.c"

Definition at line 10 of file MqContextC_jv.c.

Function Documentation

◆ Java_jvmqmsgque_MqContextC_INIT()

JNIEXPORT void JNICALL Java_jvmqmsgque_MqContextC_INIT	(	JNIEnv *	env,
		jobject	self )

Definition at line 81 of file MqContextC_jv.c.

{
  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;
}

◆ jvmqmsgque_MqContextC_Init()

void jvmqmsgque_MqContextC_Init	(	MK_RT	mkrt,
		MQ_RT	mqrt )

Definition at line 2709 of file MqContextC_jv.c.

                                          {
  ClassInit
 
  // define type
  MqContextCTT = MkTypeDup2(MqContextC_TT,"JvMqContextC");
  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 ;
}

◆ jvmqmsgque_MqContextC_ObjCreate()

static MK_UNUSED jobject jvmqmsgque_MqContextC_ObjCreate	(	MK_RT	mkrt,
		JNIEnv *	env,
		MQ_CTX	hdl )

static

Definition at line 22 of file MqContextC_jv.c.

                                                                             {
  return MK(AtomObjCreate)(MK_RT_CALL env, MqContextC_X2obj(hdl));
}

◆ jvmqmsgque_MqContextC_ObjNew()

jobject jvmqmsgque_MqContextC_ObjNew	(	MK_RT	mkrt,
		JNIEnv *	env,
		MQ_CTX	hdl )

Definition at line 16 of file MqContextC_jv.c.

                                                                   {
  static MkThreadLocal jobject NS_NULL = NULL;
  return (hdl ? MK(AtomObjNew)(MK_RT_CALL env, MqContextC_X2obj(hdl)) : MK_GET__NS_NULL(MqContextC));
}

◆ jvmqmsgque_MqContextC_selfCreate()

static MK_PTR jvmqmsgque_MqContextC_selfCreate	(	MK_RT	mkrt,
		MK_OBJ	obj,
		MK_PTR	envP )

static

Definition at line 26 of file MqContextC_jv.c.

                                                                             {
  JNIEnv *env = (JNIEnv*) envP;
  return (*env)->NewObject(env, NS(Class_MqContextC), NS(MID_MqContextC_INIT), (jlong) obj, JNI_TRUE);
}

◆ sProcessExit()

static int sProcessExit	(	MK_RT	mkrt,
		int	exitnum )

static

Definition at line 48 of file MqContextC_jv.c.

{
  SETUP_env;
  (*env)->CallStaticVoidMethod(env, NS(Class_System), NS(MID_System_exit), (jint) exitnum);
error:
  return exitnum;
}

Here is the caller graph for this function:

◆ sThreadExit()

static int sThreadExit	(	MK_RT	mkrt,
		int	exitnum )

static

Definition at line 40 of file MqContextC_jv.c.

{
#ifndef META_THREAD_POOL
  (*MK(cached_jvm))->DetachCurrentThread(MK(cached_jvm));
#endif // META_THREAD_POOL
  return exitnum;
}

Here is the caller graph for this function:

◆ sWaitForPipe()

static bool sWaitForPipe	(	MK_RT	mkrt,
		MQ_CTX const	ctx,
		const struct MkIdS *	idP )

static

Definition at line 56 of file MqContextC_jv.c.

                                                                                 {
  bool retB = false;
  switch ((*idP).type) {  
    case MK_ID_THREAD: {
      if ((*idP).setByExtern) {
        JNIEnv *env = GET_env_X(ctx); 
          if (env == NULL) MK(GetJniEnv)(MK_RT_CALL &env);
        if (env)  {
          jobject futureO = (jobject) (*idP).val ;
          if (!(*env)->IsSameObject(env,futureO, NULL)) {
            (*env)->CallVoidMethod(env, futureO, MQ(MID_Thread_wait));
            retB = true;
          }
          (*env)->DeleteWeakGlobalRef(env,futureO); 
        }
      }
      break;
    }
    case MK_ID_PROCESS:
    case MK_ID_UNUSED: break;
  }
  return retB;
}

Here is the caller graph for this function:

Variable Documentation

◆ MqContextCTT

MK_TYP MqContextCTT = NULL

static

Definition at line 37 of file MqContextC_jv.c.

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ ClassInit

◆ META_FILE_NAME

Function Documentation

◆ Java_jvmqmsgque_MqContextC_INIT()

◆ jvmqmsgque_MqContextC_Init()

◆ jvmqmsgque_MqContextC_ObjCreate()

◆ jvmqmsgque_MqContextC_ObjNew()

◆ jvmqmsgque_MqContextC_selfCreate()

◆ sProcessExit()

◆ sThreadExit()

◆ sWaitForPipe()

Variable Documentation

◆ MqContextCTT