MqContextC_cc.hh

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#pragma once
 
#include <list>
 
namespace ccmqmsgque {
 
  typedef struct {
    MK_NUM      size;
    MqContextC  **data;
  } MqContextC_A;
 
  class MqContextC : public MkObjectC {
 
    // factory constructor need access to hdl
    template<class T> friend class MqFactoryCT;
    friend class MqMsgque;
    friend class MqServiceCallbackC;
 
    static MK_TYP mqtype;
 
/* LABEL-START */
 
 
    public:
      static thread_local MqContextC MK_NULL_REF;
 
    private:
 
      static MqContextC* MqContextC_GetSelf (MQ_CTX hdl) {
        return (hdl != NULL ? static_cast<MqContextC*>((*MqContextC_X2obj(hdl)).self) : &MK_NULL_REF);
      }
 
    #ifdef MqContextC_selfCreate_overload
      static MK_PTR MqContextC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env);
    #else
      static MK_PTR MqContextC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
        return new MqContextC(obj);
      }
    #endif
 
      static void MqContextC_selfDelete (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        delete static_cast<MqContextC*>(self);
      }
 
      static void MqContextC_selfUnlink (MK_RT_ARGS MK_PTR self, MK_PTR env) {
        MqContextC* selfO = static_cast<MqContextC*>(self);
        selfO->atomUnlink();
      }
 
      void MqContextC_Init (MQ_CTX hdl)   { atomInit(MqContextC_X2obj(hdl)); };
 
 
      static MqContextC* MqContextC_ObjCreate (MK_RT_ARGS MQ_CTX hdl) {
        return static_cast<MqContextC*>(MkObjectC::atomObjCreate(MK_RT_CALL MqContextC_X2obj(hdl)));
      }
 
#ifndef META_IS_MkObjectC
      MqContextC   (MK_OBJ obj) : MkObjectC(obj) {};
#endif
 
    public:
 
#ifndef META_IS_MkObjectC
      MqContextC   (MQ_CTX hdl) : MkObjectC(MqContextC_X2obj(hdl)) {};
#endif
 
      static MqContextC* MqContextC_ObjNew (MK_RT_ARGS MQ_CTX hdl) {
        return (hdl ? static_cast<MqContextC*>(MkObjectC::atomObjNew(MK_RT_CALL MqContextC_X2obj(hdl))) : &MK_NULL_REF);
      }
 
      MQ_CTX getCTX() const {
        MQ_CTX ret = reinterpret_cast<MQ_CTX>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      MQ_CTX getCTX__null_allow() const {
        return reinterpret_cast<MQ_CTX>(hdl);
      };
 
      MQ_CTXN getCTXN() const {
        MQ_CTXN ret = reinterpret_cast<MQ_CTXN>(hdl);
        if (unlikely(ret == NULL)) InstHdlIsNullError();
        return ret;
      };
 
      MQ_CTXN getCTXN__null_allow() const {
        return reinterpret_cast<MQ_CTXN>(hdl);
      };
 
      static MQ_CTX getCTX(MqContextC* clsHdl) {
        MQ_CTX ret = clsHdl ? reinterpret_cast<MQ_CTX>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(MqContextC);
        return ret;
      };
 
      static MQ_CTX getCTX__null_allow(MqContextC* clsHdl) {
        return clsHdl ? reinterpret_cast<MQ_CTX>(clsHdl->hdl) : NULL;
      };
 
      static MQ_CTXN getCTXN(const MqContextC* clsHdl) {
        MQ_CTXN ret = clsHdl ? reinterpret_cast<MQ_CTXN>(clsHdl->hdl) : NULL;
        if (unlikely(ret == NULL)) ClassHdlIsNullError(MqContextC);
        return ret;
      };
 
      static MQ_CTXN getCTXN__null_allow(const MqContextC* clsHdl) {
        return clsHdl ? reinterpret_cast<MQ_CTXN>(clsHdl->hdl) : NULL;
      };
 
      static MQ_CTX getCTX(const MqContextC& clsHdl) {
        return clsHdl.getCTX();
      };
 
      static MQ_CTX getCTX__null_allow(const MqContextC& clsHdl) {
        return clsHdl.getCTX__null_allow();
      };
 
      static MQ_CTXN getCTXN(const MqContextC& clsHdl) {
        return clsHdl.getCTXN();
      };
 
      static MQ_CTXN getCTXN__null_allow(const MqContextC& clsHdl) {
        return clsHdl.getCTXN__null_allow();
      };
 
      bool Check() const {
        return (hdl && MqCtxCheck(hdl));
      };
 
/* LABEL-END */
 
    public:
      void Init (MK_STRN caller = __builtin_FUNCTION());
 
      typedef void (MqContextC::*MqTokenICB) ();    
 
      typedef MqTokenICB MqBgErrorICB;
      typedef MqTokenICB MqServiceICB;
      typedef MqTokenICB MqServerSetupICB;
      typedef MqTokenICB MqServerCleanupICB;
      typedef MqTokenICB MqEventICB;
 
      typedef void (*MqTokenCCB) (MqContextC*);     
 
      typedef MqTokenCCB MqBgErrorCCB;
      typedef MqTokenCCB MqServiceCCB;
      typedef MqTokenCCB MqServerSetupCCB;
      typedef MqTokenCCB MqServerCleanupCCB;
      typedef MqTokenCCB MqEventCCB;
 
      operator MqContextC*() { return this; };
 
    //   BEGIN-MqContextC - created by 'cc_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-Class-Export,sc_,public
 
      static MqContextC* HandleResolve (MK_HDL netHdl);
 
      // doc-key: MqContextC,MqContextC-Class-Export,om_,public
 
      // skip class-overload: MK_HDL HandleGet ()
 
    // MqContextC_Class_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-Class-Introspection,oc_,public
 
      MqContextC* Next ();
 
      MqContextC* Prev ();
 
      // doc-key: MqContextC,MqContextC-Class-Introspection,sc_,public
 
      static MqContextC* Instances ();
 
    // MqContextC_Class_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-Class-Misc,sc_,public
 
      static MqContextC* GetNull ();
 
    // MqContextC_Class_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ClassApi-Class,oc_,public
 
      MqFactoryC* ClassFactoryGet () const;
 
      // doc-key: MqContextC,MqContextC-ClassApi-Class,om_,public
 
      void ClassFactorySet (MqFactoryC* item);
 
      void ClassFactorySet (const MqFactoryC& item);
 
      MK_STRN ClassIdentGet () const;
 
      void ClassIdentSet (MK_STRN ident);
 
      void ClassIdentSet (const std::string& ident);
 
      MK_STRN ClassOriginalIdentGet () const;
 
    // MqContextC_ClassApi_Class_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ConfigApi-Get,oco,public
 
      MkBufferListC* ConfigGetIoTcpL ();
 
      // doc-key: MqContextC,MqContextC-ConfigApi-Get,om_,public
 
      MK_I32 ConfigGetBuffersize () const;
 
      MqIdentE ConfigGetIdentFrom ();
 
      MQ_SOCK_HDL ConfigGetIoPipe ();
 
      MK_STRN ConfigGetIoUds () const;
 
      MK_BOOL ConfigGetIsParent ();
 
      MK_BOOL ConfigGetIsServer ();
 
      MK_BOOL ConfigGetIsString ();
 
      MK_STRN ConfigGetName () const;
 
      MK_I32 ConfigGetPkgsize () const;
 
      MK_STRN ConfigGetPostfix () const;
 
      MK_STRN ConfigGetPrefix () const;
 
      MqStartE ConfigGetStartAs ();
 
      MqStatusIsEF ConfigGetStatusIs ();
 
      MK_STRN ConfigGetStorage () const;
 
      MK_TIME_T ConfigGetTimeout () const;
 
      void ConfigSetConfigFile (MK_STRN filename);
 
      void ConfigSetConfigFile (const std::string& filename);
 
      // doc-key: MqContextC,MqContextC-ConfigApi-Get,omo,public
 
      std::tuple<MK_STRN,MK_STRN,MK_STRN,MK_STRN> ConfigGetIoTcp ();
 
    // MqContextC_ConfigApi_Get_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ConfigApi-Interface,om_,public
 
      void ConfigSetBgError (MqBgErrorCCB callback = NULL);
 
      void ConfigSetBgError (MqBgErrorICB callback = NULL);
 
      void ConfigSetBgError (MqBgErrorIF* callback = NULL);
 
      void ConfigSetEvent (MqEventCCB callback = NULL);
 
      void ConfigSetEvent (MqEventICB callback = NULL);
 
      void ConfigSetEvent (MqEventIF* callback = NULL);
 
      void ConfigSetServerCleanup (MqServerCleanupCCB callback = NULL);
 
      void ConfigSetServerCleanup (MqServerCleanupICB callback = NULL);
 
      void ConfigSetServerCleanup (MqServerCleanupIF* callback = NULL);
 
      void ConfigSetServerSetup (MqServerSetupCCB callback = NULL);
 
      void ConfigSetServerSetup (MqServerSetupICB callback = NULL);
 
      void ConfigSetServerSetup (MqServerSetupIF* callback = NULL);
 
    // MqContextC_ConfigApi_Interface_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ConfigApi-Misc,om_,public
 
      void ConfigReset ();
 
    // MqContextC_ConfigApi_Misc_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ConfigApi-Set,om_,public
 
      MK_BOOL ConfigCheckStartAs (MqStartE data);
 
      void ConfigSetAllDebug (MK_I32 data);
 
      void ConfigSetBuffersize (MK_I32 data);
 
      void ConfigSetDaemon (MK_STRN pidfile);
 
      void ConfigSetDaemon (const std::string& pidfile);
 
      void ConfigSetIdentFrom (MqIdentE data);
 
      void ConfigSetIgnoreExit (MK_BOOL data);
 
      void ConfigSetIoPipe (MQ_SOCK_HDL fh);
 
      void ConfigSetIoTcp (MK_STRN host = NULL, MK_STRN port = NULL, MK_STRN myhost = NULL, MK_STRN myport = NULL);
 
      void ConfigSetIoTcp (MkBufferListC* vals);
 
      void ConfigSetIoTcp (const MkBufferListC& vals);
 
      void ConfigSetIoUds (MK_STRN file);
 
      void ConfigSetIoUds (const std::string& file);
 
      void ConfigSetIsServer (MK_BOOL data);
 
      void ConfigSetIsString (MK_BOOL data);
 
      void ConfigSetName (MK_STRN data);
 
      void ConfigSetName (const std::string& data);
 
      void ConfigSetPkgsize (MK_I32 data);
 
      void ConfigSetPostfix (MK_STRN data);
 
      void ConfigSetPostfix (const std::string& data);
 
      void ConfigSetPrefix (MK_STRN data);
 
      void ConfigSetPrefix (const std::string& data);
 
      void ConfigSetStartAs (MqStartE data);
 
      void ConfigSetStartAsString (MK_STRN data);
 
      void ConfigSetStartAsString (const std::string& data);
 
      void ConfigSetStorage (MK_STRN data);
 
      void ConfigSetStorage (const std::string& data);
 
      void ConfigSetTimeout (MK_TIME_T data);
 
    // MqContextC_ConfigApi_Set_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-EnvApi-Env,om_,public
 
      void EnvProtect ();
 
      void EnvRestore ();
 
    // MqContextC_EnvApi_Env_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ErrorApi-Error,oc_,public
 
      MkErrorC* ErrorFORMAT () const;
 
      // doc-key: MqContextC,MqContextC-ErrorApi-Error,om_,public
 
      MkErrorE ErrorCopy (const MqContextC* sourceCtx) const;
 
      MkErrorE ErrorCopy (const MqContextC& sourceCtx) const;
 
      MkErrorE ErrorMove (const MqContextC* sourceCtx) const;
 
      MkErrorE ErrorMove (const MqContextC& sourceCtx) const;
 
    // MqContextC_ErrorApi_Error_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-HighApi-High,om_,public
 
      void SendVL2 (MK_STRN cstr, va_list var_list);
 
      void SendVL2 (const std::string& cstr, va_list var_list);
 
    // MqContextC_HighApi_High_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-LinkApi-Link,oc_,public
 
      MqContextC* LinkGetParent ();
 
      // doc-key: MqContextC,MqContextC-LinkApi-Link,om_,public
 
      void LinkConnect ();
 
      void LinkCreate (MkBufferListC* args = NULL);
 
      void LinkCreate (const MkBufferListC& args);
 
      void LinkCreateChild (MqContextC* parent, MkBufferListC* args = NULL);
 
      void LinkCreateChild (const MqContextC& parent, const MkBufferListC& args);
 
      void LinkDelete ();
 
      MK_NUM LinkGetCtxId ();
 
      MK_STRN LinkGetTargetIdent ();
 
      MK_BOOL LinkIsConnected ();
 
      MK_BOOL LinkIsParent ();
 
      void LinkShutdown ();
 
    // MqContextC_LinkApi_Link_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-LogApi-Log,om_,public
 
      // skip class-overload: void Log (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const
 
      // skip class-overload: void Log (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const
 
      void LogConfig (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogConfig (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogEnv (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogEnv (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogLink (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogLink (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogSetup (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogSetup (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogShort (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0, MK_STRN label = NULL) const;
 
      void LogShort (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0, MK_STRN label = NULL) const;
 
      void LogType (const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      void LogType (const MkObjectC& fmtobj, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0) const;
 
      MK_STRN LogParentOrChild () const;
 
      MK_STRN LogServerOrClient () const;
 
    // MqContextC_LogApi_Log_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-MiscApi-Misc,oc_,public
 
      MkBufferC* GetBuffer ();
 
      MqContextC* GetRoot ();
 
      // doc-key: MqContextC,MqContextC-MiscApi-Misc,om_,public
 
      // skip class-overload: MK_STRN ToString () const
 
      MK_I32 Exit (MK_STRN callfunc = __builtin_FUNCTION(), MK_STRN callfile = __builtin_FILE(), MK_I32 callline = __builtin_LINE());
 
      void ProcessEvent (MqWaitOnEventE wait = MQ_WAIT_NO, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
    // MqContextC_MiscApi_Misc_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ProxyApi-Proxy,om_,public
 
      void ProxyForward (MqContextC* targetCtx, MqDumpC* dump = NULL, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void ProxyForward (const MqContextC& targetCtx, const MqDumpC& dump, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void ProxyItem (MqContextC* targetCtx);
 
      void ProxyItem (const MqContextC& targetCtx);
 
    // MqContextC_ProxyApi_Proxy_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ReadApi-Atom,oci,public
 
      MkBufferListC* ReadALL (MkBufferListC* val_inout = NULL);
 
      // doc-key: MqContextC,MqContextC-ReadApi-Atom,oco,public
 
      MkBufferListC* ReadBFL ();
 
      MkBufferC* ReadBUF ();
 
      // doc-key: MqContextC,MqContextC-ReadApi-Atom,omo,public
 
      MK_BNP ReadBIN ();
 
      MK_BOL ReadBOL ();
 
      MK_BNP ReadBinaryR ();
 
      MK_DBL ReadDBL ();
 
      MK_FLT ReadFLT ();
 
      MK_HDL ReadHDL ();
 
      MK_I16 ReadI16 ();
 
      MK_I32 ReadI32 ();
 
      MK_I64 ReadI64 ();
 
      MK_I8 ReadI8 ();
 
      MkBufferListC* ReadLIST ();
 
      MK_LONG ReadLONG ();
 
      MkBufferC* ReadNEXT ();
 
      MK_STRN ReadSTR ();
 
      std::string ReadStringR ();
 
    // MqContextC_ReadApi_Atom_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ReadApi-Block,om_,public
 
      void ReadL_END ();
 
      void ReadL_START (MkBufferC* buf = NULL);
 
      void ReadL_START (const MkBufferC& buf);
 
      void ReadT_END ();
 
      void ReadT_START ();
 
    // MqContextC_ReadApi_Block_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ReadApi-Misc,om_,public
 
      void ReadDbg ();
 
      MkTypeE ReadGetNextType ();
 
      MK_NUM ReadGetNumItems ();
 
      MK_BOOL ReadItemExists ();
 
      void ReadUndo ();
 
    // MqContextC_ReadApi_Misc_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-RouteApi-Route,oco,public
 
      MkBufferListC* RouteGetTree ();
 
      // doc-key: MqContextC,MqContextC-RouteApi-Route,om_,public
 
      void RouteCreate (MK_STRN route, MK_STRN service, MK_BOOL overwrite = false);
 
      void RouteCreate (const std::string& route, const std::string& service, MK_BOOL overwrite = false);
 
      void RouteDelete (MK_STRN route, MK_STRN service, MK_BOOL overwrite = false);
 
      void RouteDelete (const std::string& route, const std::string& service, MK_BOOL overwrite = false);
 
      MqContextC_A RouteResolve (MK_STRN ident, MK_NUM retnum = -1);
 
      MqContextC_A RouteResolve (const std::string& ident, MK_NUM retnum = -1);
 
      void RouteTraverse (MK_STRN service, MkBufferListC* args = NULL);
 
      void RouteTraverse (MK_STRN service, const MkBufferListC& args);
 
      void RouteTraverse (const std::string& service, MkBufferListC* args = NULL);
 
      void RouteTraverse (const std::string& service, const MkBufferListC& args);
 
      // doc-key: MqContextC,MqContextC-RouteApi-Route,omo,public
 
      MK_STRN RouteGetPath ();
 
    // MqContextC_RouteApi_Route_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-SendApi-Atom,om_,public
 
      void SendBFL (const MkBufferListC* val);
 
      void SendBFL (const MkBufferListC& val);
 
      void SendBIN (MK_BNP val);
 
      void SendBOL (MK_BOL val);
 
      void SendBUF (const MkBufferC* val);
 
      void SendBUF (const MkBufferC& val);
 
      void SendBUS_FLAT (const MkBufferStreamC* val);
 
      void SendBUS_FLAT (const MkBufferStreamC& val);
 
      void SendBinaryR (MK_BNP val);
 
      void SendDBL (MK_DBL val);
 
      void SendFLT (MK_FLT val);
 
      void SendHDL (MK_HDL val);
 
      void SendI16 (MK_I16 val);
 
      void SendI32 (MK_I32 val);
 
      void SendI64 (MK_I64 val);
 
      void SendI8 (MK_I8 val);
 
      void SendLONG (MK_LONG val);
 
      void SendLTR (MQ_LTR transLId);
 
      void SendL_FLAT (const MkBufferListC* val);
 
      void SendL_FLAT (const MkBufferListC& val);
 
      void SendSTR (MK_STRN val);
 
      void SendSTR (const std::string& val);
 
      void SendStringR (const std::string& val);
 
      void SendV (MK_FST printfmt, ... ) __attribute__ ((format (printf, 2, 3)));
 
      void SendVL (MK_FST printfmt, va_list var_list);
 
    // MqContextC_SendApi_Atom_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-SendApi-Basics,om_,public
 
      void SendEND (MQ_TOK token, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND (const std::string& token, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_CALLBACK (MQ_TOK token, MqServiceCCB callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_CALLBACK (const std::string& token, MqServiceCCB callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_CALLBACK (MQ_TOK token, MqServiceICB callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_CALLBACK (const std::string& token, MqServiceICB callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_CALLBACK (MQ_TOK token, MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_CALLBACK (const std::string& token, MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_SUB (MQ_TOK token, MqServiceCCB callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_SUB (const std::string& token, MqServiceCCB callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_SUB (MQ_TOK token, MqServiceICB callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_SUB (const std::string& token, MqServiceICB callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_SUB (MQ_TOK token, MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_SUB (const std::string& token, MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_TRANSACTION (MQ_TOK token, MQ_TOK callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_TRANSACTION (const std::string& token, const std::string& callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_WAIT (MQ_TOK token, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendEND_AND_WAIT (const std::string& token, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT);
 
      void SendSTART ();
 
      void SendSYNC ();
 
    // MqContextC_SendApi_Basics_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-SendApi-Block,om_,public
 
      void SendL_END ();
 
      void SendL_START ();
 
      void SendT_END ();
 
      void SendT_START ();
 
    // MqContextC_SendApi_Block_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-SendApi-Return,om_,public
 
      void SendERROR ();
 
      void SendRETURN ();
 
      void SendRETURN_SUB ();
 
    // MqContextC_SendApi_Return_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-ServiceApi-Service,om_,public
 
      void ServiceCreate (MQ_TOK token, MqServiceCCB callback);
 
      void ServiceCreate (const std::string& token, MqServiceCCB callback);
 
      void ServiceCreate (MQ_TOK token, MqServiceICB callback);
 
      void ServiceCreate (const std::string& token, MqServiceICB callback);
 
      void ServiceCreate (MQ_TOK token, MqServiceIF* callback);
 
      void ServiceCreate (const std::string& token, MqServiceIF* callback);
 
      void ServiceDelete (MQ_TOK token);
 
      void ServiceDelete (const std::string& token);
 
      MK_BOOL ServiceIsTransaction ();
 
      void ServiceProxy (MQ_TOK token, MQ_SLAVE_ID id = MQ_SLAVE_OTHER);
 
      void ServiceProxy (const std::string& token, MQ_SLAVE_ID id = MQ_SLAVE_OTHER);
 
      void ServiceProxyCtx (MQ_TOK token, MqContextC* target);
 
      void ServiceProxyCtx (MQ_TOK token, const MqContextC& target);
 
      void ServiceProxyCtx (const std::string& token, MqContextC* target);
 
      void ServiceProxyCtx (const std::string& token, const MqContextC& target);
 
      MK_BOOL ServiceProxyCtxExists (MQ_TOK token, MqContextC* target);
 
      MK_BOOL ServiceProxyCtxExists (MQ_TOK token, const MqContextC& target);
 
      MK_BOOL ServiceProxyCtxExists (const std::string& token, MqContextC* target);
 
      MK_BOOL ServiceProxyCtxExists (const std::string& token, const MqContextC& target);
 
      void ServiceProxyRoundRobin (MQ_TOK token, MK_STRN ident);
 
      void ServiceProxyRoundRobin (const std::string& token, const std::string& ident);
 
      void ServiceStorage (MQ_TOK token);
 
      void ServiceStorage (const std::string& token);
 
      MK_BOOL ServiceTokenCheck (MQ_TOK token);
 
      MK_BOOL ServiceTokenCheck (const std::string& token);
 
      MK_BOOL ServiceTokenExists (MQ_TOK token);
 
      MK_BOOL ServiceTokenExists (const std::string& token);
 
      MQ_TOK ServiceTokenGet ();
 
    // MqContextC_ServiceApi_Service_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-SlaveApi-Slave,oc_,public
 
      MqContextC* SlaveGetMaster ();
 
      // doc-key: MqContextC,MqContextC-SlaveApi-Slave,oco,public
 
      MqContextC* SlaveGet (MQ_SLAVE_ID id);
 
      MqContextC* SlaveGetFilter ();
 
      MqContextC* SlaveGetProxy (MQ_SLAVE_ID id);
 
      // doc-key: MqContextC,MqContextC-SlaveApi-Slave,om_,public
 
      MK_BOOL SlaveCheck (MQ_SLAVE_ID id) const;
 
      void SlaveCreate (MQ_SLAVE_ID id, MqContextC* slave);
 
      void SlaveCreate (MQ_SLAVE_ID id, const MqContextC& slave);
 
      void SlaveDelete (MQ_SLAVE_ID id);
 
      MK_BOOL SlaveIs () const;
 
      void SlaveWorker (MQ_SLAVE_ID id, MK_STRN fct = "WORKER", MkBufferListC* args = NULL);
 
    // MqContextC_SlaveApi_Slave_CC_API
 
 
    public:
 
      // doc-key: MqContextC,MqContextC-StorageApi-Storage,oci,public
 
      MQ_LTR StorageDelete (MQ_LTR *transLIdP_inout = 0);
 
      MQ_LTR StorageImport (MQ_LTR *transLIdP_inout = 0);
 
      // doc-key: MqContextC,MqContextC-StorageApi-Storage,om_,public
 
      void StorageClose ();
 
      void StorageDecrRef (MQ_LTR transLId);
 
      void StorageIncrRef (MQ_LTR transLId);
 
      void StorageLog (MK_STRN callfunc = __builtin_FUNCTION());
 
      void StorageOpen (MK_STRN storageFile);
 
      void StorageOpen (const std::string& storageFile);
 
      // doc-key: MqContextC,MqContextC-StorageApi-Storage,omo,public
 
      MQ_LTR StorageCount ();
 
      MK_I32 StorageErrCnt (MQ_LTR transLId);
 
      MQ_LTR StorageExport ();
 
      std::tuple<MqContextC*,MQ_LTR> StorageResolve ();
 
    // MqContextC_StorageApi_Storage_CC_API
 
 
    private:
 
      // doc-key: MqContextC,MqContextC-TOR,sCc,private
 
      static MK_OBJ CTOR (MqContextC* tmpl = NULL);
 
    public:
 
      // doc-key: MqContextC,MqContextC-TOR,sCc,public
 
      static MqContextC* Create (MqContextC* tmpl = NULL);
 
      MqContextC (MqContextC* tmpl = NULL) : MkObjectC(CTOR(tmpl)) {};
 
    // MqContextC_TOR_CC_API
 
    //   END-MqContextC - created by 'cc_MqS.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
      
    private:
      static inline MK_OBJ CTOR (MK_TYP const typ, MqContextC* tmpl = NULL);
 
    public:
 
      inline bool isParent()  {return (MQ_IS_PARENT (reinterpret_cast<MQ_CTX>(hdl)));}
      inline bool isChild()   {return (MQ_IS_CHILD  (reinterpret_cast<MQ_CTX>(hdl)));}
      inline bool isMaster()  {return (MQ_IS_MASTER (reinterpret_cast<MQ_CTX>(hdl)));}
      inline bool isSlave()   {return (MQ_IS_SLAVE  (reinterpret_cast<MQ_CTX>(hdl)));}
 
 
    public:
      
      //void LinkCreate (const MkBufferListC& argv);
      
      //void LinkCreateChild (const MqContextC& parent, const MkBufferListC& argv);
 
      // following methods are added "on-demand"
      void LinkCheckOptionI32 (MK_STRN opt, MK_I32 *val);
 
 
 
    private:
 
      MkBufferListC* SendVA ( MK_STRN cstr, MqTokenF const fCall, MK_PTR data, MqDataFreeF fFree, va_list ap);
 
    public:
 
      MkBufferListC* Send (MK_STRN cstr, ...);
      MkBufferListC* Send (const std::string&  str, ...);
 
      MkBufferListC* Send (MK_STRN cstr, MqTokenICB const callback, ...);
      MkBufferListC* Send (const std::string&  str, MqTokenICB const callback, ...);
 
      MkBufferListC* Send (MK_STRN cstr, MqTokenCCB const callback, ...);
      MkBufferListC* Send (const std::string&  str, MqTokenCCB const callback, ...);
 
      MkBufferListC* Send (MK_STRN cstr, MqServiceIF * const service, ...);
      MkBufferListC* Send (const std::string&  str, MqServiceIF * const service, ...);
 
 
 
    public:
 
      inline void SlaveWorker (MK_NUM id, MK_STRN factory, const MkBufferListC& args);
 
    
    protected:
      MqContextC (MK_TYP const typ, MqContextC* tmpl = NULL) : MkObjectC(CTOR(typ,tmpl)) {};
  
  }; // class
} // namespace