Inheritance diagram for Filter6:

Collaboration diagram for Filter6:

Static Public Member Functions
static void	Help (MK_STRN base)

Static Public Member Functions inherited from ccmqmsgque::MqContextC
static MqContextC *	MqContextC_ObjNew (MK_RT mkrt, MQ_CTX hdl)
	return MqContextC from LibMsgqueObject

static MQ_CTX	getCTX (MqContextC *clsHdl)
	return LibMsgqueObject from current MqContextC pointer

static MQ_CTX	getCTX__null_allow (MqContextC *clsHdl)
	return LibMsgqueObject from current MqContextC pointer

static MQ_CTXN	getCTXN (const MqContextC *clsHdl)
	(const) return LibMsgqueObject from current MqContextC pointer

static MQ_CTXN	getCTXN__null_allow (const MqContextC *clsHdl)
	(const) return LibMsgqueObject from current MqContextC pointer

static MQ_CTX	getCTX (const MqContextC &clsHdl)
	return LibMsgqueObject from current MqContextC reference

static MQ_CTX	getCTX__null_allow (const MqContextC &clsHdl)
	return LibMsgqueObject from current MqContextC reference

static MQ_CTXN	getCTXN (const MqContextC &clsHdl)
	(const) return LibMsgqueObject from current MqContextC reference

static MQ_CTXN	getCTXN__null_allow (const MqContextC &clsHdl)
	(const) return LibMsgqueObject from current MqContextC reference

static MqContextC *	HandleResolve (MK_HDL netHdl)
	`C++: [static] MqContextC* MqContextC::HandleResolve(MK_HDL netHdl)` → C-API Handle-Resolve-Slot - return a MqContextC from *netHdl* or `MK_NULL` if invalid…

static MqContextC *	Instances ()
	`C++: [static] MqContextC* MqContextC::Instances()` → C-API get head-instance from linked-list of MqContextS type …

static MqContextC *	GetNull ()
	`C++: [static] MqContextC* MqContextC::GetNull()` → C-API Null-Slot - return a MqContextC typed `NULL` instance …

static MqContextC *	Create (MqContextC *tmpl=NULL)
	`C++: [constructor,static] MqContextC* MqContextC::Create(MqContextC* tmpl = NULL)` → C-API create and initialize the MqContextC ...

Static Public Member Functions inherited from ccmkkernel::MkObjectC
static MkObjectC *	MkObjectC_ObjNew (MK_RT mkrt, MK_OBJ hdl)

static MK_OBJ	getOBJ (MkObjectC *clsHdl)

static MK_OBJ	getOBJ__null_allow (MkObjectC *clsHdl)

static MK_OBJN	getOBJN (const MkObjectC *clsHdl)

static MK_OBJN	getOBJN__null_allow (const MkObjectC *clsHdl)

static MK_OBJ	getOBJ (const MkObjectC &clsHdl)

static MK_OBJ	getOBJ__null_allow (const MkObjectC &clsHdl)

static MK_OBJN	getOBJN (const MkObjectC &clsHdl)

static MK_OBJN	getOBJN__null_allow (const MkObjectC &clsHdl)

static MkObjectC *	HandleResolve (MK_HDL netHdl)

static void	HandleDeleteByNetHdl (MK_HDL netHdl)

static MkObjectC *	Instances ()

static MkObjectC *	GetNull ()

static void	DbgM (MK_STRN message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0)

static void	DbgM (const std::string &message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0)

static MK_I32	SysHashI32 (MK_STRN key, MK_NUM length=-1)

static MK_I32	SysHashI32 (const std::string &key, MK_NUM length=-1)

static MK_STRN	SysHashSTR (MK_STRN key, MK_NUM length=-1)

static MK_STRN	SysHashSTR (const std::string &key, MK_NUM length=-1)

static void	DeleteCallbackCleanup (MK_STRN ident)

static void	DeleteCallbackCleanup (const std::string &ident)

static void	DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteSCB callback=NULL, MK_STRN filter=NULL)

static void	DeleteCallbackSetup (const std::string &ident, MkObjectDeleteSCB callback=NULL, MK_STRN filter=NULL)

Private Member Functions
	Filter6 (MK_TYP const typ, MqContextC *tmpl=NULL)

void	ErrorWrite ()

void	LOGF ()

void	EXIT ()

void	SOEX ()

void	FilterIn ()

void	Event ()

void	ServerCleanup ()

void	ServerSetup ()

Static Private Member Functions
static void	WRIT (MqContextC *ctx)

Private Attributes
FILE *	FH

regex	rgx

Static Private Attributes
static MK_I32	retryCnt = 3

Friends
class	MqFactoryCT< Filter6 >

Additional Inherited Members
Public Types inherited from ccmqmsgque::MqContextC
typedef void(MqContextC::*)	MqTokenICB()
	instance-callback

typedef MqTokenICB	MqBgErrorICB

typedef MqTokenICB	MqServiceICB

typedef MqTokenICB	MqServerSetupICB

typedef MqTokenICB	MqServerCleanupICB

typedef MqTokenICB	MqEventICB

typedef void(*)	MqTokenCCB(MqContextC *)
	class-callback

typedef MqTokenCCB	MqBgErrorCCB

typedef MqTokenCCB	MqServiceCCB

typedef MqTokenCCB	MqServerSetupCCB

typedef MqTokenCCB	MqServerCleanupCCB

typedef MqTokenCCB	MqEventCCB

Public Types inherited from ccmkkernel::MkObjectC
typedef void(MkObjectC::*)	MkObjectDeleteICB(MkObjectC *)

typedef void(*)	MkObjectDeleteCCB(MkObjectC , MkObjectC )

typedef void(MkObjectC::*	MkObjectDeleteICB) (MkObjectC *)

typedef void(*	MkObjectDeleteCCB) (MkObjectC , MkObjectC )

Public Member Functions inherited from ccmqmsgque::MqContextC
	MqContextC (MQ_CTX hdl)

MQ_CTX	getCTX () const
	return the LibMsgqueObject from current MqContextC instance

MQ_CTX	getCTX__null_allow () const
	return the LibMsgqueObject from current MqContextC instance

MQ_CTXN	getCTXN () const
	(const) return the LibMsgqueObject from current MqContextC instance

MQ_CTXN	getCTXN__null_allow () const
	(const) return the LibMsgqueObject from current MqContextC instance

bool	Check () const
	check if pointer is still valid

void	Init (MK_STRN caller=__builtin_FUNCTION())

	operator MqContextC * ()

MqContextC *	Next ()
	`C++: MqContextC* ctx.Next()` → C-API get next instance from linked-list of MqContextS type

MqContextC *	Prev ()
	`C++: MqContextC* ctx.Prev()` → C-API get previous instance from linked-list of MqContextS type

MqFactoryC *	ClassFactoryGet () const
	`C++: MqFactoryC* ctx.ClassFactoryGet()` → C-API get the MqFactoryC used by the MqContextC

void	ClassFactorySet (MqFactoryC *item)
	`C++: ctx.ClassFactorySet(MqFactoryC* item)` → C-API link the MqContextC to a new MqFactoryC

void	ClassFactorySet (const MqFactoryC &item)
	`C++: ctx.ClassFactorySet(MqFactoryC* item)` → C-API link the MqContextC to a new MqFactoryC

MK_STRN	ClassIdentGet () const
	`C++: MK_STRN ctx.ClassIdentGet()` → C-API get the application-identification …

void	ClassIdentSet (MK_STRN ident)
	`C++: ctx.ClassIdentSet(MK_STRN ident)` → C-API link the MqContextC to a new MqFactoryC identified by ident

void	ClassIdentSet (const std::string &ident)
	`C++: ctx.ClassIdentSet(MK_STRN ident)` → C-API link the MqContextC to a new MqFactoryC identified by ident

MK_STRN	ClassOriginalIdentGet () const
	`C++: MK_STRN ctx.ClassOriginalIdentGet()` → C-API get the libmqmsgque::MqFactoryS::originalIdent from the MqContextC

MkBufferListC *	ConfigGetIoTcpL ()
	`C++: MkBufferListC* ctx.ConfigGetIoTcpL()` → C-API get the configuration-data of the tcp-client-server-link as MkBufferListC …

MK_I32	ConfigGetBuffersize () const
	`C++: MK_I32 ctx.ConfigGetBuffersize()` → C-API get the minimum of the read/send buffersize of the socket

MqIdentE	ConfigGetIdentFrom ()
	`C++: MqIdentE ctx.ConfigGetIdentFrom()` → C-API get the libmqmsgque::MqConfigS::identFrom

MQ_SOCK_HDL	ConfigGetIoPipe ()
	`C++: MQ_SOCK_HDL ctx.ConfigGetIoPipe()` → C-API return the libmqmsgque::MqIoPipeConfigS

MK_STRN	ConfigGetIoUds () const
	`C++: MK_STRN ctx.ConfigGetIoUds()` → C-API return the libmqmsgque::MqIoUdsConfigS

MK_BOOL	ConfigGetIsParent ()
	`C++: MK_BOOL ctx.ConfigGetIsParent()` → C-API does the context object is a parent ? An objext is a parent id the libmqmsgque::MqConfigS::parent attribute is `MK_NULL`

MK_BOOL	ConfigGetIsServer ()
	`C++: MK_BOOL ctx.ConfigGetIsServer()` → C-API does the context object is a server ?

MK_BOOL	ConfigGetIsString ()
	`C++: MK_BOOL ctx.ConfigGetIsString()` → C-API does the context object is using the string-mode ?

MK_STRN	ConfigGetName () const
	`C++: MK_STRN ctx.ConfigGetName()` → C-API get the name of the context object

MK_I32	ConfigGetPkgsize () const
	`C++: MK_I32 ctx.ConfigGetPkgsize()` → C-API get the maximun size of a BDY package

MK_STRN	ConfigGetPostfix () const
	`C++: MK_STRN ctx.ConfigGetPostfix()` → C-API get the libmqmsgque::MqConfigS::postfix

MK_STRN	ConfigGetPrefix () const
	`C++: MK_STRN ctx.ConfigGetPrefix()` → C-API get the libmqmsgque::MqConfigS::prefix

MqStartE	ConfigGetStartAs ()
	`C++: MqStartE ctx.ConfigGetStartAs()` → C-API return the libmqmsgque::MqConfigS::startAs value

MqStatusIsEF	ConfigGetStatusIs ()
	`C++: MqStatusIsEF ctx.ConfigGetStatusIs()` → C-API return the libmqmsgque::MqContextS::statusIs value

MK_STRN	ConfigGetStorage () const
	`C++: MK_STRN ctx.ConfigGetStorage()` → C-API get the storage of the context object

MK_TIME_T	ConfigGetTimeout () const
	`C++: MK_TIME_T ctx.ConfigGetTimeout()` → C-API get the timeout value of the context object

void	ConfigSetConfigFile (MK_STRN filename)
	`C++: ctx.ConfigSetConfigFile(MK_STRN filename)` → C-API set the config-file and parse for well-known config-items

void	ConfigSetConfigFile (const std::string &filename)
	`C++: ctx.ConfigSetConfigFile(MK_STRN filename)` → C-API set the config-file and parse for well-known config-items

std::tuple< MK_STRN, MK_STRN, MK_STRN, MK_STRN >	ConfigGetIoTcp ()
	`C++: {host:MK_STRN port:MK_STRN myhost:MK_STRN myport:MK_STRN} ctx.ConfigGetIoTcp()` → C-API get the configuration-data of the tcp-client-server-link …

void	ConfigSetBgError (MqBgErrorCCB callback=NULL)
	`C++: ctx.ConfigSetBgError(MqBgErrorICB MqBgErrorCCB MqBgErrorIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::BgError

void	ConfigSetBgError (MqBgErrorICB callback=NULL)
	`C++: ctx.ConfigSetBgError(MqBgErrorICB MqBgErrorCCB MqBgErrorIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::BgError

void	ConfigSetBgError (MqBgErrorIF *callback=NULL)
	`C++: ctx.ConfigSetBgError(MqBgErrorICB MqBgErrorCCB MqBgErrorIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::BgError

void	ConfigSetEvent (MqEventCCB callback=NULL)
	`C++: ctx.ConfigSetEvent(MqEventICB MqEventCCB MqEventIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::Event

void	ConfigSetEvent (MqEventICB callback=NULL)
	`C++: ctx.ConfigSetEvent(MqEventICB MqEventCCB MqEventIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::Event

void	ConfigSetEvent (MqEventIF *callback=NULL)
	`C++: ctx.ConfigSetEvent(MqEventICB MqEventCCB MqEventIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::Event

void	ConfigSetServerCleanup (MqServerCleanupCCB callback=NULL)
	`C++: ctx.ConfigSetServerCleanup(MqServerCleanupICB MqServerCleanupCCB MqServerCleanupIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::ServerCleanup

void	ConfigSetServerCleanup (MqServerCleanupICB callback=NULL)
	`C++: ctx.ConfigSetServerCleanup(MqServerCleanupICB MqServerCleanupCCB MqServerCleanupIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::ServerCleanup

void	ConfigSetServerCleanup (MqServerCleanupIF *callback=NULL)
	`C++: ctx.ConfigSetServerCleanup(MqServerCleanupICB MqServerCleanupCCB MqServerCleanupIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::ServerCleanup

void	ConfigSetServerSetup (MqServerSetupCCB callback=NULL)
	`C++: ctx.ConfigSetServerSetup(MqServerSetupICB MqServerSetupCCB MqServerSetupIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::ServerSetup

void	ConfigSetServerSetup (MqServerSetupICB callback=NULL)
	`C++: ctx.ConfigSetServerSetup(MqServerSetupICB MqServerSetupCCB MqServerSetupIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::ServerSetup

void	ConfigSetServerSetup (MqServerSetupIF *callback=NULL)
	`C++: ctx.ConfigSetServerSetup(MqServerSetupICB MqServerSetupCCB MqServerSetupIF* callback = NULL)` → C-API set the libmqmsgque::MqSetupS::ServerSetup

void	ConfigReset ()
	`C++: ctx.ConfigReset()` → C-API clean the libmqmsgque::MqContextS::config data

MK_BOOL	ConfigCheckStartAs (MqStartE data)
	`C++: MK_BOOL ctx.ConfigCheckStartAs(MqStartE data)` → C-API check if libmqmsgque::MqConfigS::startAs can be set to data

void	ConfigSetAllDebug (MK_I32 data)
	`C++: ctx.ConfigSetAllDebug(MK_I32 data)` → C-API set the MkRuntimeS::debug value

void	ConfigSetBuffersize (MK_I32 data)
	`C++: ctx.ConfigSetBuffersize(MK_I32 data)` → C-API set the libmqmsgque::MqIoConfigS::buffersize value

void	ConfigSetDaemon (MK_STRN pidfile)
	`C++: ctx.ConfigSetDaemon(MK_STRN pidfile)` → C-API start the server-context as daemon …

void	ConfigSetDaemon (const std::string &pidfile)
	`C++: ctx.ConfigSetDaemon(MK_STRN pidfile)` → C-API start the server-context as daemon …

void	ConfigSetIdentFrom (MqIdentE data)
	`C++: ctx.ConfigSetIdentFrom(MqIdentE data)` → C-API set the libmqmsgque::MqConfigS::identFrom value

void	ConfigSetIgnoreExit (MK_BOOL data)
	`C++: ctx.ConfigSetIgnoreExit(MK_BOOL data)` → C-API set the libmqmsgque::MqSetupS::ignoreExit value

void	ConfigSetIoPipe (MQ_SOCK_HDL fh)
	`C++: ctx.ConfigSetIoPipe(MQ_SOCK_HDL fh)` → C-API set the pipe configuration data …

void	ConfigSetIoTcp (MK_STRN host=NULL, MK_STRN port=NULL, MK_STRN myhost=NULL, MK_STRN myport=NULL)
	`C++: ctx.ConfigSetIoTcp(MK_STRN host = NULL, MK_STRN port = NULL, MK_STRN myhost = NULL, MK_STRN myport = NULL)` → C-API configure a context to use a tcp-client-server-link …

void	ConfigSetIoTcp (MkBufferListC *vals)
	`C++: ctx.ConfigSetIoTcp(MkBufferListC* vals)` → C-API configure a context to use a tcp-client-server-link …

void	ConfigSetIoTcp (const MkBufferListC &vals)
	`C++: ctx.ConfigSetIoTcp(MkBufferListC* vals)` → C-API configure a context to use a tcp-client-server-link …

void	ConfigSetIoUds (MK_STRN file)
	`C++: ctx.ConfigSetIoUds(MK_STRN file)` → C-API configure a context to use a uds-client-server-link …

void	ConfigSetIoUds (const std::string &file)
	`C++: ctx.ConfigSetIoUds(MK_STRN file)` → C-API configure a context to use a uds-client-server-link …

void	ConfigSetIsServer (MK_BOOL data)
	`C++: ctx.ConfigSetIsServer(MK_BOOL data)` → C-API set the libmqmsgque::MqSetupS::isServer value

void	ConfigSetIsString (MK_BOOL data)
	`C++: ctx.ConfigSetIsString(MK_BOOL data)` → C-API set the libmqmsgque::MqConfigS::native value 'S'string or 'L'owEndian or 'B'igEndian

void	ConfigSetName (MK_STRN data)
	`C++: ctx.ConfigSetName(MK_STRN data)` → C-API set the libmqmsgque::MqConfigS::dispname value and cleanup old value

void	ConfigSetName (const std::string &data)
	`C++: ctx.ConfigSetName(MK_STRN data)` → C-API set the libmqmsgque::MqConfigS::dispname value and cleanup old value

void	ConfigSetPkgsize (MK_I32 data)
	`C++: ctx.ConfigSetPkgsize(MK_I32 data)` → C-API set the libmqmsgque::MqIoConfigS::pkgsize value

void	ConfigSetPostfix (MK_STRN data)
	`C++: ctx.ConfigSetPostfix(MK_STRN data)` → C-API set the client-part (2) of the application-identifer libmqmsgque::MqConfigS::dispname …

void	ConfigSetPostfix (const std::string &data)
	`C++: ctx.ConfigSetPostfix(MK_STRN data)` → C-API set the client-part (2) of the application-identifer libmqmsgque::MqConfigS::dispname …

void	ConfigSetPrefix (MK_STRN data)
	`C++: ctx.ConfigSetPrefix(MK_STRN data)` → C-API set the server-part (1) of the application-identifer libmqmsgque::MqConfigS::dispname …

void	ConfigSetPrefix (const std::string &data)
	`C++: ctx.ConfigSetPrefix(MK_STRN data)` → C-API set the server-part (1) of the application-identifer libmqmsgque::MqConfigS::dispname …

void	ConfigSetStartAs (MqStartE data)
	`C++: ctx.ConfigSetStartAs(MqStartE data)` → C-API set the libmqmsgque::MqConfigS::startAs value

void	ConfigSetStartAsString (MK_STRN data)
	`C++: ctx.ConfigSetStartAsString(MK_STRN data)` → C-API set the libmqmsgque::MqConfigS::startAs value using string `default`, `thread`, `fork` or `spawn`

void	ConfigSetStartAsString (const std::string &data)
	`C++: ctx.ConfigSetStartAsString(MK_STRN data)` → C-API set the libmqmsgque::MqConfigS::startAs value using string `default`, `thread`, `fork` or `spawn`

void	ConfigSetStorage (MK_STRN data)
	`C++: ctx.ConfigSetStorage(MK_STRN data)` → C-API set the Storage value and cleanup old value

void	ConfigSetStorage (const std::string &data)
	`C++: ctx.ConfigSetStorage(MK_STRN data)` → C-API set the Storage value and cleanup old value

void	ConfigSetTimeout (MK_TIME_T data)
	`C++: ctx.ConfigSetTimeout(MK_TIME_T data)` → C-API set the libmqmsgque::MqIoConfigS::timeout value

void	EnvProtect ()
	`C++: ctx.EnvProtect()` → C-API protect the service-environment

void	EnvRestore ()
	`C++: ctx.EnvRestore()` → C-API restore the service-environment

MkErrorC *	ErrorFORMAT () const
	`C++: MkErrorC* fmtobj.ErrorFORMAT()` → C-API helper used to access MkErrorDEFAULT from MqContextC

MkErrorE	ErrorCopy (const MqContextC *sourceCtx) const
	`C++: MkErrorE targetCtx.ErrorCopy(const MqContextC* sourceCtx)` → C-API copy a MkErrorS from the sourceCtx to the targetCtx …

MkErrorE	ErrorCopy (const MqContextC &sourceCtx) const
	`C++: MkErrorE targetCtx.ErrorCopy(const MqContextC* sourceCtx)` → C-API copy a MkErrorS from the sourceCtx to the targetCtx …

MkErrorE	ErrorMove (const MqContextC *sourceCtx) const
	`C++: MkErrorE targetCtx.ErrorMove(const MqContextC* sourceCtx)` → C-API move a MkErrorS from the sourceCtx to the targetCtx …

MkErrorE	ErrorMove (const MqContextC &sourceCtx) const
	`C++: MkErrorE targetCtx.ErrorMove(const MqContextC* sourceCtx)` → C-API move a MkErrorS from the sourceCtx to the targetCtx …

void	SendVL2 (MK_STRN cstr, va_list var_list)
	`C++: ctx.SendVL2(MK_STRN cstr, va_list var_list)` → C-API A version of MqSend with *va_list* support …

void	SendVL2 (const std::string &cstr, va_list var_list)
	`C++: ctx.SendVL2(MK_STRN cstr, va_list var_list)` → C-API A version of MqSend with *va_list* support …

MqContextC *	LinkGetParent ()
	`C++: MqContextC* ctx.LinkGetParent()` → C-API get the initial parent-context from a client/server link …

void	LinkConnect ()
	`C++: ctx.LinkConnect()` → C-API re-connect a client-server-link after a server crash or a network downtime …

void	LinkCreate (MkBufferListC *args=NULL)
	`C++: ctx.LinkCreate(MkBufferListC* args = NULL)` → C-API make ctx to a parent-context and setup a new client-server-link …

void	LinkCreate (const MkBufferListC &args)
	`C++: ctx.LinkCreate(MkBufferListC* args = NULL)` → C-API make ctx to a parent-context and setup a new client-server-link …

void	LinkCreateChild (MqContextC parent, MkBufferListC args=NULL)
	`C++: ctx.LinkCreateChild(MqContextC* parent, MkBufferListC* args = NULL)` → C-API make a context to a child-context on-top of an existing parent-client-server-link …

void	LinkCreateChild (const MqContextC &parent, const MkBufferListC &args)
	`C++: ctx.LinkCreateChild(MqContextC* parent, MkBufferListC* args = NULL)` → C-API make a context to a child-context on-top of an existing parent-client-server-link …

void	LinkDelete ()
	`C++: ctx.LinkDelete()` → C-API close the client-server-link …

MK_NUM	LinkGetCtxId ()
	`C++: MK_NUM ctx.LinkGetCtxId()` → C-API get an identifier which is unique per parent-or-child-context …

MK_STRN	LinkGetTargetIdent ()
	`C++: MK_STRN ctx.LinkGetTargetIdent()` → C-API get the ident of the link-target …

MK_BOOL	LinkIsConnected ()
	`C++: MK_BOOL ctx.LinkIsConnected()` → C-API is the context connected? …

MK_BOOL	LinkIsParent ()
	`C++: MK_BOOL ctx.LinkIsParent()` → C-API is the context a parent-context? …

void	LinkShutdown ()
	`C++: ctx.LinkShutdown()` → C-API shutdown the communication with a server

void	LogConfig (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogConfig(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part libmqmsgque::MqConfigS …

void	LogConfig (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogConfig(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part libmqmsgque::MqConfigS …

void	LogEnv (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogEnv(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part libmqmsgque::MqEnvS …

void	LogEnv (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogEnv(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part libmqmsgque::MqEnvS …

void	LogLink (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogLink(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part libmqmsgque::MqLinkS …

void	LogLink (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogLink(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part libmqmsgque::MqLinkS …

void	LogSetup (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogSetup(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part libmqmsgque::MqSetupS …

void	LogSetup (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogSetup(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part libmqmsgque::MqSetupS …

void	LogShort (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0, MK_STRN label=NULL) const
	`C++: ctx.LogShort(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0, MK_STRN label = NULL)` → C-API log the MqContextC with less info then MqContextLog …

void	LogShort (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0, MK_STRN label=NULL) const
	`C++: ctx.LogShort(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0, MK_STRN label = NULL)` → C-API log the MqContextC with less info then MqContextLog …

void	LogType (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogType(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part MkTypeS …

void	LogType (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: ctx.LogType(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MqContextC part MkTypeS …

MK_STRN	LogParentOrChild () const
	`C++: MK_STRN ctx.LogParentOrChild()` → C-API is ctx a PARENT or a CHILD ? …

MK_STRN	LogServerOrClient () const
	`C++: MK_STRN ctx.LogServerOrClient()` → C-API is ctx a SERVER or a CLIENT ? …

MkBufferC *	GetBuffer ()
	`C++: MkBufferC* ctx.GetBuffer()` → C-API get the libmqmsgque::MqContextS::ctxbuf object

MqContextC *	GetRoot ()
	`C++: MqContextC* ctx.GetRoot()` → C-API get the Root (toplevel initial context)

void	Exit (MK_STRN callfunc=__builtin_FUNCTION(), MK_STRN callfile=__builtin_FILE(), MK_I32 callline=__builtin_LINE())
	`C++: ctx.Exit(MK_STRN callfunc = __builtin_FUNCTION(), MK_STRN callfile = __builtin_FILE(), MK_I32 callline = __builtin_LINE())` → C-API delete the context and exit the current process or thread …

void	ProcessEvent (MqWaitOnEventE wait=MQ_WAIT_NO, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.ProcessEvent(MqWaitOnEventE wait = MQ_WAIT_NO, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API enter the event-loop and wait for an incoming service-request. …

void	ProxyForward (MqContextC targetCtx, MqDumpC dump=NULL, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: sourceCtx.ProxyForward(MqContextC* targetCtx, MqDumpC* dump = NULL, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API send the entire read-data-package-data to the link-target …

void	ProxyForward (const MqContextC &targetCtx, const MqDumpC &dump, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: sourceCtx.ProxyForward(MqContextC* targetCtx, MqDumpC* dump = NULL, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API send the entire read-data-package-data to the link-target …

void	ProxyItem (MqContextC *targetCtx)
	`C++: sourceCtx.ProxyItem(MqContextC* targetCtx)` → C-API Copy a single-data-item from the sourceCtx to the targetCtx.

void	ProxyItem (const MqContextC &targetCtx)
	`C++: sourceCtx.ProxyItem(MqContextC* targetCtx)` → C-API Copy a single-data-item from the sourceCtx to the targetCtx.

MkBufferListC *	ReadALL (MkBufferListC *val_inout=NULL)
	`C++: MkBufferListC* ctx.ReadALL(MkBufferListC* val_inout = NULL)` → C-API get a temporary MkBufferListC from all data in the read-data-package …

MkBufferListC *	ReadBFL ()
	`C++: MkBufferListC* ctx.ReadBFL()` → C-API get a temporary MkBufferListC from next list-item in the read-data-package …

MkBufferC *	ReadBUF ()
	`C++: MkBufferC* ctx.ReadBUF()` → C-API get a temporary MkBufferC from the read-data-package …

MK_BNP	ReadBIN ()
	`C++: doc_mq_cc_ReadBIN` → C-API generic function to read an libmkkernel::MK_BIN object from the read-data-package object …

MK_BOL	ReadBOL ()
	`C++: doc_mq_cc_ReadBOL` → C-API read a PRIMITIVE TYPE from the read-data-package …

MK_BNP	ReadBinaryR ()
	`C++: MK_BNP ctx.ReadBinaryR()` → C-API read a MkBinaryR from the read-data-package …

MK_DBL	ReadDBL ()
	`C++: doc_mq_cc_ReadDBL` → C-API read a PRIMITIVE TYPE from the read-data-package …

MK_FLT	ReadFLT ()
	`C++: doc_mq_cc_ReadFLT` → C-API read a PRIMITIVE TYPE from the read-data-package …

MK_HDL	ReadHDL ()
	`C++: MK_HDL ctx.ReadHDL()` → C-API read the handle from the read-data-package

MK_I16	ReadI16 ()
	`C++: doc_mq_cc_ReadI16` → C-API read a PRIMITIVE TYPE from the read-data-package …

MK_I32	ReadI32 ()
	`C++: doc_mq_cc_ReadI32` → C-API read a PRIMITIVE TYPE from the read-data-package …

MK_I64	ReadI64 ()
	`C++: doc_mq_cc_ReadI64` → C-API read a PRIMITIVE TYPE from the read-data-package …

MK_I8	ReadI8 ()
	`C++: doc_mq_cc_ReadI8` → C-API read a PRIMITIVE TYPE from the read-data-package …

MkBufferListC *	ReadLIST ()
	`C++: MkBufferListC* ctx.ReadLIST()` → C-API get all arguments as native list …

MK_LONG	ReadLONG ()
	`C++: MK_LONG ctx.ReadLONG()` → C-API read the long native object from the read-data-package

MkBufferC *	ReadNEXT ()
	`C++: MkBufferC* ctx.ReadNEXT()` → C-API get the next argument as native object …

MK_STRN	ReadSTR ()
	`C++: doc_mq_cc_ReadSTR` → C-API read a PRIMITIVE TYPE from the read-data-package …

std::string	ReadStringR ()
	`C++: std::string ctx.ReadStringR()` → C-API read a MkStringR from the read-data-package …

void	ReadL_END ()
	`C++: ctx.ReadL_END()` → C-API finish to extract a list-items from the read-data-package. …

void	ReadL_START (MkBufferC *buf=NULL)
	`C++: ctx.ReadL_START(MkBufferC* buf = NULL)` → C-API start to extract a list-items from the read-data-package. …

void	ReadL_START (const MkBufferC &buf)
	`C++: ctx.ReadL_START(MkBufferC* buf = NULL)` → C-API start to extract a list-items from the read-data-package. …

void	ReadT_END ()
	`C++: ctx.ReadT_END()` → C-API finish to extract a longterm-transaction-item from the read-data-package. …

void	ReadT_START ()
	`C++: ctx.ReadT_START()` → C-API start to extract a longterm-transaction-item from the read-data-package. …

void	ReadDbg ()
	ReadDbg

MkTypeE	ReadGetNextType ()
	`C++: MkTypeE ctx.ReadGetNextType()` → C-API get the type (MkTypeE) of the next Item in the read-data-buffer or "0" if not available

MK_NUM	ReadGetNumItems ()
	`C++: MK_NUM ctx.ReadGetNumItems()` → C-API get the number of items left in the read-data-package …

MK_BOOL	ReadItemExists ()
	`C++: MK_BOOL ctx.ReadItemExists()` → C-API check if an item exists in the read-data-package …

void	ReadUndo ()
	`C++: ctx.ReadUndo()` → C-API undo the last MqContextC READ API function call …

MkBufferListC *	RouteGetTree ()
	`C++: MkBufferListC* ctx.RouteGetTree()` → C-API create an overview about all available routing-target and services …

void	RouteCreate (MK_STRN route, MK_STRN service, MK_BOOL overwrite=false)
	`C++: ctx.RouteCreate(MK_STRN route, MK_STRN service, MK_BOOL overwrite = false)` → C-API create/delete a routing-link between context an a service using route

void	RouteCreate (const std::string &route, const std::string &service, MK_BOOL overwrite=false)
	`C++: ctx.RouteCreate(MK_STRN route, MK_STRN service, MK_BOOL overwrite = false)` → C-API create/delete a routing-link between context an a service using route

void	RouteDelete (MK_STRN route, MK_STRN service, MK_BOOL overwrite=false)
	`C++: ctx.RouteDelete(MK_STRN route, MK_STRN service, MK_BOOL overwrite = false)` → C-API delete a routing-link created with MqRouteCreate

void	RouteDelete (const std::string &route, const std::string &service, MK_BOOL overwrite=false)
	`C++: ctx.RouteDelete(MK_STRN route, MK_STRN service, MK_BOOL overwrite = false)` → C-API delete a routing-link created with MqRouteCreate

MqContextC_A	RouteResolve (MK_STRN ident, MK_NUM retnum=-1)
	`C++: MqContextC_A ctx.RouteResolve(MK_STRN ident, MK_NUM retnum = -1)` → C-API return a list of all context belonging to ident …

MqContextC_A	RouteResolve (const std::string &ident, MK_NUM retnum=-1)
	`C++: MqContextC_A ctx.RouteResolve(MK_STRN ident, MK_NUM retnum = -1)` → C-API return a list of all context belonging to ident …

void	RouteTraverse (MK_STRN service, MkBufferListC *args=NULL)
	`C++: ctx.RouteTraverse(MK_STRN service, MkBufferListC* args = NULL)` → C-API traverse a tree down and call service if available.

void	RouteTraverse (MK_STRN service, const MkBufferListC &args)
	`C++: ctx.RouteTraverse(MK_STRN service, MkBufferListC* args = NULL)` → C-API traverse a tree down and call service if available.

void	RouteTraverse (const std::string &service, MkBufferListC *args=NULL)
	`C++: ctx.RouteTraverse(MK_STRN service, MkBufferListC* args = NULL)` → C-API traverse a tree down and call service if available.

void	RouteTraverse (const std::string &service, const MkBufferListC &args)
	`C++: ctx.RouteTraverse(MK_STRN service, MkBufferListC* args = NULL)` → C-API traverse a tree down and call service if available.

MK_STRN	RouteGetPath ()
	`C++: MK_STRN ctx.RouteGetPath()` → C-API return the absolut route-connection-string up to the current ctx …

void	SendBFL (const MkBufferListC *val)
	`C++: ctx.SendBFL(const MkBufferListC* val)` → C-API append a MkBufferListC object to the send-data-package object …

void	SendBFL (const MkBufferListC &val)
	`C++: ctx.SendBFL(const MkBufferListC* val)` → C-API append a MkBufferListC object to the send-data-package object …

void	SendBIN (MK_BNP val)
	`C++: doc_mq_cc_SendBIN` → C-API append a libmkkernel::MK_BIN object to the send-data-package. …

void	SendBOL (MK_BOL val)
	`C++: doc_mq_cc_SendBOL` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendBUF (const MkBufferC *val)
	`C++: ctx.SendBUF(const MkBufferC* val)` → C-API append a MkBufferC object to the send-data-package object …

void	SendBUF (const MkBufferC &val)
	`C++: ctx.SendBUF(const MkBufferC* val)` → C-API append a MkBufferC object to the send-data-package object …

void	SendBUS_FLAT (const MkBufferStreamC *val)
	`C++: ctx.SendBUS_FLAT(const MkBufferStreamC* val)` → C-API append a MkBufferStreamC object to the send-data-package object …

void	SendBUS_FLAT (const MkBufferStreamC &val)
	`C++: ctx.SendBUS_FLAT(const MkBufferStreamC* val)` → C-API append a MkBufferStreamC object to the send-data-package object …

void	SendBinaryR (MK_BNP val)
	`C++: ctx.SendBinaryR(MK_BNP val)` → C-API append a MkBinaryR object to the send-data-package. …

void	SendDBL (MK_DBL val)
	`C++: doc_mq_cc_SendDBL` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendFLT (MK_FLT val)
	`C++: doc_mq_cc_SendFLT` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendHDL (MK_HDL val)
	`C++: ctx.SendHDL(MK_HDL val)` → C-API send the handle to the send-data-package

void	SendI16 (MK_I16 val)
	`C++: doc_mq_cc_SendI16` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendI32 (MK_I32 val)
	`C++: doc_mq_cc_SendI32` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendI64 (MK_I64 val)
	`C++: doc_mq_cc_SendI64` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendI8 (MK_I8 val)
	`C++: doc_mq_cc_SendI8` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendLONG (MK_LONG val)
	`C++: ctx.SendLONG(MK_LONG val)` → C-API send the long native object to the send-data-package

void	SendLTR (MQ_LTR transLId)
	SendLTR

void	SendL_FLAT (const MkBufferListC *val)
	`C++: ctx.SendL_FLAT(const MkBufferListC* val)` → C-API append a MkBufferListC object as flat list of items to the send-data-package object …

void	SendL_FLAT (const MkBufferListC &val)
	`C++: ctx.SendL_FLAT(const MkBufferListC* val)` → C-API append a MkBufferListC object as flat list of items to the send-data-package object …

void	SendSTR (MK_STRN val)
	`C++: doc_mq_cc_SendSTR` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendSTR (const std::string &val)
	`C++: doc_mq_cc_SendSTR` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendStringR (const std::string &val)
	`C++: ctx.SendStringR(const std::string& val)` → C-API MqContextC - append a native PRIMITIVE TYPE value to the send-data-package …

void	SendV (MK_FST printfmt,...)
	`C++: ctx.SendV(MK_FST printfmt, ... )` → C-API append a vararg string to the send-data-package object …

void	SendVL (MK_FST printfmt, va_list var_list)
	`C++: ctx.SendVL(MK_FST printfmt, va_list var_list)` → C-API append a vararg string as va_list to the send-data-package object …

void	SendEND (MQ_TOK token, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND(MQ_TOK token, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service …

void	SendEND (const std::string &token, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND(MQ_TOK token, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service …

void	SendEND_AND_CALLBACK (MQ_TOK token, MqServiceCCB callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_CALLBACK(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …

void	SendEND_AND_CALLBACK (const std::string &token, MqServiceCCB callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_CALLBACK(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …

void	SendEND_AND_CALLBACK (MQ_TOK token, MqServiceICB callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_CALLBACK(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …

void	SendEND_AND_CALLBACK (const std::string &token, MqServiceICB callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_CALLBACK(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …

void	SendEND_AND_CALLBACK (MQ_TOK token, MqServiceIF *callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_CALLBACK(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …

void	SendEND_AND_CALLBACK (const std::string &token, MqServiceIF *callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_CALLBACK(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do not-wait for the result but expect the result on a callback …

void	SendEND_AND_SUB (MQ_TOK token, MqServiceCCB callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_SUB(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …

void	SendEND_AND_SUB (const std::string &token, MqServiceCCB callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_SUB(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …

void	SendEND_AND_SUB (MQ_TOK token, MqServiceICB callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_SUB(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …

void	SendEND_AND_SUB (const std::string &token, MqServiceICB callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_SUB(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …

void	SendEND_AND_SUB (MQ_TOK token, MqServiceIF *callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_SUB(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …

void	SendEND_AND_SUB (const std::string &token, MqServiceIF *callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_SUB(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service, do wait for the result and expect multiple sub-results on a callback …

void	SendEND_AND_TRANSACTION (MQ_TOK token, MQ_TOK callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_TRANSACTION(MQ_TOK token, MQ_TOK callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service to do a longterm-transaction-call …

void	SendEND_AND_TRANSACTION (const std::string &token, const std::string &callback, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_TRANSACTION(MQ_TOK token, MQ_TOK callback, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service to do a longterm-transaction-call …

void	SendEND_AND_WAIT (MQ_TOK token, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_WAIT(MQ_TOK token, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service and wait for result…

void	SendEND_AND_WAIT (const std::string &token, MK_TIME_T timeout=MK_TIMEOUT_DEFAULT)
	`C++: ctx.SendEND_AND_WAIT(MQ_TOK token, MK_TIME_T timeout = MK_TIMEOUT_DEFAULT)` → C-API finish the send-data-block, call the remote service and wait for result…

void	SendSTART ()
	`C++: ctx.SendSTART()` → C-API initialize the send-data-package. …

void	SendSYNC ()
	`C++: ctx.SendSYNC()` → C-API garantee that all pending asynchronous-service-calls are processed. …

void	SendL_END ()
	`C++: ctx.SendL_END()` → C-API finish to append an embedded body-list-item to the send-data-package. …

void	SendL_START ()
	`C++: ctx.SendL_START()` → C-API start to append an embedded body-list-item to the send-data-package. …

void	SendT_END ()
	`C++: ctx.SendT_END()` → C-API closed a longterm-transaction-item …

void	SendT_START ()
	`C++: ctx.SendT_START()` → C-API open a longterm-transaction-item …

void	SendERROR ()
	`C++: ctx.SendERROR()` → C-API send the data from the MkErrorC to the link target . …

void	SendRETURN ()
	`C++: ctx.SendRETURN()` → C-API MqContextC - finish the send-data-block on the server and optional return the results. …

void	SendRETURN_SUB ()
	`C++: ctx.SendRETURN_SUB()` → C-API return Sub-Data-Blocks required by MqSendEND_AND_SUB …

void	ServiceCreate (MQ_TOK token, MqServiceCCB callback)
	`C++: ctx.ServiceCreate(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback)` → C-API create a link between a service-token and a service-callback …

void	ServiceCreate (const std::string &token, MqServiceCCB callback)
	`C++: ctx.ServiceCreate(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback)` → C-API create a link between a service-token and a service-callback …

void	ServiceCreate (MQ_TOK token, MqServiceICB callback)
	`C++: ctx.ServiceCreate(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback)` → C-API create a link between a service-token and a service-callback …

void	ServiceCreate (const std::string &token, MqServiceICB callback)
	`C++: ctx.ServiceCreate(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback)` → C-API create a link between a service-token and a service-callback …

void	ServiceCreate (MQ_TOK token, MqServiceIF *callback)
	`C++: ctx.ServiceCreate(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback)` → C-API create a link between a service-token and a service-callback …

void	ServiceCreate (const std::string &token, MqServiceIF *callback)
	`C++: ctx.ServiceCreate(MQ_TOK token, MqServiceICB MqServiceCCB MqServiceIF* callback)` → C-API create a link between a service-token and a service-callback …

void	ServiceDelete (MQ_TOK token)
	`C++: ctx.ServiceDelete(MQ_TOK token)` → C-API delete a service. …

void	ServiceDelete (const std::string &token)
	`C++: ctx.ServiceDelete(MQ_TOK token)` → C-API delete a service. …

MK_BOOL	ServiceIsTransaction ()
	`C++: MK_BOOL ctx.ServiceIsTransaction()` → C-API check if the ongoing-service-call belongs to a transaction …

void	ServiceProxy (MQ_TOK token, MQ_SLAVE_ID id=MQ_SLAVE_OTHER)
	`C++: ctx.ServiceProxy(MQ_TOK token, MQ_SLAVE_ID id = MQ_SLAVE_OTHER)` → C-API create a service to link a master-context with a slave-context. …

void	ServiceProxy (const std::string &token, MQ_SLAVE_ID id=MQ_SLAVE_OTHER)
	`C++: ctx.ServiceProxy(MQ_TOK token, MQ_SLAVE_ID id = MQ_SLAVE_OTHER)` → C-API create a service to link a master-context with a slave-context. …

void	ServiceProxyCtx (MQ_TOK token, MqContextC *target)
	`C++: ctx.ServiceProxyCtx(MQ_TOK token, MqContextC* target)` → C-API same as MqServiceProxy but use an MqContextC as input.

void	ServiceProxyCtx (MQ_TOK token, const MqContextC &target)
	`C++: ctx.ServiceProxyCtx(MQ_TOK token, MqContextC* target)` → C-API same as MqServiceProxy but use an MqContextC as input.

void	ServiceProxyCtx (const std::string &token, MqContextC *target)
	`C++: ctx.ServiceProxyCtx(MQ_TOK token, MqContextC* target)` → C-API same as MqServiceProxy but use an MqContextC as input.

void	ServiceProxyCtx (const std::string &token, const MqContextC &target)
	`C++: ctx.ServiceProxyCtx(MQ_TOK token, MqContextC* target)` → C-API same as MqServiceProxy but use an MqContextC as input.

MK_BOOL	ServiceProxyCtxExists (MQ_TOK token, MqContextC *target)
	`C++: MK_BOOL ctx.ServiceProxyCtxExists(MQ_TOK token, MqContextC* target)` → C-API check if service who belongs to token is a proxy-service

MK_BOOL	ServiceProxyCtxExists (MQ_TOK token, const MqContextC &target)
	`C++: MK_BOOL ctx.ServiceProxyCtxExists(MQ_TOK token, MqContextC* target)` → C-API check if service who belongs to token is a proxy-service

MK_BOOL	ServiceProxyCtxExists (const std::string &token, MqContextC *target)
	`C++: MK_BOOL ctx.ServiceProxyCtxExists(MQ_TOK token, MqContextC* target)` → C-API check if service who belongs to token is a proxy-service

MK_BOOL	ServiceProxyCtxExists (const std::string &token, const MqContextC &target)
	`C++: MK_BOOL ctx.ServiceProxyCtxExists(MQ_TOK token, MqContextC* target)` → C-API check if service who belongs to token is a proxy-service

void	ServiceProxyRoundRobin (MQ_TOK token, MK_STRN ident)
	`C++: ctx.ServiceProxyRoundRobin(MQ_TOK token, MK_STRN ident)` → C-API create a proxy-service using Round-Robin as load-balancer …

void	ServiceProxyRoundRobin (const std::string &token, const std::string &ident)
	`C++: ctx.ServiceProxyRoundRobin(MQ_TOK token, MK_STRN ident)` → C-API create a proxy-service using Round-Robin as load-balancer …

void	ServiceStorage (MQ_TOK token)
	`C++: ctx.ServiceStorage(MQ_TOK token)` → C-API setup a service listen on a MqContextC_ServiceApi_Identifer and save all read-data-package into the STORAGE …

void	ServiceStorage (const std::string &token)
	`C++: ctx.ServiceStorage(MQ_TOK token)` → C-API setup a service listen on a MqContextC_ServiceApi_Identifer and save all read-data-package into the STORAGE …

MK_BOOL	ServiceTokenCheck (MQ_TOK token)
	`C++: MK_BOOL ctx.ServiceTokenCheck(MQ_TOK token)` → C-API in an ongoing-service-call check if the current MqContextC_ServiceApi_Identifer is *token* …

MK_BOOL	ServiceTokenCheck (const std::string &token)
	`C++: MK_BOOL ctx.ServiceTokenCheck(MQ_TOK token)` → C-API in an ongoing-service-call check if the current MqContextC_ServiceApi_Identifer is *token* …

MK_BOOL	ServiceTokenExists (MQ_TOK token)
	`C++: MK_BOOL ctx.ServiceTokenExists(MQ_TOK token)` → C-API check if the MqContextC_ServiceApi_Identifer *token* is defined as *ctx* service …

MK_BOOL	ServiceTokenExists (const std::string &token)
	`C++: MK_BOOL ctx.ServiceTokenExists(MQ_TOK token)` → C-API check if the MqContextC_ServiceApi_Identifer *token* is defined as *ctx* service …

MQ_TOK	ServiceTokenGet ()
	`C++: MQ_TOK ctx.ServiceTokenGet()` → C-API in an ongoing-service-call get the current MqContextC_ServiceApi_Identifer …

MqContextC *	SlaveGetMaster ()
	`C++: MqContextC* ctx.SlaveGetMaster()` → C-API opposite function of MqSlaveGetFilter

MqContextC *	SlaveGet (MQ_SLAVE_ID id)
	`C++: MqContextC* ctx.SlaveGet(MQ_SLAVE_ID id)` → C-API get the slave-context from a master-context …

MqContextC *	SlaveGetFilter ()
	`C++: MqContextC* ctx.SlaveGetFilter()` → C-API get the filter-ctx or the master-ctx …

MqContextC *	SlaveGetProxy (MQ_SLAVE_ID id)
	`C++: MqContextC* ctx.SlaveGetProxy(MQ_SLAVE_ID id)` → C-API on slave return the master and on master return the slave identified by id.

MK_BOOL	SlaveCheck (MQ_SLAVE_ID id) const
	`C++: MK_BOOL ctx.SlaveCheck(MQ_SLAVE_ID id)` → C-API check if slave-id is valid

void	SlaveCreate (MQ_SLAVE_ID id, MqContextC *slave)
	`C++: ctx.SlaveCreate(MQ_SLAVE_ID id, MqContextC* slave)` → C-API create a master/slave link between the master-parent-context and the slave-parent-context …

void	SlaveCreate (MQ_SLAVE_ID id, const MqContextC &slave)
	`C++: ctx.SlaveCreate(MQ_SLAVE_ID id, MqContextC* slave)` → C-API create a master/slave link between the master-parent-context and the slave-parent-context …

void	SlaveDelete (MQ_SLAVE_ID id)
	`C++: ctx.SlaveDelete(MQ_SLAVE_ID id)` → C-API Delete a slave object from a master/slave link identified by id. …

MK_BOOL	SlaveIs () const
	`C++: MK_BOOL ctx.SlaveIs()` → C-API is the context a slave-context ? …

void	SlaveWorker (MQ_SLAVE_ID id, MK_STRN fct="WORKER", MkBufferListC *args=NULL)
	`C++: ctx.SlaveWorker(MQ_SLAVE_ID id, MK_STRN fct = "WORKER", MkBufferListC* args = NULL)` → C-API create a master/slave link using the image of the ctx object self. …

MQ_LTR	StorageDelete (MQ_LTR *transLIdP_inout=NULL)
	`C++: MQ_LTR ctx.StorageDelete(MQ_LTR transLIdP_inout = NULL)` → C-API delete the storage-row* identified by the *transLIdP_inout* …

MQ_LTR	StorageImport (MQ_LTR *transLIdP_inout=NULL)
	`C++: MQ_LTR ctx.StorageImport(MQ_LTR transLIdP_inout = NULL)` → C-API import* the storage-package into the read-data-package …

void	StorageClose ()
	`C++: ctx.StorageClose()` → C-API close the storage. …

void	StorageDecrRef (MQ_LTR transLId)
	`C++: ctx.StorageDecrRef(MQ_LTR transLId)` → C-API decrease the internal refCount lock of the database-entry

void	StorageIncrRef (MQ_LTR transLId)
	`C++: ctx.StorageIncrRef(MQ_LTR transLId)` → C-API increase the internal refCount lock of the database-entry

void	StorageLog (MK_STRN callfunc=__builtin_FUNCTION())
	`C++: ctx.StorageLog(MK_STRN callfunc = __builtin_FUNCTION())` → C-API log the storage the status of the open transactions

void	StorageOpen (MK_STRN storageFile)
	`C++: ctx.StorageOpen(MK_STRN storageFile)` → C-API switch to a file-based-transaction-database …

void	StorageOpen (const std::string &storageFile)
	`C++: ctx.StorageOpen(MK_STRN storageFile)` → C-API switch to a file-based-transaction-database …

MQ_LTR	StorageCount ()
	`C++: MQ_LTR ctx.StorageCount()` → C-API count the number of storage-rows …

MK_I32	StorageErrCnt (MQ_LTR transLId)
	`C++: MK_I32 ctx.StorageErrCnt(MQ_LTR transLId)` → C-API increment and return the database row-error-count for the row defined with transLId

MQ_LTR	StorageExport ()
	`C++: MQ_LTR ctx.StorageExport()` → C-API export the read-data-package into the STORAGE …

std::tuple< MqContextC *, MQ_LTR >	StorageResolve ()
	`C++: {otherCtxP:MqContextC* otherLIdP:MQ_LTR} ctx.StorageResolve()` → C-API extract the `context->link.protect.rmtTransLId` entry from the database

	MqContextC (MqContextC *tmpl=NULL)
	`C++: [constructor,static] MqContextC* MqContextC::Create(MqContextC* tmpl = NULL)` → C-API create and initialize the MqContextC ...

bool	isParent ()

bool	isChild ()

bool	isMaster ()

bool	isSlave ()

void	LinkCheckOptionI32 (MK_STRN opt, MK_I32 *val)
	`C++: ctx.LinkCreate(MkBufferListC* args = NULL)` → C-API make ctx to a parent-context and setup a new client-server-link …

void	SlaveWorker (MK_NUM id, MK_STRN factory, const MkBufferListC &args)
	`C++: ctx.SlaveWorker(MQ_SLAVE_ID id, MK_STRN fct = "WORKER", MkBufferListC* args = NULL)` → C-API create a master/slave link using the image of the ctx object self. …

MkBufferListC *	Send (MK_STRN cstr,...)
	`C++: ctx.Send(MK_STRN cstr, ... )` → C-API user friendly replacement for the MqContextC_SendApi_C_API … default MqTokenICB

MkBufferListC *	Send (const std::string &str,...)

MkBufferListC *	Send (MK_STRN cstr, MqTokenICB const callback,...)
	`C++: ctx.Send(MK_STRN cstr, ... )` → C-API user friendly replacement for the MqContextC_SendApi_C_API … default MqTokenICB

MkBufferListC *	Send (const std::string &str, MqTokenICB const callback,...)

MkBufferListC *	Send (MK_STRN cstr, MqTokenCCB const callback,...)
	`C++: ctx.Send(MK_STRN cstr, ... )` → C-API user friendly replacement for the MqContextC_SendApi_C_API … default MqTokenCCB

MkBufferListC *	Send (const std::string &str, MqTokenCCB const callback,...)

MkBufferListC *	Send (MK_STRN cstr, IService *const service,...)
	`C++: ctx.Send(MK_STRN cstr, ... )` → C-API user friendly replacement for the MqContextC_SendApi_C_API … default ccmqmsgque::IService

MkBufferListC *	Send (const std::string &str, IService *const service,...)

Public Member Functions inherited from ccmkkernel::MkObjectC
MK_OBJ	getOBJ () const

MK_OBJ	getOBJ__null_allow () const

MK_OBJN	getOBJN () const

MK_OBJN	getOBJN__null_allow () const

bool	Check () const

virtual	~MkObjectC ()

MK_MNG	getMNG () const

MK_STRN	ToNativeNameOfClass () const

MK_STR	SysStrDup (MK_STRN str)

void	SysFree (MK_PTR tgt)

void	Sleep (unsigned int const sec)

void	USleep (unsigned int const usec)

void	HandleDelete ()

MK_HDL	HandleGet ()

MkObjectC *	Next ()

MkObjectC *	Prev ()

void	DbgDump (MK_STRN message="var", MK_STRN callfunc=__builtin_FUNCTION()) const

void	DbgL (MK_STRN message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const

void	DbgL (const std::string &message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const

void	DbgLogC (MK_STRN callfunc=__builtin_FUNCTION()) const

void	DbgO (MK_STRN callfunc=__builtin_FUNCTION()) const

void	DbgSTACK (MK_I32 skip=0, MK_I32 num=-1, MK_STRN callfunc=__builtin_FUNCTION()) const

void	LogC (MK_STRN message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION()) const

void	LogC (const std::string &message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION()) const

void	LogHEX (MK_STRN callfunc, MK_BNP data) const

void	LogHEX (const std::string &callfunc, MK_BNP data) const

void	LogV (MK_STRN callfunc, MK_DBG debug, MK_FST printfmt,...) const

void	LogV (const std::string &callfunc, MK_DBG debug, MK_FST printfmt,...) const

void	LogVL (MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list) const

void	LogVL (const std::string &callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list) const

void	Log (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const

void	Log (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const

void	LogDetail (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const

void	LogDetail (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const

void	LogSimple (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const

void	LogSimple (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const

MkErrorC *	ErrorCatch (std::exception *exception=NULL, MK_STRN callfunc=__builtin_FUNCTION()) const

MkErrorC *	ErrorCatch (const std::exception &exception, MK_STRN callfunc=__builtin_FUNCTION()) const

MkErrorC *	ToError ()

MK_I32	HandleGetOfType ()

MK_BOOL	IsNull ()

MK_STRN	ToName () const

MK_STRN	ToNameOfClass ()

MK_STRN	ToNameOfType () const

MK_STRN	ToString () const

MK_I32	RefGet ()

void	SysKill (MK_I32 pid, MK_I32 signal) const

MK_I32	SysGetPid () const

void	Delete ()

void	Dispose ()

void	DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteCCB callback=NULL, MK_STRN filter=NULL)

void	DeleteCallbackSetup (const std::string &ident, MkObjectDeleteCCB callback=NULL, MK_STRN filter=NULL)

void	DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteICB callback=NULL, MK_STRN filter=NULL)

void	DeleteCallbackSetup (const std::string &ident, MkObjectDeleteICB callback=NULL, MK_STRN filter=NULL)

Public Member Functions inherited from ccmqmsgque::IServerSetup
Public Member Functions inherited from ccmqmsgque::IServerCleanup
Public Member Functions inherited from ccmqmsgque::IEvent
Static Public Attributes inherited from ccmqmsgque::MqContextC
static thread_local MqContextC	MK_NULL_REF = {(MK_OBJ)0}

Static Public Attributes inherited from ccmkkernel::MkObjectC
static thread_local MkObjectC	MK_NULL_REF

Protected Member Functions inherited from ccmqmsgque::MqContextC
	MqContextC (MK_TYP const typ, MqContextC *tmpl=NULL)

Protected Member Functions inherited from ccmkkernel::MkObjectC
void	atomInit (MK_OBJ obj)

	MkObjectC ()

	MkObjectC (MK_OBJ obj)

void	ErrorCheck (enum MkErrorE err, MK_STRN const caller=__builtin_FUNCTION(), MK_I32 const line=__builtin_LINE()) const

void	ErrorCheck (MK_STRN const caller=__builtin_FUNCTION(), MK_I32 const line=__builtin_LINE()) const

Static Protected Member Functions inherited from ccmkkernel::MkObjectC
static void	ErrorCheck (MK_MNGN mng, enum MkErrorE err, MK_STRN const caller=__builtin_FUNCTION(), MK_I32 const line=__builtin_LINE())

static MK_PTR	atomObjNew (MK_RT mkrt, MK_OBJ obj)

static MK_PTR	atomObjCreate (MK_RT mkrt, MK_OBJ obj)

Protected Attributes inherited from ccmkkernel::MkObjectC
MK_OBJ	hdl

Detailed Description

Definition at line 29 of file Filter6.cc.

Constructor & Destructor Documentation

◆ Filter6()

Filter6::Filter6	(	MK_TYP const	typ,
		MqContextC *	tmpl = NULL )

inlineprivate

Definition at line 36 of file Filter6.cc.

                                                     : MqContextC(typ, tmpl) {
      ConfigSetIgnoreExit(true);
      rgx = "^(?:Filter6-1|Filter6|fs1.*)$";
    }

Member Function Documentation

◆ ErrorWrite()

void Filter6::ErrorWrite ( )

inlineprivate

Definition at line 45 of file Filter6.cc.

                       {
      auto err = ErrorFORMAT();
      fprintf(FH, "ERROR: %s\n", err->GetText());
      fflush(FH);
      err->Reset();
    }

Here is the caller graph for this function:

◆ Event()

void Filter6::Event ( )

inlineprivatevirtual

Implements ccmqmsgque::IEvent.

Definition at line 91 of file Filter6.cc.

                  {
      // check if data is available
      if (StorageCount() == 0LL) {
        // no data available, set error-code to CONTINUE
        ErrorFORMAT()->SetCONTINUE();
      } else {
        MQ_LTR Id = 0LL;
        // an item is available, try to send the data
        try {
          // get the filter-context
          MqContextC *ftr = SlaveGetFilter();
          // read package from storage
          Id = StorageImport();
          // forward the entire BDY data to the ftr-target
          try {
            ProxyForward(ftr);
          } catch (const MkExceptionC& e) {
            if (StorageErrCnt(Id) <= Filter6::retryCnt) {
              StorageDecrRef(Id);
              return;
            } else {
              throw;
            }
          } catch (...) {
            throw;
          }
        } catch (const exception& e) {
          ErrorCatch (e);
          // on error write the error-text and "forget" the data
          ErrorWrite();
        }
        // on "success" or on "error" delete item from storage
        if (Id != 0LL) StorageDelete(&Id);
      }
    }

◆ EXIT()

void Filter6::EXIT ( )

inlineprivate

Definition at line 78 of file Filter6.cc.

                 {
      Exit();
    }

Here is the caller graph for this function:

◆ FilterIn()

void Filter6::FilterIn ( )

inlineprivate

Definition at line 86 of file Filter6.cc.

                     {
      StorageExport();
      SendRETURN();
    }

Here is the caller graph for this function:

◆ Help()

static void Filter6::Help ( MK_STRN base )

inlinestatic

Definition at line 155 of file Filter6.cc.

    {
      fputs("\n", stderr);
      fprintf(stderr, "usage: %s [OPTION]... [ARGUMENT]...\n", base);
      fputs("\n", stderr);
      fputs("  This tool is database (MqStorage...) test tool of NHI1.\n", stderr);
      fputs("\n", stderr);
      fprintf(stderr, "  %s [ARGUMENT]... syntax:\n", base);
      fprintf(stderr, "    aclient... %c %s ... %c aserver\n", MK_ALFA, base, MK_ALFA);
      fputs("\n", stderr);
      fputs(MqHelp (NULL), stderr);
      fputs("\n", stderr);
      fprintf(stderr, "  %s [OPTION]:\n", base);
      fputs(          "    -h, --help       print this help\n", stderr);
      fputs("\n", stderr);
      fputs(          "    --retryCnt       how often an item should be send on error (default: 3)\n", stderr);
      fputs("\n", stderr);
 
      exit(EXIT_SUCCESS);
    }

◆ LOGF()

void Filter6::LOGF ( )

inlineprivate

Definition at line 52 of file Filter6.cc.

                 {
      // get the "link-target"
      MqContextC *ftr = SlaveGetFilter();
      // check "Ident" from the "link-target"
      if (std::regex_match(ftr->ConfigGetName(),rgx)) {
        // if "Ident" is not "transFilter" use the data as file-name to open a file 
        FH = fopen (ReadSTR(), "a");
      } else {
        // if "Ident" is "transFilter" send the data to the "link-target"
        ProxyForward(ftr);
      }
      SendRETURN();
    }

Here is the caller graph for this function:

◆ ServerCleanup()

void Filter6::ServerCleanup ( )

inlineprivatevirtual

Implements ccmqmsgque::IServerCleanup.

Definition at line 127 of file Filter6.cc.

                         {
      if (FH != NULL) fclose (FH);
    }

◆ ServerSetup()

void Filter6::ServerSetup ( )

inlineprivatevirtual

Implements ccmqmsgque::IServerSetup.

Definition at line 132 of file Filter6.cc.

                       {
      MqContextC *ftr = SlaveGetFilter();
      FH = NULL;
      // SERVER: listen on every token (+ALL)
      ServiceCreate       ("LOGF", MqServiceICB(&Filter6::LOGF));
      ServiceCreate       ("EXIT", MqServiceICB(&Filter6::EXIT));
      ServiceCreate       ("SOEX", MqServiceICB(&Filter6::SOEX));
      ServiceCreate       ("+ALL", MqServiceICB(&Filter6::FilterIn));
      ServiceStorage      ("PRNT");
      ServiceStorage      ("PRN2");
      ftr->ServiceCreate  ("WRIT", MqTokenCCB(&Filter6::WRIT));
      ServiceCreate       ("WRIT", MqTokenCCB(&Filter6::WRIT));
      ftr->ServiceProxy   ("WRT2", MQ_SLAVE_MASTER);
 
      if (isParent()) {
        LinkCheckOptionI32  ("--retryCnt", &Filter6::retryCnt);
      }
    }

◆ SOEX()

void Filter6::SOEX ( )

inlineprivate

Definition at line 82 of file Filter6.cc.

                 {
      ErrorFORMAT()->SetEXIT();
    }

Here is the caller graph for this function:

◆ WRIT()

static void Filter6::WRIT ( MqContextC * ctx )

inlinestaticprivate

Definition at line 66 of file Filter6.cc.

                                       {
      // get the "master"
      Filter6 *master = dynamic_cast<Filter6*>(ctx->SlaveGetMaster());
      if (std::regex_match(master->ConfigGetName(),master->rgx)) {
        fprintf (master->FH, "%s\n", ctx->ReadSTR());
        fflush (master->FH);
      } else {
        ctx->ProxyForward(master);
      }
      ctx->SendRETURN();
    }

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ MqFactoryCT< Filter6 >

friend class MqFactoryCT< Filter6 >

friend

Definition at line 186 of file Filter6.cc.

Member Data Documentation

◆ FH

FILE* Filter6::FH

private

Definition at line 42 of file Filter6.cc.

◆ retryCnt

int Filter6::retryCnt = 3

staticprivate

Definition at line 33 of file Filter6.cc.

◆ rgx

regex Filter6::rgx

private

Definition at line 43 of file Filter6.cc.

The documentation for this class was generated from the following file:

Filter6.cc

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Filter6()

Member Function Documentation

◆ ErrorWrite()

◆ Event()

◆ EXIT()

◆ FilterIn()

◆ Help()

◆ LOGF()

◆ ServerCleanup()

◆ ServerSetup()

◆ SOEX()

◆ WRIT()

Friends And Related Symbol Documentation

◆ MqFactoryCT< Filter6 >

Member Data Documentation

◆ FH

◆ retryCnt

◆ rgx