MqContextC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
#include "MqCall_cc.hh"
 
namespace ccmqmsgque {
 
/*
  inline MK_PTR MqContextC::MqContextC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
    return new MqContextC(obj);
  }
*/
 
  inline void MqContextC::SlaveWorker (const MQ_SLAVE_ID id, MK_STRN fct, const MkBufferListC& args) {
    MK_BAC args_hdl = MkBufferListC::getBFL(args);
    MkRtSetup_XN(args_hdl);
    enum MkErrorE errVal = MqSlaveWorker (reinterpret_cast<MQ_CTX>(hdl), id, fct, args_hdl);
    ErrorCheck(errVal);
  }
 
  //   BEGIN-MqContextC - created by 'cc_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
  // doc-key: MqContextC,MqContextC-Class-Export,sc_
 
  inline MqContextC* MqContextC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    MQ_CTX __retVal__L = MqContextHandleResolve(netHdl);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MqContextC,MqContextC-Class-Export,om_
 
  // skip class-overload: HandleGet = MqContextHandleGet → MkObjectHandleGet
 
  // MqContextC_Class_CC_API
 
 
  // doc-key: MqContextC,MqContextC-Class-Introspection,oc_
 
  inline MqContextC* MqContextC::Next ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX __retVal__L = MqContextNext(ctx);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MqContextC* MqContextC::Prev ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX __retVal__L = MqContextPrev(ctx);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MqContextC,MqContextC-Class-Introspection,sc_
 
  inline MqContextC* MqContextC::Instances ()  {
    MkRtSetup_NULL;
    MQ_CTX __retVal__L = MqContextInstances();
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MqContextC_Class_CC_API
 
 
  // doc-key: MqContextC,MqContextC-Class-Misc,sc_
 
  inline MqContextC* MqContextC::GetNull ()  {
    MkRtSetup_NULL;
    MQ_CTX __retVal__L = MqContextGetNull();
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MqContextC_Class_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ClassApi-Class,oc_
 
  inline MqFactoryC* MqContextC::ClassFactoryGet () const {
    MK_UNUSED auto ctx = getCTXN();
    MQ_FCT __retVal__L = MqClassFactoryGet(ctx);
    return MqFactoryC::MqFactoryC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MqContextC,MqContextC-ClassApi-Class,om_
 
  inline void MqContextC::ClassFactorySet (MqFactoryC* item)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_FCT item_hdl = MqFactoryC::getFCT(item);
    enum MkErrorE errVal = MqClassFactorySet(ctx, item_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ClassFactorySet (const MqFactoryC& item)  {
    MK_UNUSED auto ctx = getCTX();
    const MQ_FCT item_hdl = MqFactoryC::getFCT(item);
    enum MkErrorE errVal = MqClassFactorySet(ctx, item_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline MK_STRN MqContextC::ClassIdentGet () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqClassIdentGet(ctx);
    return __retVal__L;
  }
 
  inline void MqContextC::ClassIdentSet (MK_STRN ident)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqClassIdentSet(ctx, ident);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ClassIdentSet (const std::string& ident)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN ident_hdl = ident.c_str();
    enum MkErrorE errVal = MqClassIdentSet(ctx, ident_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline MK_STRN MqContextC::ClassOriginalIdentGet () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqClassOriginalIdentGet(ctx);
    return __retVal__L;
  }
 
  // MqContextC_ClassApi_Class_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ConfigApi-Get,oco
 
  inline MkBufferListC* MqContextC::ConfigGetIoTcpL ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BFL vals_out;
    enum MkErrorE errVal = MqConfigGetIoTcpL(ctx, &vals_out);
    MkErrorC_Check(ctx, errVal);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL vals_out);
  }
 
  // doc-key: MqContextC,MqContextC-ConfigApi-Get,om_
 
  inline MK_I32 MqContextC::ConfigGetBuffersize () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_I32 __retVal__L = MqConfigGetBuffersize(ctx);
    return __retVal__L;
  }
 
  inline MqIdentE MqContextC::ConfigGetIdentFrom ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MqIdentE __retVal__L = MqConfigGetIdentFrom(ctx);
    return __retVal__L;
  }
 
  inline MQ_SOCK_HDL MqContextC::ConfigGetIoPipe ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_SOCK_HDL __retVal__L = MqConfigGetIoPipe(ctx);
    return __retVal__L;
  }
 
  inline MK_STRN MqContextC::ConfigGetIoUds () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqConfigGetIoUds(ctx);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ConfigGetIsParent ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqConfigGetIsParent(ctx);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ConfigGetIsServer ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqConfigGetIsServer(ctx);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ConfigGetIsString ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqConfigGetIsString(ctx);
    return __retVal__L;
  }
 
  inline MK_STRN MqContextC::ConfigGetName () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqConfigGetName(ctx);
    return __retVal__L;
  }
 
  inline MK_I32 MqContextC::ConfigGetPkgsize () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_I32 __retVal__L = MqConfigGetPkgsize(ctx);
    return __retVal__L;
  }
 
  inline MK_STRN MqContextC::ConfigGetPostfix () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqConfigGetPostfix(ctx);
    return __retVal__L;
  }
 
  inline MK_STRN MqContextC::ConfigGetPrefix () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqConfigGetPrefix(ctx);
    return __retVal__L;
  }
 
  inline MqStartE MqContextC::ConfigGetStartAs ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MqStartE __retVal__L = MqConfigGetStartAs(ctx);
    return __retVal__L;
  }
 
  inline MqStatusIsEF MqContextC::ConfigGetStatusIs ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MqStatusIsEF __retVal__L = MqConfigGetStatusIs(ctx);
    return __retVal__L;
  }
 
  inline MK_STRN MqContextC::ConfigGetStorage () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqConfigGetStorage(ctx);
    return __retVal__L;
  }
 
  inline MK_TIME_T MqContextC::ConfigGetTimeout () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_TIME_T __retVal__L = MqConfigGetTimeout(ctx);
    return __retVal__L;
  }
 
  inline void MqContextC::ConfigSetConfigFile (MK_STRN filename)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqConfigSetConfigFile(ctx, filename);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetConfigFile (const std::string& filename)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN filename_hdl = filename.c_str();
    enum MkErrorE errVal = MqConfigSetConfigFile(ctx, filename_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  // doc-key: MqContextC,MqContextC-ConfigApi-Get,omo
 
  inline std::tuple<MK_STRN,MK_STRN,MK_STRN,MK_STRN> MqContextC::ConfigGetIoTcp ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_STRN host_out;
    MK_STRN port_out;
    MK_STRN myhost_out;
    MK_STRN myport_out;
    enum MkErrorE errVal = MqConfigGetIoTcp(ctx, &host_out, &port_out, &myhost_out, &myport_out);
    MkErrorC_Check(ctx, errVal);
    std::tuple<MK_STRN,MK_STRN,MK_STRN,MK_STRN> __retVal__L = {host_out,port_out,myhost_out,myport_out};
    return __retVal__L;
  }
 
  // MqContextC_ConfigApi_Get_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ConfigApi-Interface,om_
 
  inline void MqContextC::ConfigSetBgError (MqBgErrorCCB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqBgErrorCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetBgError(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetBgError (MqBgErrorICB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqBgErrorCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetBgError(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetBgError (MqBgErrorIF* callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqBgErrorCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetBgError(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetEvent (MqEventCCB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqEventCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetEvent(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetEvent (MqEventICB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqEventCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetEvent(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetEvent (MqEventIF* callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqEventCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetEvent(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetServerCleanup (MqServerCleanupCCB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqServerCleanupCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetServerCleanup(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetServerCleanup (MqServerCleanupICB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqServerCleanupCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetServerCleanup(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetServerCleanup (MqServerCleanupIF* callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqServerCleanupCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetServerCleanup(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetServerSetup (MqServerSetupCCB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqServerSetupCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetServerSetup(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetServerSetup (MqServerSetupICB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqServerSetupCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetServerSetup(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  inline void MqContextC::ConfigSetServerSetup (MqServerSetupIF* callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto fCall = MqServiceCallbackC::Call;
    auto callback_ptr = MqServerSetupCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    MqConfigSetServerSetup(ctx, fCall, callback_ptr, MqServiceCallbackC::Free, MqServiceCallbackC::Copy);
  }
 
  // MqContextC_ConfigApi_Interface_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ConfigApi-Misc,om_
 
  inline void MqContextC::ConfigReset ()  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigReset(ctx);
  }
 
  // MqContextC_ConfigApi_Misc_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ConfigApi-Set,om_
 
  inline MK_BOOL MqContextC::ConfigCheckStartAs (MqStartE data)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqConfigCheckStartAs(ctx, data);
    return __retVal__L;
  }
 
  inline void MqContextC::ConfigSetAllDebug (MK_I32 data)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqConfigSetAllDebug(ctx, data);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetBuffersize (MK_I32 data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetBuffersize(ctx, data);
  }
 
  inline void MqContextC::ConfigSetDaemon (MK_STRN pidfile)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqConfigSetDaemon(ctx, pidfile);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetDaemon (const std::string& pidfile)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN pidfile_hdl = pidfile.c_str();
    enum MkErrorE errVal = MqConfigSetDaemon(ctx, pidfile_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetIdentFrom (MqIdentE data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetIdentFrom(ctx, data);
  }
 
  inline void MqContextC::ConfigSetIgnoreExit (MK_BOOL data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetIgnoreExit(ctx, data);
  }
 
  inline void MqContextC::ConfigSetIoPipe (MQ_SOCK_HDL fh)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqConfigSetIoPipe(ctx, fh);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetIoTcp (MK_STRN host, MK_STRN port, MK_STRN myhost, MK_STRN myport)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqConfigSetIoTcp(ctx, host, port, myhost, myport);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetIoTcp (MkBufferListC* vals)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BFL vals_hdl = MkBufferListC::getBFL(vals);
    enum MkErrorE errVal = MqConfigSetIoTcpL(ctx, vals_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetIoTcp (const MkBufferListC& vals)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_BFL vals_hdl = MkBufferListC::getBFL(vals);
    enum MkErrorE errVal = MqConfigSetIoTcpL(ctx, vals_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetIoUds (MK_STRN file)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqConfigSetIoUds(ctx, file);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetIoUds (const std::string& file)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN file_hdl = file.c_str();
    enum MkErrorE errVal = MqConfigSetIoUds(ctx, file_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetIsServer (MK_BOOL data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetIsServer(ctx, data);
  }
 
  inline void MqContextC::ConfigSetIsString (MK_BOOL data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetIsString(ctx, data);
  }
 
  inline void MqContextC::ConfigSetName (MK_STRN data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetName(ctx, data);
  }
 
  inline void MqContextC::ConfigSetName (const std::string& data)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN data_hdl = data.c_str();
    MqConfigSetName(ctx, data_hdl);
  }
 
  inline void MqContextC::ConfigSetPkgsize (MK_I32 data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetPkgsize(ctx, data);
  }
 
  inline void MqContextC::ConfigSetPostfix (MK_STRN data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetPostfix(ctx, data);
  }
 
  inline void MqContextC::ConfigSetPostfix (const std::string& data)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN data_hdl = data.c_str();
    MqConfigSetPostfix(ctx, data_hdl);
  }
 
  inline void MqContextC::ConfigSetPrefix (MK_STRN data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetPrefix(ctx, data);
  }
 
  inline void MqContextC::ConfigSetPrefix (const std::string& data)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN data_hdl = data.c_str();
    MqConfigSetPrefix(ctx, data_hdl);
  }
 
  inline void MqContextC::ConfigSetStartAs (MqStartE data)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqConfigSetStartAs(ctx, data);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetStartAsString (MK_STRN data)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqConfigSetStartAsString(ctx, data);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetStartAsString (const std::string& data)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN data_hdl = data.c_str();
    enum MkErrorE errVal = MqConfigSetStartAsString(ctx, data_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ConfigSetStorage (MK_STRN data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetStorage(ctx, data);
  }
 
  inline void MqContextC::ConfigSetStorage (const std::string& data)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN data_hdl = data.c_str();
    MqConfigSetStorage(ctx, data_hdl);
  }
 
  inline void MqContextC::ConfigSetTimeout (MK_TIME_T data)  {
    MK_UNUSED auto ctx = getCTX();
    MqConfigSetTimeout(ctx, data);
  }
 
  // MqContextC_ConfigApi_Set_CC_API
 
 
  // doc-key: MqContextC,MqContextC-EnvApi-Env,om_
 
  inline void MqContextC::EnvProtect ()  {
    MK_UNUSED auto ctx = getCTX();
    MqEnvProtect(ctx);
  }
 
  inline void MqContextC::EnvRestore ()  {
    MK_UNUSED auto ctx = getCTX();
    MqEnvRestore(ctx);
  }
 
  // MqContextC_EnvApi_Env_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ErrorApi-Error,oc_
 
  inline MkErrorC* MqContextC::ErrorFORMAT () const {
    MK_UNUSED auto fmtobj = getCTXN__null_allow();
    MK_ERR __retVal__L = MqContextErrorFORMAT(fmtobj);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MqContextC,MqContextC-ErrorApi-Error,om_
 
  inline MkErrorE MqContextC::ErrorCopy (const MqContextC* sourceCtx) const {
    MK_UNUSED auto targetCtx = getCTXN();
    MQ_CTXN sourceCtx_hdl = MqContextC::getCTXN(sourceCtx);
    enum MkErrorE errVal = MqContextErrorCopy(targetCtx, sourceCtx_hdl);
    return errVal;
  }
 
  inline MkErrorE MqContextC::ErrorCopy (const MqContextC& sourceCtx) const {
    MK_UNUSED auto targetCtx = getCTXN();
    const MQ_CTXN sourceCtx_hdl = MqContextC::getCTXN(sourceCtx);
    enum MkErrorE errVal = MqContextErrorCopy(targetCtx, sourceCtx_hdl);
    return errVal;
  }
 
  inline MkErrorE MqContextC::ErrorMove (const MqContextC* sourceCtx) const {
    MK_UNUSED auto targetCtx = getCTXN();
    MQ_CTXN sourceCtx_hdl = MqContextC::getCTXN(sourceCtx);
    enum MkErrorE errVal = MqContextErrorMove(targetCtx, sourceCtx_hdl);
    return errVal;
  }
 
  inline MkErrorE MqContextC::ErrorMove (const MqContextC& sourceCtx) const {
    MK_UNUSED auto targetCtx = getCTXN();
    const MQ_CTXN sourceCtx_hdl = MqContextC::getCTXN(sourceCtx);
    enum MkErrorE errVal = MqContextErrorMove(targetCtx, sourceCtx_hdl);
    return errVal;
  }
 
  // MqContextC_ErrorApi_Error_CC_API
 
 
  // doc-key: MqContextC,MqContextC-HighApi-High,om_
 
  inline void MqContextC::SendVL2 (MK_STRN cstr, va_list var_list)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendVL2(ctx, cstr, var_list);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendVL2 (const std::string& cstr, va_list var_list)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN cstr_hdl = cstr.c_str();
    enum MkErrorE errVal = MqSendVL2(ctx, cstr_hdl, var_list);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_HighApi_High_CC_API
 
 
  // doc-key: MqContextC,MqContextC-LinkApi-Link,oc_
 
  inline MqContextC* MqContextC::LinkGetParent ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX __retVal__L = MqLinkGetParent(ctx);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MqContextC,MqContextC-LinkApi-Link,om_
 
  inline void MqContextC::LinkConnect ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqLinkConnect(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::LinkCreate (MkBufferListC* args)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BAC args_hdl = MkBufferListC::getBFL__null_allow(args);
    enum MkErrorE errVal = MqLinkCreate(ctx, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::LinkCreate (const MkBufferListC& args)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_BAC args_hdl = MkBufferListC::getBFL(args);
    enum MkErrorE errVal = MqLinkCreate(ctx, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::LinkCreateChild (MqContextC* parent, MkBufferListC* args)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX parent_hdl = MqContextC::getCTX(parent);
    MK_BAC args_hdl = MkBufferListC::getBFL__null_allow(args);
    enum MkErrorE errVal = MqLinkCreateChild(ctx, parent_hdl, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::LinkCreateChild (const MqContextC& parent, const MkBufferListC& args)  {
    MK_UNUSED auto ctx = getCTX();
    const MQ_CTX parent_hdl = MqContextC::getCTX(parent);
    const MK_BAC args_hdl = MkBufferListC::getBFL(args);
    enum MkErrorE errVal = MqLinkCreateChild(ctx, parent_hdl, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::LinkDelete ()  {
    MK_UNUSED auto ctx = getCTX();
    MqLinkDelete(ctx);
  }
 
  inline MK_NUM MqContextC::LinkGetCtxId ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_NUM __retVal__L = MqLinkGetCtxId(ctx);
    return __retVal__L;
  }
 
  inline MK_STRN MqContextC::LinkGetTargetIdent ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_STRN __retVal__L = MqLinkGetTargetIdent(ctx);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::LinkIsConnected ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqLinkIsConnected(ctx);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::LinkIsParent ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqLinkIsParent(ctx);
    return __retVal__L;
  }
 
  inline void MqContextC::LinkShutdown ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqLinkShutdown(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_LinkApi_Link_CC_API
 
 
  // doc-key: MqContextC,MqContextC-LogApi-Log,om_
 
  // skip class-overload: Log = MqContextLog → MkObjectLog
 
  // skip class-overload: Log = MqContextLog → MkObjectLog
 
  inline void MqContextC::LogConfig (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTXN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogConfig(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogConfig (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTXN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogConfig(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogEnv (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTX();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogEnv(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogEnv (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTX();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogEnv(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogLink (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTXN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogLink(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogLink (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTXN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogLink(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogSetup (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTXN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogSetup(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogSetup (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTXN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogSetup(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogShort (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl, MK_STRN label) const {
    MK_UNUSED auto ctx = getCTXN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogShort(ctx, fmtobj_hdl, debug, callfunc, lvl, label);
  }
 
  inline void MqContextC::LogShort (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl, MK_STRN label) const {
    MK_UNUSED auto ctx = getCTXN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogShort(ctx, fmtobj_hdl, debug, callfunc, lvl, label);
  }
 
  inline void MqContextC::LogType (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTX();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogType(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MqContextC::LogType (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto ctx = getCTX();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MqContextLogType(ctx, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline MK_STRN MqContextC::LogParentOrChild () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqLogParentOrChild(ctx);
    return __retVal__L;
  }
 
  inline MK_STRN MqContextC::LogServerOrClient () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_STRN __retVal__L = MqLogServerOrClient(ctx);
    return __retVal__L;
  }
 
  // MqContextC_LogApi_Log_CC_API
 
 
  // doc-key: MqContextC,MqContextC-MiscApi-Misc,oc_
 
  inline MkBufferC* MqContextC::GetBuffer ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BUF __retVal__L = MqContextGetBuffer(ctx);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MqContextC* MqContextC::GetRoot ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX __retVal__L = MqGetRoot(ctx);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MqContextC,MqContextC-MiscApi-Misc,om_
 
  // skip class-overload: ToString = MqContextToString → MkObjectToString
 
  inline MK_I32 MqContextC::Exit (MK_STRN callfunc, MK_STRN callfile, MK_I32 callline)  {
    MK_UNUSED auto ctx = getCTX__null_allow();
    if (callline == -1) {callline = __builtin_LINE();}
    if (callfile == NULL) {callfile = __builtin_FILE();}
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MK_I32 __retVal__L = MqExit(ctx, callfunc, callfile, callline);
    return __retVal__L;
  }
 
  inline void MqContextC::ProcessEvent (MqWaitOnEventE wait, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqProcessEvent(ctx, wait, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_MiscApi_Misc_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ProxyApi-Proxy,om_
 
  inline void MqContextC::ProxyForward (MqContextC* targetCtx, MqDumpC* dump, MK_TIME_T timeout)  {
    MK_UNUSED auto sourceCtx = getCTX();
    MQ_CTX targetCtx_hdl = MqContextC::getCTX(targetCtx);
    MQ_DMP dump_hdl = MqDumpC::getDMP__null_allow(dump);
    enum MkErrorE errVal = MqProxyForward(sourceCtx, targetCtx_hdl, dump_hdl, timeout);
    MkErrorC_Check(sourceCtx, errVal);
  }
 
  inline void MqContextC::ProxyForward (const MqContextC& targetCtx, const MqDumpC& dump, MK_TIME_T timeout)  {
    MK_UNUSED auto sourceCtx = getCTX();
    const MQ_CTX targetCtx_hdl = MqContextC::getCTX(targetCtx);
    const MQ_DMP dump_hdl = MqDumpC::getDMP(dump);
    enum MkErrorE errVal = MqProxyForward(sourceCtx, targetCtx_hdl, dump_hdl, timeout);
    MkErrorC_Check(sourceCtx, errVal);
  }
 
  inline void MqContextC::ProxyItem (MqContextC* targetCtx)  {
    MK_UNUSED auto sourceCtx = getCTX();
    MQ_CTX targetCtx_hdl = MqContextC::getCTX(targetCtx);
    enum MkErrorE errVal = MqProxyItem(sourceCtx, targetCtx_hdl);
    MkErrorC_Check(sourceCtx, errVal);
  }
 
  inline void MqContextC::ProxyItem (const MqContextC& targetCtx)  {
    MK_UNUSED auto sourceCtx = getCTX();
    const MQ_CTX targetCtx_hdl = MqContextC::getCTX(targetCtx);
    enum MkErrorE errVal = MqProxyItem(sourceCtx, targetCtx_hdl);
    MkErrorC_Check(sourceCtx, errVal);
  }
 
  // MqContextC_ProxyApi_Proxy_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ReadApi-Atom,oci
 
  inline MkBufferListC* MqContextC::ReadALL (MkBufferListC* val_inout)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BFL val_inout_hdl = MkBufferListC::getBFL__null_allow(val_inout);
    enum MkErrorE errVal = MqReadALL(ctx, &val_inout_hdl);
    MkErrorC_Check(ctx, errVal);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL val_inout_hdl);
  }
 
  // doc-key: MqContextC,MqContextC-ReadApi-Atom,oco
 
  inline MkBufferListC* MqContextC::ReadBFL ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BFL val_out;
    enum MkErrorE errVal = MqReadBFL(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL val_out);
  }
 
  inline MkBufferC* MqContextC::ReadBUF ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BUF val_out;
    enum MkErrorE errVal = MqReadBUF(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL val_out);
  }
 
  // doc-key: MqContextC,MqContextC-ReadApi-Atom,omo
 
  inline MK_BNP MqContextC::ReadBIN ()  {
    MK_UNUSED auto ctx = getCTX();
    MkBinaryR val_out_ref;
    enum MkErrorE errVal = MqReadBIN(ctx, &val_out_ref);
    ErrorCheck(errVal);
    MK_BNP val_out = std::make_pair(val_out_ref.size,val_out_ref.data);
    return val_out;
  }
 
  inline MK_BOL MqContextC::ReadBOL ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOL val_out;
    enum MkErrorE errVal = MqReadBOL(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out != 0;
  }
 
  inline MK_BNP MqContextC::ReadBinaryR ()  {
    MK_UNUSED auto ctx = getCTX();
    MkBinaryR val_out_ref;
    enum MkErrorE errVal = MqReadBinaryR(ctx, &val_out_ref);
    ErrorCheck(errVal);
    MK_BNP val_out = std::make_pair(val_out_ref.size,val_out_ref.data);
    return val_out;
  }
 
  inline MK_DBL MqContextC::ReadDBL ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_DBL val_out;
    enum MkErrorE errVal = MqReadDBL(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out;
  }
 
  inline MK_FLT MqContextC::ReadFLT ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_FLT val_out;
    enum MkErrorE errVal = MqReadFLT(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out;
  }
 
  inline MK_HDL MqContextC::ReadHDL ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_HDL val_out;
    enum MkErrorE errVal = MqReadHDL(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out;
  }
 
  inline MK_I16 MqContextC::ReadI16 ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_I16 val_out;
    enum MkErrorE errVal = MqReadI16(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out;
  }
 
  inline MK_I32 MqContextC::ReadI32 ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_I32 val_out;
    enum MkErrorE errVal = MqReadI32(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out;
  }
 
  inline MK_I64 MqContextC::ReadI64 ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_I64 val_out;
    enum MkErrorE errVal = MqReadI64(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out;
  }
 
  inline MK_I8 MqContextC::ReadI8 ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_I8 val_out;
    enum MkErrorE errVal = MqReadI8(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return (MK_I8)val_out;
  }
 
 
  inline MK_LONG MqContextC::ReadLONG ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_LONG val_out;
    enum MkErrorE errVal = MqReadLONG(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out;
  }
 
 
  inline MK_STRN MqContextC::ReadSTR ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_STRN val_out;
    enum MkErrorE errVal = MqReadSTR(ctx, &val_out);
    MkErrorC_Check(ctx, errVal);
    return val_out;
  }
 
  inline std::string MqContextC::ReadStringR ()  {
    MK_UNUSED auto ctx = getCTX();
    MkStringR val_out_ref;
    enum MkErrorE errVal = MqReadStringR(ctx, &val_out_ref);
    ErrorCheck(errVal);
    const std::string& val_out = std::string(val_out_ref.ptr,val_out_ref.len);
    return val_out;
  }
 
  // MqContextC_ReadApi_Atom_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ReadApi-Block,om_
 
  inline void MqContextC::ReadL_END ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqReadL_END(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ReadL_START (MkBufferC* buf)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BUF buf_hdl = MkBufferC::getBUF__null_allow(buf);
    enum MkErrorE errVal = MqReadL_START(ctx, buf_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ReadL_START (const MkBufferC& buf)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_BUF buf_hdl = MkBufferC::getBUF(buf);
    enum MkErrorE errVal = MqReadL_START(ctx, buf_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ReadT_END ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqReadT_END(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ReadT_START ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqReadT_START(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_ReadApi_Block_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ReadApi-Misc,om_
 
  inline void MqContextC::ReadDbg ()  {
    MK_UNUSED auto ctx = getCTX();
    MqReadDbg(ctx);
  }
 
  inline MkTypeE MqContextC::ReadGetNextType ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkTypeE __retVal__L = MqReadGetNextType(ctx);
    return __retVal__L;
  }
 
  inline MK_NUM MqContextC::ReadGetNumItems ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_NUM __retVal__L = MqReadGetNumItems(ctx);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ReadItemExists ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqReadItemExists(ctx);
    return __retVal__L;
  }
 
  inline void MqContextC::ReadUndo ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqReadUndo(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_ReadApi_Misc_CC_API
 
 
  // doc-key: MqContextC,MqContextC-RouteApi-Route,oco
 
  inline MkBufferListC* MqContextC::RouteGetTree ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BFL treeP_out;
    enum MkErrorE errVal = MqRouteGetTree(ctx, &treeP_out);
    MkErrorC_Check(ctx, errVal);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL treeP_out);
  }
 
  // doc-key: MqContextC,MqContextC-RouteApi-Route,om_
 
  inline void MqContextC::RouteCreate (MK_STRN route, MK_STRN service, MK_BOOL overwrite)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqRouteCreate(ctx, route, service, overwrite);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::RouteCreate (const std::string& route, const std::string& service, MK_BOOL overwrite)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN route_hdl = route.c_str();
    const MK_STRN service_hdl = service.c_str();
    enum MkErrorE errVal = MqRouteCreate(ctx, route_hdl, service_hdl, overwrite);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::RouteDelete (MK_STRN route, MK_STRN service, MK_BOOL overwrite)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqRouteDelete(ctx, route, service, overwrite);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::RouteDelete (const std::string& route, const std::string& service, MK_BOOL overwrite)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN route_hdl = route.c_str();
    const MK_STRN service_hdl = service.c_str();
    enum MkErrorE errVal = MqRouteDelete(ctx, route_hdl, service_hdl, overwrite);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline MqContextC_A MqContextC::RouteResolve (MK_STRN ident, MK_NUM retnum)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX_A __retVal__L = MqRouteResolve(ctx, ident, retnum);
    static __thread MK_NUM szret = 0;
    static __thread MqContextC* *ret = NULL;
    if (__retVal__L.size+1 > szret) {
      szret=__retVal__L.size*2+1;
      ret=(MqContextC**)MkSysRealloc(MK_ERROR_PANIC,ret,szret*sizeof(MqContextC*));
    }
    MK_NUM num;
    for (num=0; num<__retVal__L.size; num++) {
      ret[num] = MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L.data[num]);
    }
    ret[num] = NULL;
    return (MqContextC_A) {__retVal__L.size,ret};
  }
 
  inline MqContextC_A MqContextC::RouteResolve (const std::string& ident, MK_NUM retnum)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN ident_hdl = ident.c_str();
    MQ_CTX_A __retVal__L = MqRouteResolve(ctx, ident_hdl, retnum);
    static __thread MK_NUM szret = 0;
    static __thread MqContextC* *ret = NULL;
    if (__retVal__L.size+1 > szret) {
      szret=__retVal__L.size*2+1;
      ret=(MqContextC**)MkSysRealloc(MK_ERROR_PANIC,ret,szret*sizeof(MqContextC*));
    }
    MK_NUM num;
    for (num=0; num<__retVal__L.size; num++) {
      ret[num] = MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L.data[num]);
    }
    ret[num] = NULL;
    return (MqContextC_A) {__retVal__L.size,ret};
  }
 
  inline void MqContextC::RouteTraverse (MK_STRN service, MkBufferListC* args)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BAC args_hdl = MkBufferListC::getBFL__null_allow(args);
    enum MkErrorE errVal = MqRouteTraverse(ctx, service, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::RouteTraverse (MK_STRN service, const MkBufferListC& args)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_BAC args_hdl = MkBufferListC::getBFL(args);
    enum MkErrorE errVal = MqRouteTraverse(ctx, service, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::RouteTraverse (const std::string& service, MkBufferListC* args)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN service_hdl = service.c_str();
    MK_BAC args_hdl = MkBufferListC::getBFL__null_allow(args);
    enum MkErrorE errVal = MqRouteTraverse(ctx, service_hdl, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::RouteTraverse (const std::string& service, const MkBufferListC& args)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN service_hdl = service.c_str();
    const MK_BAC args_hdl = MkBufferListC::getBFL(args);
    enum MkErrorE errVal = MqRouteTraverse(ctx, service_hdl, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  // doc-key: MqContextC,MqContextC-RouteApi-Route,omo
 
  inline MK_STRN MqContextC::RouteGetPath ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_STRN path_out;
    enum MkErrorE errVal = MqRouteGetPath(ctx, &path_out);
    MkErrorC_Check(ctx, errVal);
    return path_out;
  }
 
  // MqContextC_RouteApi_Route_CC_API
 
 
  // doc-key: MqContextC,MqContextC-SendApi-Atom,om_
 
  inline void MqContextC::SendBFL (const MkBufferListC* val)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BFLN val_hdl = MkBufferListC::getBFLN(val);
    enum MkErrorE errVal = MqSendBFL(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendBFL (const MkBufferListC& val)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_BFLN val_hdl = MkBufferListC::getBFLN(val);
    enum MkErrorE errVal = MqSendBFL(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendBIN (MK_BNP val)  {
    MK_UNUSED auto ctx = getCTX();
    const MkBinaryR val_ref = MkBinaryCreate(val.first,val.second);
    enum MkErrorE errVal = MqSendBIN(ctx, val_ref);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendBOL (MK_BOL val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendBOL(ctx, (MK_BOL)(val?1:0));
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendBUF (const MkBufferC* val)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BUFN val_hdl = MkBufferC::getBUFN(val);
    enum MkErrorE errVal = MqSendBUF(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendBUF (const MkBufferC& val)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_BUFN val_hdl = MkBufferC::getBUFN(val);
    enum MkErrorE errVal = MqSendBUF(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendBUS_FLAT (const MkBufferStreamC* val)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BUSN val_hdl = MkBufferStreamC::getBUSN(val);
    enum MkErrorE errVal = MqSendBUS_FLAT(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendBUS_FLAT (const MkBufferStreamC& val)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_BUSN val_hdl = MkBufferStreamC::getBUSN(val);
    enum MkErrorE errVal = MqSendBUS_FLAT(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendBinaryR (MK_BNP val)  {
    MK_UNUSED auto ctx = getCTX();
    const MkBinaryR val_ref = MkBinaryCreate(val.first,val.second);
    enum MkErrorE errVal = MqSendBinaryR(ctx, val_ref);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendDBL (MK_DBL val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendDBL(ctx, val);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendFLT (MK_FLT val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendFLT(ctx, val);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendHDL (MK_HDL val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendHDL(ctx, val);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendI16 (MK_I16 val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendI16(ctx, val);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendI32 (MK_I32 val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendI32(ctx, val);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendI64 (MK_I64 val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendI64(ctx, val);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendI8 (MK_I8 val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendI8(ctx, (MK_I8)(val));
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendLONG (MK_LONG val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendLONG(ctx, val);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendLTR (MQ_LTR transLId)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendLTR(ctx, transLId);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendL_FLAT (const MkBufferListC* val)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BFLN val_hdl = MkBufferListC::getBFLN(val);
    enum MkErrorE errVal = MqSendL_FLAT(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendL_FLAT (const MkBufferListC& val)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_BFLN val_hdl = MkBufferListC::getBFLN(val);
    enum MkErrorE errVal = MqSendL_FLAT(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendSTR (MK_STRN val)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendSTR(ctx, val);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendSTR (const std::string& val)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN val_hdl = val.c_str();
    enum MkErrorE errVal = MqSendSTR(ctx, val_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendStringR (const std::string& val)  {
    MK_UNUSED auto ctx = getCTX();
    const MkStringR val_ref = MkStringCreate((MK_NUM)val.size(),val.c_str());
    enum MkErrorE errVal = MqSendStringR(ctx, val_ref);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendV (MK_FST printfmt, ... )  {
    MK_UNUSED auto ctx = getCTX();
    va_list ap;
    va_start (ap, printfmt);
    enum MkErrorE errVal = MqSendVL(ctx, printfmt, ap);
    va_end (ap);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendVL (MK_FST printfmt, va_list var_list)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendVL(ctx, printfmt, var_list);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_SendApi_Atom_CC_API
 
 
  // doc-key: MqContextC,MqContextC-SendApi-Basics,om_
 
  inline void MqContextC::SendEND (MQ_TOK token, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendEND(ctx, token, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND (const std::string& token, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    enum MkErrorE errVal = MqSendEND(ctx, token_hdl, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_CALLBACK (MQ_TOK token, MqServiceCCB callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_CALLBACK(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_CALLBACK (const std::string& token, MqServiceCCB callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_CALLBACK(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_CALLBACK (MQ_TOK token, MqServiceICB callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_CALLBACK(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_CALLBACK (const std::string& token, MqServiceICB callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_CALLBACK(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_CALLBACK (MQ_TOK token, MqServiceIF* callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_CALLBACK(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_CALLBACK (const std::string& token, MqServiceIF* callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_CALLBACK(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_SUB (MQ_TOK token, MqServiceCCB callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_SUB(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_SUB (const std::string& token, MqServiceCCB callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_SUB(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_SUB (MQ_TOK token, MqServiceICB callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_SUB(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_SUB (const std::string& token, MqServiceICB callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_SUB(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_SUB (MQ_TOK token, MqServiceIF* callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_SUB(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_SUB (const std::string& token, MqServiceIF* callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqSendEND_AND_SUB(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_TRANSACTION (MQ_TOK token, MQ_TOK callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendEND_AND_TRANSACTION(ctx, token, callback, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_TRANSACTION (const std::string& token, const std::string& callback, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    const MK_STRN callback_hdl = callback.c_str();
    enum MkErrorE errVal = MqSendEND_AND_TRANSACTION(ctx, token_hdl, callback_hdl, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_WAIT (MQ_TOK token, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendEND_AND_WAIT(ctx, token, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendEND_AND_WAIT (const std::string& token, MK_TIME_T timeout)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    enum MkErrorE errVal = MqSendEND_AND_WAIT(ctx, token_hdl, timeout);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendSTART ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendSTART(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendSYNC ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendSYNC(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_SendApi_Basics_CC_API
 
 
  // doc-key: MqContextC,MqContextC-SendApi-Block,om_
 
  inline void MqContextC::SendL_END ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendL_END(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendL_START ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendL_START(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendT_END ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendT_END(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendT_START ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendT_START(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_SendApi_Block_CC_API
 
 
  // doc-key: MqContextC,MqContextC-SendApi-Return,om_
 
  inline void MqContextC::SendERROR ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendERROR(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendRETURN ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendRETURN(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SendRETURN_SUB ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendRETURN_SUB(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_SendApi_Return_CC_API
 
 
  // doc-key: MqContextC,MqContextC-ServiceApi-Service,om_
 
  inline void MqContextC::ServiceCreate (MQ_TOK token, MqServiceCCB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqServiceCreate(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, NULL);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceCreate (const std::string& token, MqServiceCCB callback)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqServiceCreate(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, NULL);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceCreate (MQ_TOK token, MqServiceICB callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqServiceCreate(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, NULL);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceCreate (const std::string& token, MqServiceICB callback)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqServiceCreate(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, NULL);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceCreate (MQ_TOK token, MqServiceIF* callback)  {
    MK_UNUSED auto ctx = getCTX();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqServiceCreate(ctx, token, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, NULL);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceCreate (const std::string& token, MqServiceIF* callback)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    auto callback_ptr = MqServiceCallbackC::Create(MK_RT_CALL callback, this);
    enum MkErrorE errVal = MqServiceCreate(ctx, token_hdl, MqServiceCallbackC::Call, callback_ptr, MqServiceCallbackC::Free, NULL);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceDelete (MQ_TOK token)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqServiceDelete(ctx, token);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceDelete (const std::string& token)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    enum MkErrorE errVal = MqServiceDelete(ctx, token_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline MK_BOOL MqContextC::ServiceIsTransaction ()  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqServiceIsTransaction(ctx);
    return __retVal__L;
  }
 
  inline void MqContextC::ServiceProxy (MQ_TOK token, MQ_SLAVE_ID id)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqServiceProxy(ctx, token, id);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceProxy (const std::string& token, MQ_SLAVE_ID id)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    enum MkErrorE errVal = MqServiceProxy(ctx, token_hdl, id);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceProxyCtx (MQ_TOK token, MqContextC* target)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX target_hdl = MqContextC::getCTX(target);
    enum MkErrorE errVal = MqServiceProxyCtx(ctx, token, target_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceProxyCtx (MQ_TOK token, const MqContextC& target)  {
    MK_UNUSED auto ctx = getCTX();
    const MQ_CTX target_hdl = MqContextC::getCTX(target);
    enum MkErrorE errVal = MqServiceProxyCtx(ctx, token, target_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceProxyCtx (const std::string& token, MqContextC* target)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    MQ_CTX target_hdl = MqContextC::getCTX(target);
    enum MkErrorE errVal = MqServiceProxyCtx(ctx, token_hdl, target_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceProxyCtx (const std::string& token, const MqContextC& target)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    const MQ_CTX target_hdl = MqContextC::getCTX(target);
    enum MkErrorE errVal = MqServiceProxyCtx(ctx, token_hdl, target_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline MK_BOOL MqContextC::ServiceProxyCtxExists (MQ_TOK token, MqContextC* target)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX target_hdl = MqContextC::getCTX(target);
    MK_BOOL __retVal__L = MqServiceProxyCtxExists(ctx, token, target_hdl);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ServiceProxyCtxExists (MQ_TOK token, const MqContextC& target)  {
    MK_UNUSED auto ctx = getCTX();
    const MQ_CTX target_hdl = MqContextC::getCTX(target);
    MK_BOOL __retVal__L = MqServiceProxyCtxExists(ctx, token, target_hdl);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ServiceProxyCtxExists (const std::string& token, MqContextC* target)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    MQ_CTX target_hdl = MqContextC::getCTX(target);
    MK_BOOL __retVal__L = MqServiceProxyCtxExists(ctx, token_hdl, target_hdl);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ServiceProxyCtxExists (const std::string& token, const MqContextC& target)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    const MQ_CTX target_hdl = MqContextC::getCTX(target);
    MK_BOOL __retVal__L = MqServiceProxyCtxExists(ctx, token_hdl, target_hdl);
    return __retVal__L;
  }
 
  inline void MqContextC::ServiceProxyRoundRobin (MQ_TOK token, MK_STRN ident)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqServiceProxyRoundRobin(ctx, token, ident);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceProxyRoundRobin (const std::string& token, const std::string& ident)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    const MK_STRN ident_hdl = ident.c_str();
    enum MkErrorE errVal = MqServiceProxyRoundRobin(ctx, token_hdl, ident_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceStorage (MQ_TOK token)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqServiceStorage(ctx, token);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::ServiceStorage (const std::string& token)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    enum MkErrorE errVal = MqServiceStorage(ctx, token_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline MK_BOOL MqContextC::ServiceTokenCheck (MQ_TOK token)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqServiceTokenCheck(ctx, token);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ServiceTokenCheck (const std::string& token)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    MK_BOOL __retVal__L = MqServiceTokenCheck(ctx, token_hdl);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ServiceTokenExists (MQ_TOK token)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BOOL __retVal__L = MqServiceTokenExists(ctx, token);
    return __retVal__L;
  }
 
  inline MK_BOOL MqContextC::ServiceTokenExists (const std::string& token)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN token_hdl = token.c_str();
    MK_BOOL __retVal__L = MqServiceTokenExists(ctx, token_hdl);
    return __retVal__L;
  }
 
  inline MQ_TOK MqContextC::ServiceTokenGet ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_TOK __retVal__L = MqServiceTokenGet(ctx);
    return __retVal__L;
  }
 
  // MqContextC_ServiceApi_Service_CC_API
 
 
  // doc-key: MqContextC,MqContextC-SlaveApi-Slave,oc_
 
  inline MqContextC* MqContextC::SlaveGetMaster ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX __retVal__L = MqSlaveGetMaster(ctx);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MqContextC,MqContextC-SlaveApi-Slave,oco
 
  inline MqContextC* MqContextC::SlaveGet (MQ_SLAVE_ID id)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX ctx_out;
    enum MkErrorE errVal = MqSlaveGet(ctx, id, &ctx_out);
    MkErrorC_Check(ctx, errVal);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL ctx_out);
  }
 
  inline MqContextC* MqContextC::SlaveGetFilter ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX ctx_out;
    enum MkErrorE errVal = MqSlaveGetFilter(ctx, &ctx_out);
    MkErrorC_Check(ctx, errVal);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL ctx_out);
  }
 
  inline MqContextC* MqContextC::SlaveGetProxy (MQ_SLAVE_ID id)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX ctx_out;
    enum MkErrorE errVal = MqSlaveGetProxy(ctx, id, &ctx_out);
    MkErrorC_Check(ctx, errVal);
    return MqContextC::MqContextC_ObjNew(MK_RT_CALL ctx_out);
  }
 
  // doc-key: MqContextC,MqContextC-SlaveApi-Slave,om_
 
  inline MK_BOOL MqContextC::SlaveCheck (MQ_SLAVE_ID id) const {
    MK_UNUSED auto ctx = getCTXN();
    MK_BOOL __retVal__L = MqSlaveCheck(ctx, id);
    return __retVal__L;
  }
 
  inline void MqContextC::SlaveCreate (MQ_SLAVE_ID id, MqContextC* slave)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX slave_hdl = MqContextC::getCTX(slave);
    enum MkErrorE errVal = MqSlaveCreate(ctx, id, slave_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SlaveCreate (MQ_SLAVE_ID id, const MqContextC& slave)  {
    MK_UNUSED auto ctx = getCTX();
    const MQ_CTX slave_hdl = MqContextC::getCTX(slave);
    enum MkErrorE errVal = MqSlaveCreate(ctx, id, slave_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::SlaveDelete (MQ_SLAVE_ID id)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSlaveDelete(ctx, id);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline MK_BOOL MqContextC::SlaveIs () const {
    MK_UNUSED auto ctx = getCTXN();
    MK_BOOL __retVal__L = MqSlaveIs(ctx);
    return __retVal__L;
  }
 
  inline void MqContextC::SlaveWorker (MQ_SLAVE_ID id, MK_STRN fct, MkBufferListC* args)  {
    MK_UNUSED auto ctx = getCTX();
    MK_BAC args_hdl = MkBufferListC::getBFL__null_allow(args);
    enum MkErrorE errVal = MqSlaveWorker(ctx, id, fct, args_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  // MqContextC_SlaveApi_Slave_CC_API
 
 
  // doc-key: MqContextC,MqContextC-StorageApi-Storage,oci
 
  inline MQ_LTR MqContextC::StorageDelete (MQ_LTR *transLIdP_inout)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_LTR transLIdP_inout_val = transLIdP_inout == NULL ? 0 : (MQ_LTR)(*transLIdP_inout);
    enum MkErrorE errVal = MqStorageDelete(ctx, &transLIdP_inout_val);
    if (transLIdP_inout != NULL) {*transLIdP_inout = (MQ_LTR)(transLIdP_inout_val);}
    MkErrorC_Check(ctx, errVal);
    return transLIdP_inout_val;
  }
 
  inline MQ_LTR MqContextC::StorageImport (MQ_LTR *transLIdP_inout)  {
    MK_UNUSED auto ctx = getCTX();
    MQ_LTR transLIdP_inout_val = transLIdP_inout == NULL ? 0 : (MQ_LTR)(*transLIdP_inout);
    enum MkErrorE errVal = MqStorageImport(ctx, &transLIdP_inout_val);
    if (transLIdP_inout != NULL) {*transLIdP_inout = (MQ_LTR)(transLIdP_inout_val);}
    MkErrorC_Check(ctx, errVal);
    return transLIdP_inout_val;
  }
 
  // doc-key: MqContextC,MqContextC-StorageApi-Storage,om_
 
  inline void MqContextC::StorageClose ()  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqStorageClose(ctx);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::StorageDecrRef (MQ_LTR transLId)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqStorageDecrRef(ctx, transLId);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::StorageIncrRef (MQ_LTR transLId)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqStorageIncrRef(ctx, transLId);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::StorageLog (MK_STRN callfunc)  {
    MK_UNUSED auto ctx = getCTX();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MqStorageLog(ctx, callfunc);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::StorageOpen (MK_STRN storageFile)  {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqStorageOpen(ctx, storageFile);
    MkErrorC_Check(ctx, errVal);
  }
 
  inline void MqContextC::StorageOpen (const std::string& storageFile)  {
    MK_UNUSED auto ctx = getCTX();
    const MK_STRN storageFile_hdl = storageFile.c_str();
    enum MkErrorE errVal = MqStorageOpen(ctx, storageFile_hdl);
    MkErrorC_Check(ctx, errVal);
  }
 
  // doc-key: MqContextC,MqContextC-StorageApi-Storage,omo
 
  inline MQ_LTR MqContextC::StorageCount ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_LTR cnt_out;
    enum MkErrorE errVal = MqStorageCount(ctx, &cnt_out);
    MkErrorC_Check(ctx, errVal);
    return cnt_out;
  }
 
  inline MK_I32 MqContextC::StorageErrCnt (MQ_LTR transLId)  {
    MK_UNUSED auto ctx = getCTX();
    MK_I32 cnt_out;
    enum MkErrorE errVal = MqStorageErrCnt(ctx, transLId, &cnt_out);
    MkErrorC_Check(ctx, errVal);
    return cnt_out;
  }
 
  inline MQ_LTR MqContextC::StorageExport ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_LTR ltid_out;
    enum MkErrorE errVal = MqStorageExport(ctx, &ltid_out);
    MkErrorC_Check(ctx, errVal);
    return ltid_out;
  }
 
  inline std::tuple<MqContextC*,MQ_LTR> MqContextC::StorageResolve ()  {
    MK_UNUSED auto ctx = getCTX();
    MQ_CTX otherCtxP_out;
    MQ_LTR otherLIdP_out;
    enum MkErrorE errVal = MqStorageResolve(ctx, &otherCtxP_out, &otherLIdP_out);
    MkErrorC_Check(ctx, errVal);
    std::tuple<MqContextC*,MQ_LTR> __retVal__L = {MqContextC::MqContextC_ObjNew(MK_RT_CALL otherCtxP_out),otherLIdP_out};
    return __retVal__L;
  }
 
  // MqContextC_StorageApi_Storage_CC_API
 
 
  // doc-key: MqContextC,MqContextC-TOR,sCc
 
  inline MK_OBJ MqContextC::CTOR (MqContextC* tmpl)  {
    MkRtSetup_NULL;
    MQ_CTX tmpl_hdl = MqContextC::getCTX__null_allow(tmpl);
    MQ_CTX __retVal__L = MqContextCreate(NULL, tmpl_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MqContextC::CTOR");
    }
    return (MK_OBJ)__retVal__L;
  }
 
  inline MqContextC* MqContextC::Create (MqContextC* tmpl)  {
    MkRtSetup_NULL;
    MQ_CTX tmpl_hdl = MqContextC::getCTX__null_allow(tmpl);
    MQ_CTX __retVal__L = MqContextCreate(NULL, tmpl_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MqContextC::Create");
    }
    return MqContextC::MqContextC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // MqContextC_TOR_CC_API
 
  //   END-MqContextC - created by 'cc_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
  
  inline MK_OBJ MK_DECL MqContextC::CTOR (MK_TYP const typ, MqContextC* tmpl)  {
    MkRtSetup_NULL;
    MQ_CTX tmpl_hdl = MqContextC::getCTX__null_allow(tmpl);
    MQ_CTX __retVal__L = MqContextCreate(typ, tmpl_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MqContextC::CTOR");
    }
    return (MK_OBJ)__retVal__L;
  }
 
} // END - namespace "ccmqmsgque"