MqContextC_py.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME              "MqContextC_py.c"
 
#include "LibMqMsgque_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(MqContextCR))
#define OT_CLASS_NAME               "MqContextC"
 
#define OT_LNG2META(O)              MqCtx(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(MqContextC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MqContextC)
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(MqContextC)
#define OT_SETUP_hdl_constr         MK_RT_UNUSED AllRtSetup_NULL; \
                                    MQ_CTX hdl = (MQ_CTX) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MqContextC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MqContextC##_TT;
 
#define OT_SETUP_hdl_static_constr  OT_SETUP_hdl_static
 
#if !defined(SetupRtFromObj_X)
  #define SetupRtFromObj_X(hdl)     AllRtSetup_X(hdl)
  #define SetupRtFromObj_XN(hdl)    AllRtSetup_XN(hdl)
#endif
 
// MO class
#undef MqContextCTT
#define MqContextCTT MQ(MqMsgqueThreadState).MqContextCTT
/* MqContextC_MK_NULL defined in LibMqMsgque_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(MqContextC_CTOR) (MK_RT_ARGS OT_CLS_T type, MQ_CTX hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,MqContextC_X2obj(hdl));
}
 
// helper: mk_dbg_color_ln(MK_COLOR_YELLOW,"hdl<%p>, self<%p>", obj, self);
 
// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MqContextC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
  return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
}
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(MqContextC_selfDelete) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
}
// META: called to destroy link from SELF to META
static void NS(MqContextC_selfUnlink) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
  selfO->hdl = NULL;
}
 
// initialize the PY and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META type */ \
  if (MqContextCTT == NULL) MqContextCTT = MqContextSTT; \
  \
  /* protect against double call */ \
  if (MqContextCTT->selfCreate == NS(MqContextC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MqContextCTT->selfCreate    = NS(MqContextC_selfCreate); \
  MqContextCTT->selfDelete    = NS(MqContextC_selfDelete); \
  MqContextCTT->selfUnlink    = NS(MqContextC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MqContextCR).tp_base = MqContextC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MqContextC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MqContextC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
 
/* LABEL-END */
 
#if 0
// initialize the PY and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW MQ type */ \
  if (MqContextCTT == NULL) MqContextCTT = MqContextSTT; \
  \
  /* protect against double call */ \
  if (MqContextCTT->selfCreate == NS(MqContextC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the MQ-Class */ \
  MqContextCTT->selfCreate    = NS(MqContextC_selfCreate); \
  MqContextCTT->selfDelete    = NS(MqContextC_selfDelete); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
M0; \
    NS(MqContextCR).tp_base = OT_MqContextC_base; \
printZ(Py_REFCNT(OT_CLASS)); \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
printP(PyThreadState_Get()); \
printZ(Py_REFCNT(OT_CLASS)); \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MqContextC", (PyObject *)OT_CLASS)); \
printZ(Py_REFCNT(OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  NS(MqMsgqueThreadState).MqContextC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/, false));
#endif
 
#define META_CONTEXT_S              hdl
 
 
// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// doc-key: MqContextC,MqClass,oc_,func
#define ClassFactoryGet_doc "MqFactoryC ctx.ClassFactoryGet() (const)"
 
// doc-key: MqContextC,MqClass,om_,func
#define ClassFactorySet_doc "ctx.ClassFactorySet(item:MqFactoryC)"
#define ClassIdentGet_doc "string ctx.ClassIdentGet() (const)"
#define ClassIdentSet_doc "ctx.ClassIdentSet(ident:string)"
#define ClassOriginalIdentGet_doc "string ctx.ClassOriginalIdentGet() (const)"
 
// doc-key: MqContextC,MqConfig,oco,func
#define ConfigGetIoTcpL_doc "MkBufferListC ctx.ConfigGetIoTcpL()"
 
// doc-key: MqContextC,MqConfig,om_,func
#define ConfigCheckStartAs_doc "bool ctx.ConfigCheckStartAs(data:MqStartE)"
#define ConfigGetBuffersize_doc "int32 ctx.ConfigGetBuffersize() (const)"
#define ConfigGetIdentFrom_doc "MqIdentE ctx.ConfigGetIdentFrom()"
#define ConfigGetIoPipe_doc "int32 ctx.ConfigGetIoPipe()"
#define ConfigGetIoUds_doc "string ctx.ConfigGetIoUds() (const)"
#define ConfigGetIsParent_doc "bool ctx.ConfigGetIsParent()"
#define ConfigGetIsServer_doc "bool ctx.ConfigGetIsServer()"
#define ConfigGetIsString_doc "bool ctx.ConfigGetIsString()"
#define ConfigGetName_doc "string ctx.ConfigGetName() (const)"
#define ConfigGetPkgsize_doc "int32 ctx.ConfigGetPkgsize() (const)"
#define ConfigGetPostfix_doc "string ctx.ConfigGetPostfix() (const)"
#define ConfigGetPrefix_doc "string ctx.ConfigGetPrefix() (const)"
#define ConfigGetStartAs_doc "MqStartE ctx.ConfigGetStartAs()"
#define ConfigGetStatusIs_doc "MqStatusIsEF ctx.ConfigGetStatusIs()"
#define ConfigGetStorage_doc "string ctx.ConfigGetStorage() (const)"
#define ConfigGetTimeout_doc "MkTimeoutE|int32 ctx.ConfigGetTimeout() (const)"
#define ConfigReset_doc "ctx.ConfigReset()"
#define ConfigSetAllDebug_doc "ctx.ConfigSetAllDebug(data:int32)"
#define ConfigSetBgError_doc "ctx.ConfigSetBgError(?callback:callable=None?)"
#define ConfigSetBuffersize_doc "ctx.ConfigSetBuffersize(data:int32)"
#define ConfigSetConfigFile_doc "ctx.ConfigSetConfigFile(filename:string)"
#define ConfigSetDaemon_doc "ctx.ConfigSetDaemon(pidfile:string)"
#define ConfigSetEvent_doc "ctx.ConfigSetEvent(?callback:callable=None?)"
#define ConfigSetIdentFrom_doc "ctx.ConfigSetIdentFrom(data:MqIdentE)"
#define ConfigSetIgnoreExit_doc "ctx.ConfigSetIgnoreExit(data:bool)"
#define ConfigSetIoPipe_doc "ctx.ConfigSetIoPipe(fh:int32)"
#define ConfigSetIoTcp_doc "ctx.ConfigSetIoTcp(?host:string=\"None\"?, ?port:string=\"None\"?, ?myhost:string=\"None\"?, ?myport:string=\"None\"?)"
#define ConfigSetIoTcpL_doc "ctx.ConfigSetIoTcpL(vals:MkBufferListC)"
#define ConfigSetIoUds_doc "ctx.ConfigSetIoUds(file:string)"
#define ConfigSetIsServer_doc "ctx.ConfigSetIsServer(data:bool)"
#define ConfigSetIsString_doc "ctx.ConfigSetIsString(data:bool)"
#define ConfigSetName_doc "ctx.ConfigSetName(data:string)"
#define ConfigSetPkgsize_doc "ctx.ConfigSetPkgsize(data:int32)"
#define ConfigSetPostfix_doc "ctx.ConfigSetPostfix(data:string)"
#define ConfigSetPrefix_doc "ctx.ConfigSetPrefix(data:string)"
#define ConfigSetServerCleanup_doc "ctx.ConfigSetServerCleanup(?callback:callable=None?)"
#define ConfigSetServerSetup_doc "ctx.ConfigSetServerSetup(?callback:callable=None?)"
#define ConfigSetStartAs_doc "ctx.ConfigSetStartAs(data:MqStartE)"
#define ConfigSetStartAsString_doc "ctx.ConfigSetStartAsString(data:string)"
#define ConfigSetStorage_doc "ctx.ConfigSetStorage(data:string)"
#define ConfigSetTimeout_doc "ctx.ConfigSetTimeout(data:MkTimeoutE|int32)"
 
// doc-key: MqContextC,MqConfig,omo,func
#define ConfigGetIoTcp_doc "{host:string port:string myhost:string myport:string} ctx.ConfigGetIoTcp()"
 
// doc-key: MqContextC,MqContext,sCc,func
#define Create_doc "MqContextC MqContextC.Create(?tmpl:MqContextC=None?)"
#define new_doc "MqContextC MqContextC.new(?tmpl:MqContextC=None?)"
 
// doc-key: MqContextC,MqContext,sc_,func
#define GetNull_doc "MqContextC MqContextC.GetNull()"
#define HandleResolve_doc "MqContextC MqContextC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "MqContextC MqContextC.Instances()"
 
// doc-key: MqContextC,MqContext,oc_,func
#define ErrorFORMAT_doc "MkErrorC fmtobj.ErrorFORMAT() (const)"
#define GetBuffer_doc "MkBufferC ctx.GetBuffer()"
#define Next_doc "MqContextC ctx.Next()"
#define Prev_doc "MqContextC ctx.Prev()"
 
// doc-key: MqContextC,MqContext,om_,func
#define ErrorCopy_doc "MkErrorE targetCtx.ErrorCopy(sourceCtx:MqContextC) (const)"
#define ErrorMove_doc "MkErrorE targetCtx.ErrorMove(sourceCtx:MqContextC) (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
// skip class-overload: Log → MkObjectLog
#define LogConfig_doc "ctx.LogConfig(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogEnv_doc "ctx.LogEnv(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogLink_doc "ctx.LogLink(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogSetup_doc "ctx.LogSetup(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
#define LogShort_doc "ctx.LogShort(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?, ?label:string=\"None\"?) (const)"
#define LogType_doc "ctx.LogType(?fmtobj:MkObjectC=None?, ?debug:int32=0?, ?callfunc:string=\"MK_NULL\"?, ?lvl:int32=0?) (const)"
// skip class-overload: ToString → MkObjectToString
 
// doc-key: MqContextC,MqEnv,om_,func
#define EnvProtect_doc "ctx.EnvProtect()"
#define EnvRestore_doc "ctx.EnvRestore()"
 
// doc-key: MqContextC,MqExit,om_,func
#define Exit_doc "int32 ctx.Exit(?callfunc:string=\"MK_NULL\"?, ?callfile:string=\"MK_NULL\"?, ?callline:int32=-1?)"
 
// doc-key: MqContextC,MqGet,oc_,func
#define GetRoot_doc "MqContextC ctx.GetRoot()"
 
// doc-key: MqContextC,MqLink,oc_,func
#define LinkGetParent_doc "MqContextC ctx.LinkGetParent()"
 
// doc-key: MqContextC,MqLink,om_,func
#define LinkConnect_doc "ctx.LinkConnect()"
#define LinkCreate_doc "ctx.LinkCreate(?args:MkBufferListC...=None?)"
#define LinkCreateChild_doc "ctx.LinkCreateChild(parent:MqContextC, ?args:MkBufferListC...=None?)"
#define LinkDelete_doc "ctx.LinkDelete()"
#define LinkGetCtxId_doc "int32 ctx.LinkGetCtxId()"
#define LinkGetTargetIdent_doc "string ctx.LinkGetTargetIdent()"
#define LinkIsConnected_doc "bool ctx.LinkIsConnected()"
#define LinkIsParent_doc "bool ctx.LinkIsParent()"
#define LinkShutdown_doc "ctx.LinkShutdown()"
 
// doc-key: MqContextC,MqLog,om_,func
#define LogParentOrChild_doc "string ctx.LogParentOrChild() (const)"
#define LogServerOrClient_doc "string ctx.LogServerOrClient() (const)"
 
// doc-key: MqContextC,MqProcess,om_,func
#define ProcessEvent_doc "ctx.ProcessEvent(?wait:MqWaitOnEventE=NO?, ?timeout:MkTimeoutE|int32=DEFAULT?)"
 
// doc-key: MqContextC,MqProxy,om_,func
#define ProxyForward_doc "sourceCtx.ProxyForward(targetCtx:MqContextC, ?dump:MqDumpC=None?, ?timeout:MkTimeoutE|int32=DEFAULT?)"
#define ProxyItem_doc "sourceCtx.ProxyItem(targetCtx:MqContextC)"
 
// doc-key: MqContextC,MqRead,oci,func
#define ReadALL_doc "MkBufferListC ctx.ReadALL(?val_inout:MkBufferListC=None?)"
 
// doc-key: MqContextC,MqRead,oco,func
#define ReadBFL_doc "MkBufferListC ctx.ReadBFL()"
#define ReadBUF_doc "MkBufferC ctx.ReadBUF()"
 
// doc-key: MqContextC,MqRead,om_,func
#define ReadDbg_doc "ctx.ReadDbg()"
#define ReadGetNextType_doc "MkTypeE ctx.ReadGetNextType()"
#define ReadGetNumItems_doc "int32 ctx.ReadGetNumItems()"
#define ReadItemExists_doc "bool ctx.ReadItemExists()"
#define ReadL_END_doc "ctx.ReadL_END()"
#define ReadL_START_doc "ctx.ReadL_START(?buf:MkBufferC=None?)"
#define ReadT_END_doc "ctx.ReadT_END()"
#define ReadT_START_doc "ctx.ReadT_START()"
#define ReadUndo_doc "ctx.ReadUndo()"
 
// doc-key: MqContextC,MqRead,omo,func
#define ReadBIN_doc "binary ctx.ReadBIN()"
#define ReadBOL_doc "bool ctx.ReadBOL()"
#define ReadBinaryR_doc "binary ctx.ReadBinaryR()"
#define ReadDBL_doc "double ctx.ReadDBL()"
#define ReadFLT_doc "float ctx.ReadFLT()"
#define ReadHDL_doc "MK_HDL ctx.ReadHDL()"
#define ReadI16_doc "int16 ctx.ReadI16()"
#define ReadI32_doc "int32 ctx.ReadI32()"
#define ReadI64_doc "int64 ctx.ReadI64()"
#define ReadI8_doc "int8 ctx.ReadI8()"
#define ReadLIST_doc "[list...] ctx.ReadLIST()"
#define ReadLONG_doc "long ctx.ReadLONG()"
#define ReadNEXT_doc "obj ctx.ReadNEXT()"
#define ReadSTR_doc "string ctx.ReadSTR()"
#define ReadStringR_doc "string ctx.ReadStringR()"
 
// doc-key: MqContextC,MqRoute,oco,func
#define RouteGetTree_doc "MkBufferListC ctx.RouteGetTree()"
 
// doc-key: MqContextC,MqRoute,om_,func
#define RouteCreate_doc "ctx.RouteCreate(route:string, service:string, ?overwrite:bool=false?)"
#define RouteDelete_doc "ctx.RouteDelete(route:string, service:string, ?overwrite:bool=false?)"
#define RouteResolve_doc "[MqContextC...] ctx.RouteResolve(ident:string, ?retnum:int32=-1?)"
#define RouteTraverse_doc "ctx.RouteTraverse(service:string, ?args:MkBufferListC...=None?)"
 
// doc-key: MqContextC,MqRoute,omo,func
#define RouteGetPath_doc "string ctx.RouteGetPath()"
 
// doc-key: MqContextC,MqSend,om_,func
#define Send_doc "ctx.Send(cstr:string, args:args...)"
#define SendBFL_doc "ctx.SendBFL(val:MkBufferListC)"
#define SendBIN_doc "ctx.SendBIN(val:binary)"
#define SendBOL_doc "ctx.SendBOL(val:bool)"
#define SendBUF_doc "ctx.SendBUF(val:MkBufferC)"
#define SendBUS_FLAT_doc "ctx.SendBUS_FLAT(val:MkBufferStreamC)"
#define SendBinaryR_doc "ctx.SendBinaryR(val:binary)"
#define SendDBL_doc "ctx.SendDBL(val:double)"
#define SendEND_doc "ctx.SendEND(token:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?)"
#define SendEND_AND_CALLBACK_doc "ctx.SendEND_AND_CALLBACK(token:string[4], callback:callable, ?timeout:MkTimeoutE|int32=DEFAULT?)"
#define SendEND_AND_SUB_doc "ctx.SendEND_AND_SUB(token:string[4], callback:callable, ?timeout:MkTimeoutE|int32=DEFAULT?)"
#define SendEND_AND_TRANSACTION_doc "ctx.SendEND_AND_TRANSACTION(token:string[4], callback:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?)"
#define SendEND_AND_WAIT_doc "ctx.SendEND_AND_WAIT(token:string[4], ?timeout:MkTimeoutE|int32=DEFAULT?)"
#define SendERROR_doc "ctx.SendERROR()"
#define SendFLT_doc "ctx.SendFLT(val:float)"
#define SendHDL_doc "ctx.SendHDL(val:MK_HDL)"
#define SendI16_doc "ctx.SendI16(val:int16)"
#define SendI32_doc "ctx.SendI32(val:int32)"
#define SendI64_doc "ctx.SendI64(val:int64)"
#define SendI8_doc "ctx.SendI8(val:int8)"
#define SendLONG_doc "ctx.SendLONG(val:long)"
#define SendLTR_doc "ctx.SendLTR(transLId:int32)"
#define SendL_END_doc "ctx.SendL_END()"
#define SendL_FLAT_doc "ctx.SendL_FLAT(val:MkBufferListC)"
#define SendL_START_doc "ctx.SendL_START()"
#define SendRETURN_doc "ctx.SendRETURN()"
#define SendRETURN_SUB_doc "ctx.SendRETURN_SUB()"
#define SendSTART_doc "ctx.SendSTART()"
#define SendSTR_doc "ctx.SendSTR(val:string)"
#define SendSYNC_doc "ctx.SendSYNC()"
#define SendStringR_doc "ctx.SendStringR(val:string)"
#define SendT_END_doc "ctx.SendT_END()"
#define SendT_START_doc "ctx.SendT_START()"
 
// doc-key: MqContextC,MqService,om_,func
#define ServiceCreate_doc "ctx.ServiceCreate(token:string[4], callback:callable)"
#define ServiceDelete_doc "ctx.ServiceDelete(token:string[4])"
#define ServiceIsTransaction_doc "bool ctx.ServiceIsTransaction()"
#define ServiceProxy_doc "ctx.ServiceProxy(token:string[4], ?id:MqSlaveE|int32=MQ_SLAVE_OTHER?)"
#define ServiceProxyCtx_doc "ctx.ServiceProxyCtx(token:string[4], target:MqContextC)"
#define ServiceProxyCtxExists_doc "bool ctx.ServiceProxyCtxExists(token:string[4], target:MqContextC)"
#define ServiceProxyRoundRobin_doc "ctx.ServiceProxyRoundRobin(token:string[4], ident:string)"
#define ServiceStorage_doc "ctx.ServiceStorage(token:string[4])"
#define ServiceTokenCheck_doc "bool ctx.ServiceTokenCheck(token:string[4])"
#define ServiceTokenExists_doc "bool ctx.ServiceTokenExists(token:string[4])"
#define ServiceTokenGet_doc "string[4] ctx.ServiceTokenGet()"
 
// doc-key: MqContextC,MqSlave,oc_,func
#define SlaveGetMaster_doc "MqContextC ctx.SlaveGetMaster()"
 
// doc-key: MqContextC,MqSlave,oco,func
#define SlaveGet_doc "MqContextC ctx.SlaveGet(id:MqSlaveE|int32)"
#define SlaveGetFilter_doc "MqContextC ctx.SlaveGetFilter()"
#define SlaveGetProxy_doc "MqContextC ctx.SlaveGetProxy(id:MqSlaveE|int32)"
 
// doc-key: MqContextC,MqSlave,om_,func
#define SlaveCheck_doc "bool ctx.SlaveCheck(id:MqSlaveE|int32) (const)"
#define SlaveCreate_doc "ctx.SlaveCreate(id:MqSlaveE|int32, slave:MqContextC)"
#define SlaveDelete_doc "ctx.SlaveDelete(id:MqSlaveE|int32)"
#define SlaveIs_doc "bool ctx.SlaveIs() (const)"
#define SlaveWorker_doc "ctx.SlaveWorker(id:MqSlaveE|int32, ?fct:string=\"WORKER\"?, ?args:MkBufferListC...=None?)"
 
// doc-key: MqContextC,MqStorage,oci,func
#define StorageDelete_doc "int32 ctx.StorageDelete(?*transLIdP_inout:int32=0?)"
#define StorageImport_doc "int32 ctx.StorageImport(?*transLIdP_inout:int32=0?)"
 
// doc-key: MqContextC,MqStorage,om_,func
#define StorageClose_doc "ctx.StorageClose()"
#define StorageDecrRef_doc "ctx.StorageDecrRef(transLId:int32)"
#define StorageIncrRef_doc "ctx.StorageIncrRef(transLId:int32)"
#define StorageLog_doc "ctx.StorageLog(?callfunc:string=\"MK_NULL\"?)"
#define StorageOpen_doc "ctx.StorageOpen(storageFile:string)"
 
// doc-key: MqContextC,MqStorage,omo,func
#define StorageCount_doc "int32 ctx.StorageCount()"
#define StorageErrCnt_doc "int32 ctx.StorageErrCnt(transLId:int32)"
#define StorageExport_doc "int32 ctx.StorageExport()"
#define StorageResolve_doc "{otherCtxP:MqContextC otherLIdP:int32} ctx.StorageResolve()"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
#undef Send_doc
#define Send_doc Send_doc_extra
 
#define Debug_doc "None ctx.Debug(prefix:str, obj=self:object)"
 
 
PyObject*   NS(MqContextC_ReadNEXT)     (MqContextC_ARGS);
#include "tmpl/MqContextC_ReadNEXT_lng.h"
 
PyObject*   NS(MqContextC_ReadLIST)     (MqContextC_ARGS);
#include "tmpl/MqContextC_ReadLIST_lng.h"
 
static PyObject* NS(MqContextC_Debug) (MqContextC_ARGS) {
  PyObject *strO=NULL, *utf8=NULL;
  OT_SETUP_hdl
  OT_SETUP_VARARGS(1,2,"None ctx.Debug(prefix:str, obj=self:object)")
  MK_STRN prefix=0;
  OT_CHECK_REQUIRED(OT_CHECK_STR(prefix))
  OT_SETUP_OBJ(obj,self)
  OT_CHECK_OPTIONAL(OT_CHECK_LNG_T(obj))
  OT_CHECK_NOARGS
  LngErrorCheckN(strO = PyObject_Repr(obj));
  LngErrorCheckN(utf8 = PyUnicode_AsUTF8String(strO));
  MkLogV_4M(hdl,prefix,0,"%s, type=%s, refCnt=%-3zi\n",
    PyBytes_AsString(utf8), Py_TYPE(obj)->tp_name, Py_REFCNT(obj)-1);
  OT_retObj_SET_None
  goto end;
error:
  OT_retObj_SET_Error
end:
  Py_CLEAR(strO);
  Py_CLEAR(utf8);
  OT_retObj_RETURN
}
 
static PyObject* NS(MqContextC_Debug2) (MqContextC_ARGS) {
  OT_SETUP_hdl
  OT_SETUP_VARARGS(1,2,"None ctx.Debug2(prefix:str, ?obj=self:object?)")
  MK_STRN prefix=0;
  OT_CHECK_REQUIRED(OT_CHECK_STR(prefix))
  OT_SETUP_OBJ(obj,self)
  OT_CHECK_OPTIONAL(OT_CHECK_LNG_T(obj))
  OT_CHECK_NOARGS
  MkLogV_4M(hdl,prefix,0,"self<%p>, type<%s>, refCount<%li>\n", obj, Py_TYPE(obj)->tp_name, (long) Py_REFCNT(obj)-1);
  OT_retObj_SET_None
  goto end;
error:
  OT_retObj_SET_Error
end:
  OT_retObj_RETURN
}
 
// -----------------------------------------------------------------------------
 
// BEGIN-MqContextC - created by 'py_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
// doc-key: MqContextC,MqContextC-Class-Export,sc_
 
static OT_ProcRet NS(MqContextC_HandleResolve) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(HandleResolve_doc);
  MK_HDL netHdl = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (netHdl))
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqContextHandleResolve (netHdl);
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-Class-Export,om_
 
// skip on class-overload: MqContextHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MqContextC_HandleGet) (MqContextC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MqContextC_Class_PY_API
 
 
// doc-key: MqContextC,MqContextC-Class-Introspection,oc_
 
static OT_ProcRet NS(MqContextC_Next) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqContextNext (hdl);
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_Prev) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqContextPrev (hdl);
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-Class-Introspection,sc_
 
static OT_ProcRet NS(MqContextC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqContextInstances ();
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_Class_PY_API
 
 
// doc-key: MqContextC,MqContextC-Class-Misc,sc_
 
static OT_ProcRet NS(MqContextC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqContextGetNull ();
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_Class_PY_API
 
 
// doc-key: MqContextC,MqContextC-ClassApi-Class,oc_
 
static OT_ProcRet NS(MqContextC_ClassFactoryGet) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ClassFactoryGet_doc);
  OT_CHECK_NOARGS;
  MQ_FCT retVal = MqClassFactoryGet (hdl);
  OT_retObj_SET_FCT(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-ClassApi-Class,om_
 
static OT_ProcRet NS(MqContextC_ClassFactorySet) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ClassFactorySet_doc);
  MQ_FCT item = 0;
  OT_CHECK_REQUIRED(OT_CHECK_FCT (item,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqClassFactorySet (hdl, item));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ClassIdentGet) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ClassIdentGet_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqClassIdentGet (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ClassIdentSet) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ClassIdentSet_doc);
  MK_STRN ident = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqClassIdentSet (hdl, ident));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ClassOriginalIdentGet) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ClassOriginalIdentGet_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqClassOriginalIdentGet (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ClassApi_Class_PY_API
 
 
// doc-key: MqContextC,MqContextC-ConfigApi-Get,oco
 
static OT_ProcRet NS(MqContextC_ConfigGetIoTcpL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetIoTcpL_doc);
  OT_CHECK_NOARGS;
  MK_BFL vals_out;
  MkErrorC_Check(hdl,MqConfigGetIoTcpL (hdl, &vals_out));
  OT_retObj_SET_BFL(vals_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-ConfigApi-Get,om_
 
static OT_ProcRet NS(MqContextC_ConfigGetBuffersize) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetBuffersize_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqConfigGetBuffersize (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetIdentFrom) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetIdentFrom_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mq_enum_OBJ(IdentE,MqConfigGetIdentFrom (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetIoPipe) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetIoPipe_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqConfigGetIoPipe (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetIoUds) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetIoUds_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqConfigGetIoUds (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetIsParent) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetIsParent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqConfigGetIsParent (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetIsServer) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetIsServer_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqConfigGetIsServer (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetIsString) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetIsString_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqConfigGetIsString (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetName) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetName_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqConfigGetName (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetPkgsize) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetPkgsize_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqConfigGetPkgsize (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetPostfix) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetPostfix_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqConfigGetPostfix (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetPrefix) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetPrefix_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqConfigGetPrefix (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetStartAs) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetStartAs_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mq_enum_OBJ(StartE,MqConfigGetStartAs (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetStatusIs) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetStatusIs_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mq_enum_OBJ(StatusIsEF,MqConfigGetStatusIs (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetStorage) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetStorage_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqConfigGetStorage (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigGetTimeout) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetTimeout_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_LONG(MqConfigGetTimeout (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetConfigFile) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetConfigFile_doc);
  MK_STRN filename = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (filename))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetConfigFile (hdl, filename));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-ConfigApi-Get,omo
 
static OT_ProcRet NS(MqContextC_ConfigGetIoTcp) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigGetIoTcp_doc);
  OT_CHECK_NOARGS;
  MK_STRN host_out;
  MK_STRN port_out;
  MK_STRN myhost_out;
  MK_STRN myport_out;
  MkErrorC_Check(hdl,MqConfigGetIoTcp (hdl, &host_out, &port_out, &myhost_out, &myport_out));
  OT_retObj_SET_List;
  OT_retObj_APPEND(OT_TMP_STR_OBJ(host_out));
  OT_retObj_APPEND(OT_TMP_STR_OBJ(port_out));
  OT_retObj_APPEND(OT_TMP_STR_OBJ(myhost_out));
  OT_retObj_APPEND(OT_TMP_STR_OBJ(myport_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ConfigApi_Get_PY_API
 
 
// doc-key: MqContextC,MqContextC-ConfigApi-Interface,om_
 
static OT_ProcRet NS(MqContextC_ConfigSetBgError) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,ConfigSetBgError_doc);
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_OPTIONAL(OT_CHECK_CALLABLE(callback))
  OT_CHECK_NOARGS;
  MqServiceCallbackF fCall = (callback == NULL ? NULL : NS(ServiceCall));
  MqConfigSetBgError (hdl, fCall, callback, NS(ServiceFree), NS(ServiceCopy));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetEvent) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,ConfigSetEvent_doc);
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_OPTIONAL(OT_CHECK_CALLABLE(callback))
  OT_CHECK_NOARGS;
  MqServiceCallbackF fCall = (callback == NULL ? NULL : NS(ServiceCall));
  MqConfigSetEvent (hdl, fCall, callback, NS(ServiceFree), NS(ServiceCopy));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetServerCleanup) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,ConfigSetServerCleanup_doc);
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_OPTIONAL(OT_CHECK_CALLABLE(callback))
  OT_CHECK_NOARGS;
  MqServiceCallbackF fCall = (callback == NULL ? NULL : NS(ServiceCall));
  MqConfigSetServerCleanup (hdl, fCall, callback, NS(ServiceFree), NS(ServiceCopy));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetServerSetup) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,ConfigSetServerSetup_doc);
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_OPTIONAL(OT_CHECK_CALLABLE(callback))
  OT_CHECK_NOARGS;
  MqServiceCallbackF fCall = (callback == NULL ? NULL : NS(ServiceCall));
  MqConfigSetServerSetup (hdl, fCall, callback, NS(ServiceFree), NS(ServiceCopy));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
// MqContextC_ConfigApi_Interface_PY_API
 
 
// doc-key: MqContextC,MqContextC-ConfigApi-Misc,om_
 
static OT_ProcRet NS(MqContextC_ConfigReset) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ConfigReset_doc);
  OT_CHECK_NOARGS;
  MqConfigReset (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ConfigApi_Misc_PY_API
 
 
// doc-key: MqContextC,MqContextC-ConfigApi-Set,om_
 
static OT_ProcRet NS(MqContextC_ConfigCheckStartAs) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigCheckStartAs_doc);
  enum MqStartE data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqStartE,data))
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqConfigCheckStartAs (hdl, data));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetAllDebug) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetAllDebug_doc);
  MK_I32 data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (data))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetAllDebug (hdl, data));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetBuffersize) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetBuffersize_doc);
  MK_I32 data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (data))
  OT_CHECK_NOARGS;
  MqConfigSetBuffersize (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetDaemon) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetDaemon_doc);
  MK_STRN pidfile = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (pidfile))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetDaemon (hdl, pidfile));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetIdentFrom) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetIdentFrom_doc);
  enum MqIdentE data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqIdentE,data))
  OT_CHECK_NOARGS;
  MqConfigSetIdentFrom (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetIgnoreExit) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetIgnoreExit_doc);
  MK_BOOL data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_bool (data))
  OT_CHECK_NOARGS;
  MqConfigSetIgnoreExit (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetIoPipe) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetIoPipe_doc);
  MQ_SOCK_HDL fh = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (fh))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetIoPipe (hdl, fh));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetIoTcp) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,ConfigSetIoTcp_doc);
  MK_STRN host = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (host))
  MK_STRN port = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (port))
  MK_STRN myhost = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (myhost))
  MK_STRN myport = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (myport))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetIoTcp (hdl, host, port, myhost, myport));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetIoTcpL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetIoTcpL_doc);
  MkBufferListCreateTLS_T(vals,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFL (vals,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetIoTcpL (hdl, vals));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetIoUds) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetIoUds_doc);
  MK_STRN file = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (file))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetIoUds (hdl, file));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetIsServer) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetIsServer_doc);
  MK_BOOL data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_bool (data))
  OT_CHECK_NOARGS;
  MqConfigSetIsServer (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetIsString) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetIsString_doc);
  MK_BOOL data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_bool (data))
  OT_CHECK_NOARGS;
  MqConfigSetIsString (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetName) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetName_doc);
  MK_STRN data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (data))
  OT_CHECK_NOARGS;
  MqConfigSetName (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetPkgsize) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetPkgsize_doc);
  MK_I32 data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (data))
  OT_CHECK_NOARGS;
  MqConfigSetPkgsize (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetPostfix) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetPostfix_doc);
  MK_STRN data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (data))
  OT_CHECK_NOARGS;
  MqConfigSetPostfix (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetPrefix) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetPrefix_doc);
  MK_STRN data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (data))
  OT_CHECK_NOARGS;
  MqConfigSetPrefix (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetStartAs) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetStartAs_doc);
  enum MqStartE data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MqStartE,data))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetStartAs (hdl, data));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetStartAsString) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetStartAsString_doc);
  MK_STRN data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (data))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqConfigSetStartAsString (hdl, data));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetStorage) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetStorage_doc);
  MK_STRN data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (data))
  OT_CHECK_NOARGS;
  MqConfigSetStorage (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ConfigSetTimeout) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ConfigSetTimeout_doc);
  MK_TIME_T data = 0;
  OT_CHECK_REQUIRED(OT_CHECK_TIME_T (data))
  OT_CHECK_NOARGS;
  MqConfigSetTimeout (hdl, data);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ConfigApi_Set_PY_API
 
 
// doc-key: MqContextC,MqContextC-EnvApi-Env,om_
 
static OT_ProcRet NS(MqContextC_EnvProtect) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(EnvProtect_doc);
  OT_CHECK_NOARGS;
  MqEnvProtect (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_EnvRestore) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(EnvRestore_doc);
  OT_CHECK_NOARGS;
  MqEnvRestore (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_EnvApi_Env_PY_API
 
 
// doc-key: MqContextC,MqContextC-ErrorApi-Error,oc_
 
static OT_ProcRet NS(MqContextC_ErrorFORMAT) (MqContextC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_NOARG(ErrorFORMAT_doc);
  OT_CHECK_NOARGS;
  MK_ERR retVal = MqContextErrorFORMAT (hdl);
  OT_retObj_SET_ERR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-ErrorApi-Error,om_
 
OT_ProcRet NS(MqContextC_ErrorCopy) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ErrorCopy_doc);
  MQ_CTXN sourceCtx = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CTXN (sourceCtx,MK_NULL_NO))
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,MqContextErrorCopy (hdl, sourceCtx)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
OT_ProcRet NS(MqContextC_ErrorMove) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ErrorMove_doc);
  MQ_CTXN sourceCtx = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CTXN (sourceCtx,MK_NULL_NO))
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(ErrorE,MqContextErrorMove (hdl, sourceCtx)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ErrorApi_Error_PY_API
 
 
// doc-key: MqContextC,MqContextC-HighApi-High,om_
 
OT_ProcRet NS(MqContextC_Send) (MqContextC_ARGS) ; // skip template-required
 
// MqContextC_HighApi_High_PY_API
 
 
// doc-key: MqContextC,MqContextC-LinkApi-Link,oc_
 
static OT_ProcRet NS(MqContextC_LinkGetParent) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LinkGetParent_doc);
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqLinkGetParent (hdl);
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-LinkApi-Link,om_
 
static OT_ProcRet NS(MqContextC_LinkConnect) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LinkConnect_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqLinkConnect (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LinkCreate) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,99,LinkCreate_doc);
  MkBufferListCreateTLS_T(args,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BAC (args))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqLinkCreate (hdl, args));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LinkCreateChild) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,99,LinkCreateChild_doc);
  MQ_CTX parent = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CTX (parent,MK_NULL_NO))
  MkBufferListCreateTLS_T(args,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BAC (args))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqLinkCreateChild (hdl, parent, args));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LinkDelete) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LinkDelete_doc);
  OT_CHECK_NOARGS;
  MqLinkDelete (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LinkGetCtxId) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LinkGetCtxId_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqLinkGetCtxId (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LinkGetTargetIdent) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LinkGetTargetIdent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqLinkGetTargetIdent (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LinkIsConnected) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LinkIsConnected_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqLinkIsConnected (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LinkIsParent) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LinkIsParent_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqLinkIsParent (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LinkShutdown) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LinkShutdown_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqLinkShutdown (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_LinkApi_Link_PY_API
 
 
// doc-key: MqContextC,MqContextC-LogApi-Log,om_
 
// skip on class-overload: MqContextLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MqContextC_Log) (MqContextC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(MqContextC_LogConfig) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,LogConfig_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MqContextLogConfig (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LogEnv) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,LogEnv_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MqContextLogEnv (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LogLink) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,LogLink_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MqContextLogLink (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LogSetup) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,LogSetup_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MqContextLogSetup (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LogShort) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,5,LogShort_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  MK_STRN label = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (label))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MqContextLogShort (hdl, fmtobj, debug, callfunc, lvl, label);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LogType) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,4,LogType_doc);
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_DBG debug = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (debug))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_I32 lvl = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (lvl))
  OT_CHECK_NOARGS;
  if (debug > MkRuntimeDebugGet()) {
    OT_retObj_SET_None;
    goto end;
  }
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MqContextLogType (hdl, fmtobj, debug, callfunc, lvl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LogParentOrChild) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LogParentOrChild_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqLogParentOrChild (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_LogServerOrClient) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(LogServerOrClient_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqLogServerOrClient (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_LogApi_Log_PY_API
 
 
// doc-key: MqContextC,MqContextC-MiscApi-Misc,oc_
 
static OT_ProcRet NS(MqContextC_GetBuffer) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetBuffer_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MqContextGetBuffer (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_GetRoot) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetRoot_doc);
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqGetRoot (hdl);
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-MiscApi-Misc,om_
 
// skip on class-overload: MqContextToString → MkObjectToString
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MqContextC_ToString) (MqContextC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(MqContextC_Exit) (MqContextC_ARGS) {
  OT_SETUP_hdl__null_allow;
  OT_SETUP_VARARGS(0,3,Exit_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  MK_STRN callfile = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfile))
  MK_I32 callline = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (callline))
  OT_CHECK_NOARGS;
  if (callline == -1 ) {callline = OT_GET_CALL_LINE;}
  if (MkSysStringIsNULL(callfile)) {callfile = OT_GET_CALL_FILE;}
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  OT_retObj_SET_I32(MqExit (hdl, callfunc, callfile, callline));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ProcessEvent) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,2,ProcessEvent_doc);
  enum MqWaitOnEventE wait = MQ_WAIT_NO;
  OT_CHECK_OPTIONAL(OT_CHECK_ENUM (MqWaitOnEventE,wait))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqProcessEvent (hdl, wait, timeout));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_MiscApi_Misc_PY_API
 
 
// doc-key: MqContextC,MqContextC-ProxyApi-Proxy,om_
 
static OT_ProcRet NS(MqContextC_ProxyForward) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,ProxyForward_doc);
  MQ_CTX targetCtx = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CTX (targetCtx,MK_NULL_NO))
  MQ_DMP dump = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_DMP (dump,MK_NULL_YES))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqProxyForward (hdl, targetCtx, dump, timeout));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ProxyItem) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ProxyItem_doc);
  MQ_CTX targetCtx = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CTX (targetCtx,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqProxyItem (hdl, targetCtx));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ProxyApi_Proxy_PY_API
 
 
// doc-key: MqContextC,MqContextC-ReadApi-Atom,oci
 
static OT_ProcRet NS(MqContextC_ReadALL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,ReadALL_doc);
  MkBufferListCreateTLS_T(val_inout,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BFL (val_inout,MK_NULL_YES))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqReadALL (hdl, &val_inout));
  OT_retObj_SET_BFL(val_inout);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-ReadApi-Atom,oco
 
static OT_ProcRet NS(MqContextC_ReadBFL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBFL_doc);
  OT_CHECK_NOARGS;
  MK_BFL val_out;
  MkErrorC_Check(hdl,MqReadBFL (hdl, &val_out));
  OT_retObj_SET_BFL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadBUF) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBUF_doc);
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MqReadBUF (hdl, &val_out));
  OT_retObj_SET_BUF(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-ReadApi-Atom,omo
 
static OT_ProcRet NS(MqContextC_ReadBIN) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBIN_doc);
  OT_CHECK_NOARGS;
  MkBinaryR val_out;
  MkErrorC_Check(hdl,MqReadBIN (hdl, &val_out));
  MkBinaryR retVal = val_out;
  OT_retObj_SET(OT_GET__ME_REF_MkBinaryR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadBOL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBOL_doc);
  OT_CHECK_NOARGS;
  MK_BOL val_out;
  MkErrorC_Check(hdl,MqReadBOL (hdl, &val_out));
  OT_retObj_SET_BOL(val_out == 1);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadBinaryR) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBinaryR_doc);
  OT_CHECK_NOARGS;
  MkBinaryR val_out;
  MkErrorC_Check(hdl,MqReadBinaryR (hdl, &val_out));
  MkBinaryR retVal = val_out;
  OT_retObj_SET(OT_GET__ME_REF_MkBinaryR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadDBL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadDBL_doc);
  OT_CHECK_NOARGS;
  MK_DBL val_out;
  MkErrorC_Check(hdl,MqReadDBL (hdl, &val_out));
  OT_retObj_SET_DBL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadFLT) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadFLT_doc);
  OT_CHECK_NOARGS;
  MK_FLT val_out;
  MkErrorC_Check(hdl,MqReadFLT (hdl, &val_out));
  OT_retObj_SET_FLT(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadHDL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadHDL_doc);
  OT_CHECK_NOARGS;
  MK_HDL val_out;
  MkErrorC_Check(hdl,MqReadHDL (hdl, &val_out));
  OT_retObj_SET_HDL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadI16) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadI16_doc);
  OT_CHECK_NOARGS;
  MK_I16 val_out;
  MkErrorC_Check(hdl,MqReadI16 (hdl, &val_out));
  OT_retObj_SET_I16(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadI32) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadI32_doc);
  OT_CHECK_NOARGS;
  MK_I32 val_out;
  MkErrorC_Check(hdl,MqReadI32 (hdl, &val_out));
  OT_retObj_SET_I32(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadI64) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadI64_doc);
  OT_CHECK_NOARGS;
  MK_I64 val_out;
  MkErrorC_Check(hdl,MqReadI64 (hdl, &val_out));
  OT_retObj_SET_I64(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadI8) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadI8_doc);
  OT_CHECK_NOARGS;
  MK_I8 val_out;
  MkErrorC_Check(hdl,MqReadI8 (hdl, &val_out));
  OT_retObj_SET_I8(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
OT_ProcRet NS(MqContextC_ReadLIST) (MqContextC_ARGS) ; // skip template-required
 
static OT_ProcRet NS(MqContextC_ReadLONG) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadLONG_doc);
  OT_CHECK_NOARGS;
  MK_LONG val_out;
  MkErrorC_Check(hdl,MqReadLONG (hdl, &val_out));
  OT_retObj_SET_LONG(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
OT_ProcRet NS(MqContextC_ReadNEXT) (MqContextC_ARGS) ; // skip template-required
 
static OT_ProcRet NS(MqContextC_ReadSTR) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadSTR_doc);
  OT_CHECK_NOARGS;
  MK_STRN val_out;
  MkErrorC_Check(hdl,MqReadSTR (hdl, &val_out));
  OT_retObj_SET_STR(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadStringR) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadStringR_doc);
  OT_CHECK_NOARGS;
  MkStringR val_out;
  MkErrorC_Check(hdl,MqReadStringR (hdl, &val_out));
  MkStringR retVal = val_out;
  OT_retObj_SET(OT_GET__ME_REF_MkStringR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ReadApi_Atom_PY_API
 
 
// doc-key: MqContextC,MqContextC-ReadApi-Block,om_
 
static OT_ProcRet NS(MqContextC_ReadL_END) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadL_END_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqReadL_END (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadL_START) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,ReadL_START_doc);
  MK_BUF buf = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_BUF (buf,MK_NULL_YES))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqReadL_START (hdl, buf));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadT_END) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadT_END_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqReadT_END (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadT_START) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadT_START_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqReadT_START (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ReadApi_Block_PY_API
 
 
// doc-key: MqContextC,MqContextC-ReadApi-Misc,om_
 
static OT_ProcRet NS(MqContextC_ReadDbg) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadDbg_doc);
  OT_CHECK_NOARGS;
  MqReadDbg (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadGetNextType) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadGetNextType_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(TypeE,MqReadGetNextType (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadGetNumItems) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadGetNumItems_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MqReadGetNumItems (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadItemExists) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadItemExists_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqReadItemExists (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ReadUndo) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadUndo_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqReadUndo (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ReadApi_Misc_PY_API
 
 
// doc-key: MqContextC,MqContextC-RouteApi-Route,oco
 
static OT_ProcRet NS(MqContextC_RouteGetTree) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(RouteGetTree_doc);
  OT_CHECK_NOARGS;
  MK_BFL treeP_out;
  MkErrorC_Check(hdl,MqRouteGetTree (hdl, &treeP_out));
  OT_retObj_SET_BFL(treeP_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-RouteApi-Route,om_
 
static OT_ProcRet NS(MqContextC_RouteCreate) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,3,RouteCreate_doc);
  MK_STRN route = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (route))
  MK_STRN service = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (service))
  MK_BOOL overwrite = false;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (overwrite))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqRouteCreate (hdl, route, service, overwrite));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_RouteDelete) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,3,RouteDelete_doc);
  MK_STRN route = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (route))
  MK_STRN service = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (service))
  MK_BOOL overwrite = false;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (overwrite))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqRouteDelete (hdl, route, service, overwrite));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_RouteResolve) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,RouteResolve_doc);
  MK_STRN ident = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (ident))
  MK_NUM retnum = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (retnum))
  OT_CHECK_NOARGS;
  MQ_CTX_A retVal = MqRouteResolve (hdl, ident, retnum);
  OT_retObj_SET_List;
  for (int i=0; i<retVal.size; i++) {
    OT_retObj_APPEND(OT_TMP_CTX_OBJ(retVal.data[i]));
  }
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_RouteTraverse) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,99,RouteTraverse_doc);
  MK_STRN service = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (service))
  MkBufferListCreateTLS_T(args,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BAC (args))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqRouteTraverse (hdl, service, args));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-RouteApi-Route,omo
 
static OT_ProcRet NS(MqContextC_RouteGetPath) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(RouteGetPath_doc);
  OT_CHECK_NOARGS;
  MK_STRN path_out;
  MkErrorC_Check(hdl,MqRouteGetPath (hdl, &path_out));
  OT_retObj_SET_STR(path_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_RouteApi_Route_PY_API
 
 
// doc-key: MqContextC,MqContextC-SendApi-Atom,om_
 
static OT_ProcRet NS(MqContextC_SendBFL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendBFL_doc);
  MkBufferListCreateTLS_T(val,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendBFL (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendBIN) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendBIN_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendBIN (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendBOL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendBOL_doc);
  MK_BOL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NB1 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendBOL (hdl, (MK_BOL)(val?1:0)));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendBUF) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendBUF_doc);
  MK_BUFN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendBUF (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendBUS_FLAT) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendBUS_FLAT_doc);
  MK_BUSN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUSN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendBUS_FLAT (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendBinaryR) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendBinaryR_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendBinaryR (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendDBL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendDBL_doc);
  MK_DBL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF8 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendDBL (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendFLT) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendFLT_doc);
  MK_FLT val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF4 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendFLT (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendHDL) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendHDL_doc);
  MK_HDL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendHDL (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendI16) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendI16_doc);
  MK_I16 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendI16 (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendI32) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendI32_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendI32 (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendI64) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendI64_doc);
  MK_I64 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI8 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendI64 (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendI8) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendI8_doc);
  MK_I8 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI1 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendI8 (hdl, (MK_I8)(val)));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendLONG) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendLONG_doc);
  MK_LONG val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIL (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendLONG (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendLTR) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendLTR_doc);
  MQ_LTR transLId = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (transLId))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendLTR (hdl, transLId));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendL_FLAT) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendL_FLAT_doc);
  MkBufferListCreateTLS_T(val,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendL_FLAT (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendSTR) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendSTR_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendSTR (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendStringR) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SendStringR_doc);
  MkStringR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkStringR(val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendStringR (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_SendApi_Atom_PY_API
 
 
// doc-key: MqContextC,MqContextC-SendApi-Basics,om_
 
static OT_ProcRet NS(MqContextC_SendEND) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,SendEND_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND (hdl, token, timeout));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendEND_AND_CALLBACK) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,3,SendEND_AND_CALLBACK_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_REQUIRED(OT_CHECK_CALLABLE(callback))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND_AND_CALLBACK (hdl, token, NS(ServiceCall), callback, NS(ServiceFree), timeout));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendEND_AND_SUB) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,3,SendEND_AND_SUB_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_REQUIRED(OT_CHECK_CALLABLE(callback))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND_AND_SUB (hdl, token, NS(ServiceCall), callback, NS(ServiceFree), timeout));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendEND_AND_TRANSACTION) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,3,SendEND_AND_TRANSACTION_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MQ_TOK callback = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (callback))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND_AND_TRANSACTION (hdl, token, callback, timeout));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendEND_AND_WAIT) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,SendEND_AND_WAIT_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MK_TIME_T timeout = MK_TIMEOUT_DEFAULT;
  OT_CHECK_OPTIONAL(OT_CHECK_TIME_T (timeout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendEND_AND_WAIT (hdl, token, timeout));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendSTART) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendSTART_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendSTART (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendSYNC) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendSYNC_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendSYNC (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_SendApi_Basics_PY_API
 
 
// doc-key: MqContextC,MqContextC-SendApi-Block,om_
 
static OT_ProcRet NS(MqContextC_SendL_END) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendL_END_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendL_END (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendL_START) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendL_START_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendL_START (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendT_END) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendT_END_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendT_END (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendT_START) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendT_START_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendT_START (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_SendApi_Block_PY_API
 
 
// doc-key: MqContextC,MqContextC-SendApi-Return,om_
 
static OT_ProcRet NS(MqContextC_SendERROR) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendERROR_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendERROR (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendRETURN) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendRETURN_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendRETURN (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SendRETURN_SUB) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SendRETURN_SUB_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSendRETURN_SUB (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_SendApi_Return_PY_API
 
 
// doc-key: MqContextC,MqContextC-ServiceApi-Service,om_
 
static OT_ProcRet NS(MqContextC_ServiceCreate) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,ServiceCreate_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_SETUP_CALLABLE(callback)
  OT_CHECK_REQUIRED(OT_CHECK_CALLABLE(callback))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqServiceCreate (hdl, token, NS(ServiceCall), callback, NS(ServiceFree), NULL));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_CLEANUP_CALLABLE(callback)
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceDelete) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ServiceDelete_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqServiceDelete (hdl, token));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceIsTransaction) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ServiceIsTransaction_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqServiceIsTransaction (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceProxy) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,ServiceProxy_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MQ_SLAVE_ID id = MQ_SLAVE_OTHER;
  OT_CHECK_OPTIONAL(OT_CHECK_SLAVE_ID (id))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqServiceProxy (hdl, token, id));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceProxyCtx) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,ServiceProxyCtx_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MQ_CTX target = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CTX (target,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqServiceProxyCtx (hdl, token, target));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceProxyCtxExists) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,ServiceProxyCtxExists_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MQ_CTX target = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CTX (target,MK_NULL_NO))
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqServiceProxyCtxExists (hdl, token, target));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceProxyRoundRobin) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,ServiceProxyRoundRobin_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  MK_STRN ident = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (ident))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqServiceProxyRoundRobin (hdl, token, ident));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceStorage) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ServiceStorage_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqServiceStorage (hdl, token));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceTokenCheck) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ServiceTokenCheck_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqServiceTokenCheck (hdl, token));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceTokenExists) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(ServiceTokenExists_doc);
  MQ_TOK token = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (token))
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqServiceTokenExists (hdl, token));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_ServiceTokenGet) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ServiceTokenGet_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MqServiceTokenGet (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_ServiceApi_Service_PY_API
 
 
// doc-key: MqContextC,MqContextC-SlaveApi-Slave,oc_
 
static OT_ProcRet NS(MqContextC_SlaveGetMaster) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SlaveGetMaster_doc);
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqSlaveGetMaster (hdl);
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-SlaveApi-Slave,oco
 
static OT_ProcRet NS(MqContextC_SlaveGet) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SlaveGet_doc);
  MQ_SLAVE_ID id = 0;
  OT_CHECK_REQUIRED(OT_CHECK_SLAVE_ID (id))
  OT_CHECK_NOARGS;
  MQ_CTX ctx_out;
  MkErrorC_Check(hdl,MqSlaveGet (hdl, id, &ctx_out));
  OT_retObj_SET_CTX(ctx_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SlaveGetFilter) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SlaveGetFilter_doc);
  OT_CHECK_NOARGS;
  MQ_CTX ctx_out;
  MkErrorC_Check(hdl,MqSlaveGetFilter (hdl, &ctx_out));
  OT_retObj_SET_CTX(ctx_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SlaveGetProxy) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SlaveGetProxy_doc);
  MQ_SLAVE_ID id = 0;
  OT_CHECK_REQUIRED(OT_CHECK_SLAVE_ID (id))
  OT_CHECK_NOARGS;
  MQ_CTX ctx_out;
  MkErrorC_Check(hdl,MqSlaveGetProxy (hdl, id, &ctx_out));
  OT_retObj_SET_CTX(ctx_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-SlaveApi-Slave,om_
 
static OT_ProcRet NS(MqContextC_SlaveCheck) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SlaveCheck_doc);
  MQ_SLAVE_ID id = 0;
  OT_CHECK_REQUIRED(OT_CHECK_SLAVE_ID (id))
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqSlaveCheck (hdl, id));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SlaveCreate) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,SlaveCreate_doc);
  MQ_SLAVE_ID id = 0;
  OT_CHECK_REQUIRED(OT_CHECK_SLAVE_ID (id))
  MQ_CTX slave = 0;
  OT_CHECK_REQUIRED(OT_CHECK_CTX (slave,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSlaveCreate (hdl, id, slave));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SlaveDelete) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SlaveDelete_doc);
  MQ_SLAVE_ID id = 0;
  OT_CHECK_REQUIRED(OT_CHECK_SLAVE_ID (id))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSlaveDelete (hdl, id));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SlaveIs) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(SlaveIs_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MqSlaveIs (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_SlaveWorker) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,99,SlaveWorker_doc);
  MQ_SLAVE_ID id = 0;
  OT_CHECK_REQUIRED(OT_CHECK_SLAVE_ID (id))
  MK_STRN fct = "WORKER";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (fct))
  MkBufferListCreateTLS_T(args,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BAC (args))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqSlaveWorker (hdl, id, fct, args));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_SlaveApi_Slave_PY_API
 
 
// doc-key: MqContextC,MqContextC-StorageApi-Storage,oci
 
static OT_ProcRet NS(MqContextC_StorageDelete) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,StorageDelete_doc);
  MQ_LTR transLIdP_inout = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (transLIdP_inout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqStorageDelete (hdl, &transLIdP_inout));
  OT_retObj_SET_I32(transLIdP_inout);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_StorageImport) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,StorageImport_doc);
  MQ_LTR transLIdP_inout = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (transLIdP_inout))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqStorageImport (hdl, &transLIdP_inout));
  OT_retObj_SET_I32(transLIdP_inout);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-StorageApi-Storage,om_
 
static OT_ProcRet NS(MqContextC_StorageClose) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(StorageClose_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqStorageClose (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_StorageDecrRef) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(StorageDecrRef_doc);
  MQ_LTR transLId = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (transLId))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqStorageDecrRef (hdl, transLId));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_StorageIncrRef) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(StorageIncrRef_doc);
  MQ_LTR transLId = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (transLId))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqStorageIncrRef (hdl, transLId));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_StorageLog) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,StorageLog_doc);
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkErrorC_Check(hdl,MqStorageLog (hdl, callfunc));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_StorageOpen) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(StorageOpen_doc);
  MK_STRN storageFile = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (storageFile))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MqStorageOpen (hdl, storageFile));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MqContextC,MqContextC-StorageApi-Storage,omo
 
static OT_ProcRet NS(MqContextC_StorageCount) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(StorageCount_doc);
  OT_CHECK_NOARGS;
  MQ_LTR cnt_out;
  MkErrorC_Check(hdl,MqStorageCount (hdl, &cnt_out));
  OT_retObj_SET_I32(cnt_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_StorageErrCnt) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(StorageErrCnt_doc);
  MQ_LTR transLId = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (transLId))
  OT_CHECK_NOARGS;
  MK_I32 cnt_out;
  MkErrorC_Check(hdl,MqStorageErrCnt (hdl, transLId, &cnt_out));
  OT_retObj_SET_I32(cnt_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_StorageExport) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(StorageExport_doc);
  OT_CHECK_NOARGS;
  MQ_LTR ltid_out;
  MkErrorC_Check(hdl,MqStorageExport (hdl, &ltid_out));
  OT_retObj_SET_I32(ltid_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_StorageResolve) (MqContextC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(StorageResolve_doc);
  OT_CHECK_NOARGS;
  MQ_CTX otherCtxP_out;
  MQ_LTR otherLIdP_out;
  MkErrorC_Check(hdl,MqStorageResolve (hdl, &otherCtxP_out, &otherLIdP_out));
  OT_retObj_SET_List;
  OT_retObj_APPEND(OT_TMP_CTX_OBJ(otherCtxP_out));
  OT_retObj_APPEND(OT_TMP_I32_OBJ(otherLIdP_out));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_StorageApi_Storage_PY_API
 
 
// doc-key: MqContextC,MqContextC-TOR,sCc
 
static OT_ProcRet NS(MqContextC_Create) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create_doc);
  MQ_CTX tmpl = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_CTX (tmpl,MK_NULL_YES))
  OT_CHECK_NOARGS;
  MQ_CTX retVal = MqContextCreate (MqContextCTT, tmpl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqContextC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_CTX(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MqContextC_new) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(0,1,new_doc);
  MQ_CTX tmpl = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_CTX (tmpl,MK_NULL_YES))
  MQ_CTX retVal = MqContextCreate (MqContextCTT, tmpl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MqContextC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MqContextC_TOR_PY_API
 
// END-MqContextC - created by 'py_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
// vim: Marker(o)
 
static PyMethodDef NS(MqContextC_Methods)[] = {
 
    { "Debug",                     (PyCFunction) NS(MqContextC_Debug),                 METH_VARARGS,             "debugging…" },
    { "Debug2",                    (PyCFunction) NS(MqContextC_Debug2),                METH_VARARGS,             "debugging…" },
    { "ReadLIST",                  (PyCFunction) NS(MqContextC_ReadLIST),              METH_NOARGS,              "read entire list…" },
 
    // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
    // doc-key: MqContextC,MqContext,sCc
    { "Create"                  , (PyCFunction) NS(MqContextC_Create)                  , METH_VARARGS|METH_CLASS , Create_doc },
 
    // doc-key: MqContextC,MqContext,sc_
    { "GetNull"                 , (PyCFunction) NS(MqContextC_GetNull)                 , METH_NOARGS|METH_CLASS  , GetNull_doc },
    { "HandleResolve"           , (PyCFunction) NS(MqContextC_HandleResolve)           , METH_O|METH_CLASS       , HandleResolve_doc },
    { "Instances"               , (PyCFunction) NS(MqContextC_Instances)               , METH_NOARGS|METH_CLASS  , Instances_doc },
 
    // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
    // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
    // doc-key: MqContextC,MqClass,oc_
    { "ClassFactoryGet"         , (PyCFunction) NS(MqContextC_ClassFactoryGet)         , METH_NOARGS             , ClassFactoryGet_doc },
 
    // doc-key: MqContextC,MqClass,om_
    { "ClassFactorySet"         , (PyCFunction) NS(MqContextC_ClassFactorySet)         , METH_O                  , ClassFactorySet_doc },
    { "ClassIdentGet"           , (PyCFunction) NS(MqContextC_ClassIdentGet)           , METH_NOARGS             , ClassIdentGet_doc },
    { "ClassIdentSet"           , (PyCFunction) NS(MqContextC_ClassIdentSet)           , METH_O                  , ClassIdentSet_doc },
    { "ClassOriginalIdentGet"   , (PyCFunction) NS(MqContextC_ClassOriginalIdentGet)   , METH_NOARGS             , ClassOriginalIdentGet_doc },
 
    // doc-key: MqContextC,MqConfig,oco
    { "ConfigGetIoTcpL"         , (PyCFunction) NS(MqContextC_ConfigGetIoTcpL)         , METH_NOARGS             , ConfigGetIoTcpL_doc },
 
    // doc-key: MqContextC,MqConfig,om_
    { "ConfigCheckStartAs"      , (PyCFunction) NS(MqContextC_ConfigCheckStartAs)      , METH_O                  , ConfigCheckStartAs_doc },
    { "ConfigGetBuffersize"     , (PyCFunction) NS(MqContextC_ConfigGetBuffersize)     , METH_NOARGS             , ConfigGetBuffersize_doc },
    { "ConfigGetIdentFrom"      , (PyCFunction) NS(MqContextC_ConfigGetIdentFrom)      , METH_NOARGS             , ConfigGetIdentFrom_doc },
    { "ConfigGetIoPipe"         , (PyCFunction) NS(MqContextC_ConfigGetIoPipe)         , METH_NOARGS             , ConfigGetIoPipe_doc },
    { "ConfigGetIoUds"          , (PyCFunction) NS(MqContextC_ConfigGetIoUds)          , METH_NOARGS             , ConfigGetIoUds_doc },
    { "ConfigGetIsParent"       , (PyCFunction) NS(MqContextC_ConfigGetIsParent)       , METH_NOARGS             , ConfigGetIsParent_doc },
    { "ConfigGetIsServer"       , (PyCFunction) NS(MqContextC_ConfigGetIsServer)       , METH_NOARGS             , ConfigGetIsServer_doc },
    { "ConfigGetIsString"       , (PyCFunction) NS(MqContextC_ConfigGetIsString)       , METH_NOARGS             , ConfigGetIsString_doc },
    { "ConfigGetName"           , (PyCFunction) NS(MqContextC_ConfigGetName)           , METH_NOARGS             , ConfigGetName_doc },
    { "ConfigGetPkgsize"        , (PyCFunction) NS(MqContextC_ConfigGetPkgsize)        , METH_NOARGS             , ConfigGetPkgsize_doc },
    { "ConfigGetPostfix"        , (PyCFunction) NS(MqContextC_ConfigGetPostfix)        , METH_NOARGS             , ConfigGetPostfix_doc },
    { "ConfigGetPrefix"         , (PyCFunction) NS(MqContextC_ConfigGetPrefix)         , METH_NOARGS             , ConfigGetPrefix_doc },
    { "ConfigGetStartAs"        , (PyCFunction) NS(MqContextC_ConfigGetStartAs)        , METH_NOARGS             , ConfigGetStartAs_doc },
    { "ConfigGetStatusIs"       , (PyCFunction) NS(MqContextC_ConfigGetStatusIs)       , METH_NOARGS             , ConfigGetStatusIs_doc },
    { "ConfigGetStorage"        , (PyCFunction) NS(MqContextC_ConfigGetStorage)        , METH_NOARGS             , ConfigGetStorage_doc },
    { "ConfigGetTimeout"        , (PyCFunction) NS(MqContextC_ConfigGetTimeout)        , METH_NOARGS             , ConfigGetTimeout_doc },
    { "ConfigReset"             , (PyCFunction) NS(MqContextC_ConfigReset)             , METH_NOARGS             , ConfigReset_doc },
    { "ConfigSetAllDebug"       , (PyCFunction) NS(MqContextC_ConfigSetAllDebug)       , METH_O                  , ConfigSetAllDebug_doc },
    { "ConfigSetBgError"        , (PyCFunction) NS(MqContextC_ConfigSetBgError)        , METH_VARARGS            , ConfigSetBgError_doc },
    { "ConfigSetBuffersize"     , (PyCFunction) NS(MqContextC_ConfigSetBuffersize)     , METH_O                  , ConfigSetBuffersize_doc },
    { "ConfigSetConfigFile"     , (PyCFunction) NS(MqContextC_ConfigSetConfigFile)     , METH_O                  , ConfigSetConfigFile_doc },
    { "ConfigSetDaemon"         , (PyCFunction) NS(MqContextC_ConfigSetDaemon)         , METH_O                  , ConfigSetDaemon_doc },
    { "ConfigSetEvent"          , (PyCFunction) NS(MqContextC_ConfigSetEvent)          , METH_VARARGS            , ConfigSetEvent_doc },
    { "ConfigSetIdentFrom"      , (PyCFunction) NS(MqContextC_ConfigSetIdentFrom)      , METH_O                  , ConfigSetIdentFrom_doc },
    { "ConfigSetIgnoreExit"     , (PyCFunction) NS(MqContextC_ConfigSetIgnoreExit)     , METH_O                  , ConfigSetIgnoreExit_doc },
    { "ConfigSetIoPipe"         , (PyCFunction) NS(MqContextC_ConfigSetIoPipe)         , METH_O                  , ConfigSetIoPipe_doc },
    { "ConfigSetIoTcp"          , (PyCFunction) NS(MqContextC_ConfigSetIoTcp)          , METH_VARARGS            , ConfigSetIoTcp_doc },
    { "ConfigSetIoTcpL"         , (PyCFunction) NS(MqContextC_ConfigSetIoTcpL)         , METH_O                  , ConfigSetIoTcpL_doc },
    { "ConfigSetIoUds"          , (PyCFunction) NS(MqContextC_ConfigSetIoUds)          , METH_O                  , ConfigSetIoUds_doc },
    { "ConfigSetIsServer"       , (PyCFunction) NS(MqContextC_ConfigSetIsServer)       , METH_O                  , ConfigSetIsServer_doc },
    { "ConfigSetIsString"       , (PyCFunction) NS(MqContextC_ConfigSetIsString)       , METH_O                  , ConfigSetIsString_doc },
    { "ConfigSetName"           , (PyCFunction) NS(MqContextC_ConfigSetName)           , METH_O                  , ConfigSetName_doc },
    { "ConfigSetPkgsize"        , (PyCFunction) NS(MqContextC_ConfigSetPkgsize)        , METH_O                  , ConfigSetPkgsize_doc },
    { "ConfigSetPostfix"        , (PyCFunction) NS(MqContextC_ConfigSetPostfix)        , METH_O                  , ConfigSetPostfix_doc },
    { "ConfigSetPrefix"         , (PyCFunction) NS(MqContextC_ConfigSetPrefix)         , METH_O                  , ConfigSetPrefix_doc },
    { "ConfigSetServerCleanup"  , (PyCFunction) NS(MqContextC_ConfigSetServerCleanup)  , METH_VARARGS            , ConfigSetServerCleanup_doc },
    { "ConfigSetServerSetup"    , (PyCFunction) NS(MqContextC_ConfigSetServerSetup)    , METH_VARARGS            , ConfigSetServerSetup_doc },
    { "ConfigSetStartAs"        , (PyCFunction) NS(MqContextC_ConfigSetStartAs)        , METH_O                  , ConfigSetStartAs_doc },
    { "ConfigSetStartAsString"  , (PyCFunction) NS(MqContextC_ConfigSetStartAsString)  , METH_O                  , ConfigSetStartAsString_doc },
    { "ConfigSetStorage"        , (PyCFunction) NS(MqContextC_ConfigSetStorage)        , METH_O                  , ConfigSetStorage_doc },
    { "ConfigSetTimeout"        , (PyCFunction) NS(MqContextC_ConfigSetTimeout)        , METH_O                  , ConfigSetTimeout_doc },
 
    // doc-key: MqContextC,MqConfig,omo
    { "ConfigGetIoTcp"          , (PyCFunction) NS(MqContextC_ConfigGetIoTcp)          , METH_NOARGS             , ConfigGetIoTcp_doc },
 
    // doc-key: MqContextC,MqContext,oc_
    { "ErrorFORMAT"             , (PyCFunction) NS(MqContextC_ErrorFORMAT)             , METH_NOARGS             , ErrorFORMAT_doc },
    { "GetBuffer"               , (PyCFunction) NS(MqContextC_GetBuffer)               , METH_NOARGS             , GetBuffer_doc },
    { "Next"                    , (PyCFunction) NS(MqContextC_Next)                    , METH_NOARGS             , Next_doc },
    { "Prev"                    , (PyCFunction) NS(MqContextC_Prev)                    , METH_NOARGS             , Prev_doc },
 
    // doc-key: MqContextC,MqContext,om_
    { "ErrorCopy"               , (PyCFunction) NS(MqContextC_ErrorCopy)               , METH_O                  , ErrorCopy_doc },
    { "ErrorMove"               , (PyCFunction) NS(MqContextC_ErrorMove)               , METH_O                  , ErrorMove_doc },
    // skip class-overload: MqContextHandleGet → HandleGet, NS(MqContextC_HandleGet)
    // skip class-overload: MqContextLog → Log, NS(MqContextC_Log)
    { "LogConfig"               , (PyCFunction) NS(MqContextC_LogConfig)               , METH_VARARGS            , LogConfig_doc },
    { "LogEnv"                  , (PyCFunction) NS(MqContextC_LogEnv)                  , METH_VARARGS            , LogEnv_doc },
    { "LogLink"                 , (PyCFunction) NS(MqContextC_LogLink)                 , METH_VARARGS            , LogLink_doc },
    { "LogSetup"                , (PyCFunction) NS(MqContextC_LogSetup)                , METH_VARARGS            , LogSetup_doc },
    { "LogShort"                , (PyCFunction) NS(MqContextC_LogShort)                , METH_VARARGS            , LogShort_doc },
    { "LogType"                 , (PyCFunction) NS(MqContextC_LogType)                 , METH_VARARGS            , LogType_doc },
    // skip class-overload: MqContextToString → ToString, NS(MqContextC_ToString)
 
    // doc-key: MqContextC,MqEnv,om_
    { "EnvProtect"              , (PyCFunction) NS(MqContextC_EnvProtect)              , METH_NOARGS             , EnvProtect_doc },
    { "EnvRestore"              , (PyCFunction) NS(MqContextC_EnvRestore)              , METH_NOARGS             , EnvRestore_doc },
 
    // doc-key: MqContextC,MqExit,om_
    { "Exit"                    , (PyCFunction) NS(MqContextC_Exit)                    , METH_VARARGS            , Exit_doc },
 
    // doc-key: MqContextC,MqGet,oc_
    { "GetRoot"                 , (PyCFunction) NS(MqContextC_GetRoot)                 , METH_NOARGS             , GetRoot_doc },
 
    // doc-key: MqContextC,MqLink,oc_
    { "LinkGetParent"           , (PyCFunction) NS(MqContextC_LinkGetParent)           , METH_NOARGS             , LinkGetParent_doc },
 
    // doc-key: MqContextC,MqLink,om_
    { "LinkConnect"             , (PyCFunction) NS(MqContextC_LinkConnect)             , METH_NOARGS             , LinkConnect_doc },
    { "LinkCreate"              , (PyCFunction) NS(MqContextC_LinkCreate)              , METH_VARARGS            , LinkCreate_doc },
    { "LinkCreateChild"         , (PyCFunction) NS(MqContextC_LinkCreateChild)         , METH_VARARGS            , LinkCreateChild_doc },
    { "LinkDelete"              , (PyCFunction) NS(MqContextC_LinkDelete)              , METH_NOARGS             , LinkDelete_doc },
    { "LinkGetCtxId"            , (PyCFunction) NS(MqContextC_LinkGetCtxId)            , METH_NOARGS             , LinkGetCtxId_doc },
    { "LinkGetTargetIdent"      , (PyCFunction) NS(MqContextC_LinkGetTargetIdent)      , METH_NOARGS             , LinkGetTargetIdent_doc },
    { "LinkIsConnected"         , (PyCFunction) NS(MqContextC_LinkIsConnected)         , METH_NOARGS             , LinkIsConnected_doc },
    { "LinkIsParent"            , (PyCFunction) NS(MqContextC_LinkIsParent)            , METH_NOARGS             , LinkIsParent_doc },
    { "LinkShutdown"            , (PyCFunction) NS(MqContextC_LinkShutdown)            , METH_NOARGS             , LinkShutdown_doc },
 
    // doc-key: MqContextC,MqLog,om_
    { "LogParentOrChild"        , (PyCFunction) NS(MqContextC_LogParentOrChild)        , METH_NOARGS             , LogParentOrChild_doc },
    { "LogServerOrClient"       , (PyCFunction) NS(MqContextC_LogServerOrClient)       , METH_NOARGS             , LogServerOrClient_doc },
 
    // doc-key: MqContextC,MqProcess,om_
    { "ProcessEvent"            , (PyCFunction) NS(MqContextC_ProcessEvent)            , METH_VARARGS            , ProcessEvent_doc },
 
    // doc-key: MqContextC,MqProxy,om_
    { "ProxyForward"            , (PyCFunction) NS(MqContextC_ProxyForward)            , METH_VARARGS            , ProxyForward_doc },
    { "ProxyItem"               , (PyCFunction) NS(MqContextC_ProxyItem)               , METH_O                  , ProxyItem_doc },
 
    // doc-key: MqContextC,MqRead,oci
    { "ReadALL"                 , (PyCFunction) NS(MqContextC_ReadALL)                 , METH_VARARGS            , ReadALL_doc },
 
    // doc-key: MqContextC,MqRead,oco
    { "ReadBFL"                 , (PyCFunction) NS(MqContextC_ReadBFL)                 , METH_NOARGS             , ReadBFL_doc },
    { "ReadBUF"                 , (PyCFunction) NS(MqContextC_ReadBUF)                 , METH_NOARGS             , ReadBUF_doc },
 
    // doc-key: MqContextC,MqRead,om_
    { "ReadDbg"                 , (PyCFunction) NS(MqContextC_ReadDbg)                 , METH_NOARGS             , ReadDbg_doc },
    { "ReadGetNextType"         , (PyCFunction) NS(MqContextC_ReadGetNextType)         , METH_NOARGS             , ReadGetNextType_doc },
    { "ReadGetNumItems"         , (PyCFunction) NS(MqContextC_ReadGetNumItems)         , METH_NOARGS             , ReadGetNumItems_doc },
    { "ReadItemExists"          , (PyCFunction) NS(MqContextC_ReadItemExists)          , METH_NOARGS             , ReadItemExists_doc },
    { "ReadL_END"               , (PyCFunction) NS(MqContextC_ReadL_END)               , METH_NOARGS             , ReadL_END_doc },
    { "ReadL_START"             , (PyCFunction) NS(MqContextC_ReadL_START)             , METH_VARARGS            , ReadL_START_doc },
    { "ReadT_END"               , (PyCFunction) NS(MqContextC_ReadT_END)               , METH_NOARGS             , ReadT_END_doc },
    { "ReadT_START"             , (PyCFunction) NS(MqContextC_ReadT_START)             , METH_NOARGS             , ReadT_START_doc },
    { "ReadUndo"                , (PyCFunction) NS(MqContextC_ReadUndo)                , METH_NOARGS             , ReadUndo_doc },
 
    // doc-key: MqContextC,MqRead,omo
    { "ReadBIN"                 , (PyCFunction) NS(MqContextC_ReadBIN)                 , METH_NOARGS             , ReadBIN_doc },
    { "ReadBOL"                 , (PyCFunction) NS(MqContextC_ReadBOL)                 , METH_NOARGS             , ReadBOL_doc },
    { "ReadBinaryR"             , (PyCFunction) NS(MqContextC_ReadBinaryR)             , METH_NOARGS             , ReadBinaryR_doc },
    { "ReadDBL"                 , (PyCFunction) NS(MqContextC_ReadDBL)                 , METH_NOARGS             , ReadDBL_doc },
    { "ReadFLT"                 , (PyCFunction) NS(MqContextC_ReadFLT)                 , METH_NOARGS             , ReadFLT_doc },
    { "ReadHDL"                 , (PyCFunction) NS(MqContextC_ReadHDL)                 , METH_NOARGS             , ReadHDL_doc },
    { "ReadI16"                 , (PyCFunction) NS(MqContextC_ReadI16)                 , METH_NOARGS             , ReadI16_doc },
    { "ReadI32"                 , (PyCFunction) NS(MqContextC_ReadI32)                 , METH_NOARGS             , ReadI32_doc },
    { "ReadI64"                 , (PyCFunction) NS(MqContextC_ReadI64)                 , METH_NOARGS             , ReadI64_doc },
    { "ReadI8"                  , (PyCFunction) NS(MqContextC_ReadI8)                  , METH_NOARGS             , ReadI8_doc },
    { "ReadLIST"                , (PyCFunction) NS(MqContextC_ReadLIST)                , METH_NOARGS             , ReadLIST_doc },
    { "ReadLONG"                , (PyCFunction) NS(MqContextC_ReadLONG)                , METH_NOARGS             , ReadLONG_doc },
    { "ReadNEXT"                , (PyCFunction) NS(MqContextC_ReadNEXT)                , METH_NOARGS             , ReadNEXT_doc },
    { "ReadSTR"                 , (PyCFunction) NS(MqContextC_ReadSTR)                 , METH_NOARGS             , ReadSTR_doc },
    { "ReadStringR"             , (PyCFunction) NS(MqContextC_ReadStringR)             , METH_NOARGS             , ReadStringR_doc },
 
    // doc-key: MqContextC,MqRoute,oco
    { "RouteGetTree"            , (PyCFunction) NS(MqContextC_RouteGetTree)            , METH_NOARGS             , RouteGetTree_doc },
 
    // doc-key: MqContextC,MqRoute,om_
    { "RouteCreate"             , (PyCFunction) NS(MqContextC_RouteCreate)             , METH_VARARGS            , RouteCreate_doc },
    { "RouteDelete"             , (PyCFunction) NS(MqContextC_RouteDelete)             , METH_VARARGS            , RouteDelete_doc },
    { "RouteResolve"            , (PyCFunction) NS(MqContextC_RouteResolve)            , METH_VARARGS            , RouteResolve_doc },
    { "RouteTraverse"           , (PyCFunction) NS(MqContextC_RouteTraverse)           , METH_VARARGS            , RouteTraverse_doc },
 
    // doc-key: MqContextC,MqRoute,omo
    { "RouteGetPath"            , (PyCFunction) NS(MqContextC_RouteGetPath)            , METH_NOARGS             , RouteGetPath_doc },
 
    // doc-key: MqContextC,MqSend,om_
    { "Send"                    , (PyCFunction) NS(MqContextC_Send)                    , METH_VARARGS            , Send_doc },
    { "SendBFL"                 , (PyCFunction) NS(MqContextC_SendBFL)                 , METH_O                  , SendBFL_doc },
    { "SendBIN"                 , (PyCFunction) NS(MqContextC_SendBIN)                 , METH_O                  , SendBIN_doc },
    { "SendBOL"                 , (PyCFunction) NS(MqContextC_SendBOL)                 , METH_O                  , SendBOL_doc },
    { "SendBUF"                 , (PyCFunction) NS(MqContextC_SendBUF)                 , METH_O                  , SendBUF_doc },
    { "SendBUS_FLAT"            , (PyCFunction) NS(MqContextC_SendBUS_FLAT)            , METH_O                  , SendBUS_FLAT_doc },
    { "SendBinaryR"             , (PyCFunction) NS(MqContextC_SendBinaryR)             , METH_O                  , SendBinaryR_doc },
    { "SendDBL"                 , (PyCFunction) NS(MqContextC_SendDBL)                 , METH_O                  , SendDBL_doc },
    { "SendEND"                 , (PyCFunction) NS(MqContextC_SendEND)                 , METH_VARARGS            , SendEND_doc },
    { "SendEND_AND_CALLBACK"    , (PyCFunction) NS(MqContextC_SendEND_AND_CALLBACK)    , METH_VARARGS            , SendEND_AND_CALLBACK_doc },
    { "SendEND_AND_SUB"         , (PyCFunction) NS(MqContextC_SendEND_AND_SUB)         , METH_VARARGS            , SendEND_AND_SUB_doc },
    { "SendEND_AND_TRANSACTION" , (PyCFunction) NS(MqContextC_SendEND_AND_TRANSACTION) , METH_VARARGS            , SendEND_AND_TRANSACTION_doc },
    { "SendEND_AND_WAIT"        , (PyCFunction) NS(MqContextC_SendEND_AND_WAIT)        , METH_VARARGS            , SendEND_AND_WAIT_doc },
    { "SendERROR"               , (PyCFunction) NS(MqContextC_SendERROR)               , METH_NOARGS             , SendERROR_doc },
    { "SendFLT"                 , (PyCFunction) NS(MqContextC_SendFLT)                 , METH_O                  , SendFLT_doc },
    { "SendHDL"                 , (PyCFunction) NS(MqContextC_SendHDL)                 , METH_O                  , SendHDL_doc },
    { "SendI16"                 , (PyCFunction) NS(MqContextC_SendI16)                 , METH_O                  , SendI16_doc },
    { "SendI32"                 , (PyCFunction) NS(MqContextC_SendI32)                 , METH_O                  , SendI32_doc },
    { "SendI64"                 , (PyCFunction) NS(MqContextC_SendI64)                 , METH_O                  , SendI64_doc },
    { "SendI8"                  , (PyCFunction) NS(MqContextC_SendI8)                  , METH_O                  , SendI8_doc },
    { "SendLONG"                , (PyCFunction) NS(MqContextC_SendLONG)                , METH_O                  , SendLONG_doc },
    { "SendLTR"                 , (PyCFunction) NS(MqContextC_SendLTR)                 , METH_O                  , SendLTR_doc },
    { "SendL_END"               , (PyCFunction) NS(MqContextC_SendL_END)               , METH_NOARGS             , SendL_END_doc },
    { "SendL_FLAT"              , (PyCFunction) NS(MqContextC_SendL_FLAT)              , METH_O                  , SendL_FLAT_doc },
    { "SendL_START"             , (PyCFunction) NS(MqContextC_SendL_START)             , METH_NOARGS             , SendL_START_doc },
    { "SendRETURN"              , (PyCFunction) NS(MqContextC_SendRETURN)              , METH_NOARGS             , SendRETURN_doc },
    { "SendRETURN_SUB"          , (PyCFunction) NS(MqContextC_SendRETURN_SUB)          , METH_NOARGS             , SendRETURN_SUB_doc },
    { "SendSTART"               , (PyCFunction) NS(MqContextC_SendSTART)               , METH_NOARGS             , SendSTART_doc },
    { "SendSTR"                 , (PyCFunction) NS(MqContextC_SendSTR)                 , METH_O                  , SendSTR_doc },
    { "SendSYNC"                , (PyCFunction) NS(MqContextC_SendSYNC)                , METH_NOARGS             , SendSYNC_doc },
    { "SendStringR"             , (PyCFunction) NS(MqContextC_SendStringR)             , METH_O                  , SendStringR_doc },
    { "SendT_END"               , (PyCFunction) NS(MqContextC_SendT_END)               , METH_NOARGS             , SendT_END_doc },
    { "SendT_START"             , (PyCFunction) NS(MqContextC_SendT_START)             , METH_NOARGS             , SendT_START_doc },
 
    // doc-key: MqContextC,MqService,om_
    { "ServiceCreate"           , (PyCFunction) NS(MqContextC_ServiceCreate)           , METH_VARARGS            , ServiceCreate_doc },
    { "ServiceDelete"           , (PyCFunction) NS(MqContextC_ServiceDelete)           , METH_O                  , ServiceDelete_doc },
    { "ServiceIsTransaction"    , (PyCFunction) NS(MqContextC_ServiceIsTransaction)    , METH_NOARGS             , ServiceIsTransaction_doc },
    { "ServiceProxy"            , (PyCFunction) NS(MqContextC_ServiceProxy)            , METH_VARARGS            , ServiceProxy_doc },
    { "ServiceProxyCtx"         , (PyCFunction) NS(MqContextC_ServiceProxyCtx)         , METH_VARARGS            , ServiceProxyCtx_doc },
    { "ServiceProxyCtxExists"   , (PyCFunction) NS(MqContextC_ServiceProxyCtxExists)   , METH_VARARGS            , ServiceProxyCtxExists_doc },
    { "ServiceProxyRoundRobin"  , (PyCFunction) NS(MqContextC_ServiceProxyRoundRobin)  , METH_VARARGS            , ServiceProxyRoundRobin_doc },
    { "ServiceStorage"          , (PyCFunction) NS(MqContextC_ServiceStorage)          , METH_O                  , ServiceStorage_doc },
    { "ServiceTokenCheck"       , (PyCFunction) NS(MqContextC_ServiceTokenCheck)       , METH_O                  , ServiceTokenCheck_doc },
    { "ServiceTokenExists"      , (PyCFunction) NS(MqContextC_ServiceTokenExists)      , METH_O                  , ServiceTokenExists_doc },
    { "ServiceTokenGet"         , (PyCFunction) NS(MqContextC_ServiceTokenGet)         , METH_NOARGS             , ServiceTokenGet_doc },
 
    // doc-key: MqContextC,MqSlave,oc_
    { "SlaveGetMaster"          , (PyCFunction) NS(MqContextC_SlaveGetMaster)          , METH_NOARGS             , SlaveGetMaster_doc },
 
    // doc-key: MqContextC,MqSlave,oco
    { "SlaveGet"                , (PyCFunction) NS(MqContextC_SlaveGet)                , METH_O                  , SlaveGet_doc },
    { "SlaveGetFilter"          , (PyCFunction) NS(MqContextC_SlaveGetFilter)          , METH_NOARGS             , SlaveGetFilter_doc },
    { "SlaveGetProxy"           , (PyCFunction) NS(MqContextC_SlaveGetProxy)           , METH_O                  , SlaveGetProxy_doc },
 
    // doc-key: MqContextC,MqSlave,om_
    { "SlaveCheck"              , (PyCFunction) NS(MqContextC_SlaveCheck)              , METH_O                  , SlaveCheck_doc },
    { "SlaveCreate"             , (PyCFunction) NS(MqContextC_SlaveCreate)             , METH_VARARGS            , SlaveCreate_doc },
    { "SlaveDelete"             , (PyCFunction) NS(MqContextC_SlaveDelete)             , METH_O                  , SlaveDelete_doc },
    { "SlaveIs"                 , (PyCFunction) NS(MqContextC_SlaveIs)                 , METH_NOARGS             , SlaveIs_doc },
    { "SlaveWorker"             , (PyCFunction) NS(MqContextC_SlaveWorker)             , METH_VARARGS            , SlaveWorker_doc },
 
    // doc-key: MqContextC,MqStorage,oci
    { "StorageDelete"           , (PyCFunction) NS(MqContextC_StorageDelete)           , METH_VARARGS            , StorageDelete_doc },
    { "StorageImport"           , (PyCFunction) NS(MqContextC_StorageImport)           , METH_VARARGS            , StorageImport_doc },
 
    // doc-key: MqContextC,MqStorage,om_
    { "StorageClose"            , (PyCFunction) NS(MqContextC_StorageClose)            , METH_NOARGS             , StorageClose_doc },
    { "StorageDecrRef"          , (PyCFunction) NS(MqContextC_StorageDecrRef)          , METH_O                  , StorageDecrRef_doc },
    { "StorageIncrRef"          , (PyCFunction) NS(MqContextC_StorageIncrRef)          , METH_O                  , StorageIncrRef_doc },
    { "StorageLog"              , (PyCFunction) NS(MqContextC_StorageLog)              , METH_VARARGS            , StorageLog_doc },
    { "StorageOpen"             , (PyCFunction) NS(MqContextC_StorageOpen)             , METH_O                  , StorageOpen_doc },
 
    // doc-key: MqContextC,MqStorage,omo
    { "StorageCount"            , (PyCFunction) NS(MqContextC_StorageCount)            , METH_NOARGS             , StorageCount_doc },
    { "StorageErrCnt"           , (PyCFunction) NS(MqContextC_StorageErrCnt)           , METH_O                  , StorageErrCnt_doc },
    { "StorageExport"           , (PyCFunction) NS(MqContextC_StorageExport)           , METH_NOARGS             , StorageExport_doc },
    { "StorageResolve"          , (PyCFunction) NS(MqContextC_StorageResolve)          , METH_NOARGS             , StorageResolve_doc },
 
    // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
MK_UNUSED static void NS(sParentBeforeFork)(MQ_CTX mqctx) {
  PyOS_BeforeFork();
}
 
MK_UNUSED static void NS(sParentAfterFork)(MQ_CTX mqctx) {
  PyOS_AfterFork_Parent();
}
 
MK_UNUSED static void NS(sChildAfterFork)(MQ_CTX mqctx) {
  PyOS_AfterFork_Child();
}
 
// new objects are in "local-scope" at python… if an object was added with "SlaveCreate"
// the underlying "context" will disappear after leving the "local-scope"
static void NS(sIncrSelf)(MK_RT_ARGS MQ_CTX hdl, MK_PTR const env) {
  OT_SETUP_self
  Py_INCREF(self);
}
 
static void NS(sDecrSelf)(MK_RT_ARGS MQ_CTX hdl, MK_PTR const env) {
  OT_OBJ_T self = OT_SELF_X(hdl);
  Py_CLEAR(self);
}
 
static int NS(sProcessExit) (MK_RT_ARGS int num) {
//MqDLogX(context,__func__,0,"self<%p>, refCount<%li>\n", context->obj.self, ((PyObject*)context->obj.self)->ob_refcnt);
  Py_Exit(num);
  return num;
}
 
MK_UNUSED static int NS(sThreadExit) (MK_RT_ARGS int num) {
//MqDLogX(context,__func__,0,"self<%p>, refCount<%li>\n", context->obj.self, ((PyObject*)context->obj.self)->ob_refcnt);
 
//mk_dbg_color_ln(MK_COLOR_RED,"%s, current state<%p>, rt state<%p>", "thread EXIT", PyThreadState_Get(), MK_RT_REF.mkThreadData);
 
  Py_EndInterpreter(MK_RT_REF.mkThreadData.ptr);
 
  MK_RT_REF.mkThreadData.ptr = NULL;
 
  return num;
}
 
static PyObject* NS(sMqContextC_Str) (MqContextC_Obj *self) {
  MkRtSetup_X(self->hdl);
  return STRN2VAL(MkSysPrintF("MqContextC[%s]", self->hdl ? MqConfigGetName(self->hdl) : NULL));
}
 
static PyObject *NS(sMqContextC_Repr)(MqContextC_Obj* self)
{
  OT_SETUP_hdl
  return PyUnicode_FromFormat("%s={nm:%s|sf:%p|rf:%i|cx:%p}",Py_TYPE(self)->tp_name,MqConfigGetName(hdl),self,Py_REFCNT(self)-1,hdl);
error:
  return NULL;
}
 
#define MqContextC_Doc  "The pymqmsgque project is an infrastructure to link software together to\n\
act like a single software. To link mean distributing work from one\n\
software to an other software an wait or not wait for an answer. The\n\
linking is done using unix or inet domain sockets and is based on\n\
packages send from one software to an other software and back. The\n\
pymqmsgque project is used to handle all the different aspects for setup\n\
and maintain the link and is responsible for:\n\
\n\
o starting and stopping the server application\n\
o starting and stopping the communication interface\n\
o sending and receiving package data\n\
o reading and writing data from or into a package\n\
o setup and maintain the event-handling for an asynchronous transfer\n\
o propagate the error messages from the server to the client"
 
 
OT_CLASS_TYPE_REF NS(MqContextCR) = {
  PyVarObject_HEAD_INIT(NULL, 0)
  .tp_name        = "pymqmsgque.MqContextC",
  .tp_basicsize   = sizeof(MqContextC_Obj),
  .tp_itemsize    = 0,
  .tp_new         = (newfunc)     NS(MqContextC_new),
  .tp_doc         = MqContextC_Doc,
  .tp_methods     = NS(MqContextC_Methods),
  .tp_str         = (reprfunc)    NS(sMqContextC_Str),
  .tp_repr        = (reprfunc)    NS(sMqContextC_Repr),
  .tp_flags       = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
  .tp_base        = NULL
};
 
int
NS(pMqContextC_Init)(MK_RT_ARGS OT_OBJ_T m) {
  MQ_STATIC_RT;
 
  // define type
  MqContextCTT = MkTypeDup2(MqContextC_TT,"PyMqContextC");
  MqContextCT->fIncrSelf = NS(sIncrSelf);
  MqContextCT->fDecrSelf = NS(sDecrSelf);
//  >> replaced by os_fork
//  MqContextCT->fParentBeforeFork = NS(sParentBeforeFork);
//  MqContextCT->fParentAfterFork = NS(sParentAfterFork);
//  MqContextCT->fChildAfterFork = NS(sChildAfterFork);
  MqContextCT->MqProcessExitCB = NS(sProcessExit);
  MqContextCT->MqThreadExitCB = NS(sThreadExit);
  //MqContextCT->ignoreDisasterSetup = true;
  MqContextCT->ignoreThread = true;
 
  ClassInit
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap