MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service … More...

Collaboration diagram for MqContextC_SendApi_Basics_CC_API:

Functions
void	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::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	ccmqmsgque::MqContextC::SendSTART ()
	`C++: ctx.SendSTART()` → C-API initialize the send-data-package. …

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

Detailed Description

MqContextC - finish the send-data-block and call synchronous/asynchronous a remote-service …

calling a remote service and wait timeout seconds for an result. If timeout == 0 it is an asynchronous-service-call and if the timeout > 0 it is a synchronous-service-call.

service-call	blocking	timeout
synchronous	yes	timeout > 0
asynchronous	no	timeout == 0

blocking mean waiting max timeout seconds to finishing the service-call:

If the service-call is finished in less than timeout seconds… the results are available and can be processed.
If the service-call is NOT finished in timeout seconds… an timeout-error is created and the transaction will be canceled.

If an error was raised on the server during the service-processing… the following error-handling will be available

on a synchronous-service-call the error will be the result of the service-call
on a asynchronous-service-call with callback the error will be the result of the callback
on a asynchronous-service-call without callback the error will be send asynchronous from the server to the client . On the client the error will be raised on the NEXT event-handlng-command or as background-error if the libmqmsgque::MqSetupS::BgError function was defined.

Parameters

[in]	mkrt	the MkRuntimeS instance to work on - the runtime argument, used by MK_RT_CALL (C-only)
[in]	ctx	the MqContextS instance to work on
[in]	token	the MqContextC SERVICE API to identify the service
[in]	timeout	in seconds until a timeout-error is raised (possible values like ProcessEvent) (`libmkkernel::MK_TIMEOUT_DEFAULT=0`)

Exceptions

MkExceptionC → The default-exception from the Programming-Language-Micro-Kernel (PLMK)

See also: MqSendSYNC

calling a remote service and wait timeout seconds for an result. If timeout == 0 it is an asynchronous-service-call and if the timeout > 0 it is a synchronous-service-call.

service-call	blocking	timeout
synchronous	yes	timeout > 0
asynchronous	no	timeout == 0

blocking mean waiting max timeout seconds to finishing the service-call:

If the service-call is finished in less than timeout seconds… the results are available and can be processed.
If the service-call is NOT finished in timeout seconds… an timeout-error is created and the transaction will be canceled.

If an error was raised on the server during the service-processing… the following error-handling will be available

on a synchronous-service-call the error will be the result of the service-call
on a asynchronous-service-call with callback the error will be the result of the callback
on a asynchronous-service-call without callback the error will be send asynchronous from the server to the client . On the client the error will be raised on the NEXT event-handlng-command or as background-error if the libmqmsgque::MqSetupS::BgError function was defined.

Parameters

[in]	mkrt	the MkRuntimeS instance to work on - the runtime argument, used by MK_RT_CALL (C-only)
[in]	ctx	the MqContextS instance to work on
[in]	token	the MqContextC SERVICE API to identify the service
[in]	timeout	in seconds until a timeout-error is raised (possible values like ProcessEvent) (`libmkkernel::MK_TIMEOUT_DEFAULT=0`)

Exceptions

MkExceptionC → The default-exception from the Programming-Language-Micro-Kernel (PLMK)

See also: MqSendSYNC

Function Documentation

◆ SendEND() [1/2]

void ccmqmsgque::MqContextC::SendEND	(	const std::string &	token,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1666 of file MqContextC_inline_cc.hh.

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

◆ SendEND() [2/2]

void ccmqmsgque::MqContextC::SendEND	(	MQ_TOK	token,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1659 of file MqContextC_inline_cc.hh.

                                                                   {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendEND(ctx, token, timeout);
    MkErrorC_Check(ctx, errVal);
  }

◆ SendEND_AND_CALLBACK() [1/6]

void ccmqmsgque::MqContextC::SendEND_AND_CALLBACK	(	const std::string &	token,
		MqServiceCCB	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1682 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_CALLBACK() [2/6]

void ccmqmsgque::MqContextC::SendEND_AND_CALLBACK	(	const std::string &	token,
		MqServiceICB	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1699 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_CALLBACK() [3/6]

void ccmqmsgque::MqContextC::SendEND_AND_CALLBACK	(	const std::string &	token,
		MqServiceIF *	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1716 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_CALLBACK() [4/6]

void ccmqmsgque::MqContextC::SendEND_AND_CALLBACK	(	MQ_TOK	token,
		MqServiceCCB	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1674 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_CALLBACK() [5/6]

void ccmqmsgque::MqContextC::SendEND_AND_CALLBACK	(	MQ_TOK	token,
		MqServiceICB	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1691 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_CALLBACK() [6/6]

void ccmqmsgque::MqContextC::SendEND_AND_CALLBACK	(	MQ_TOK	token,
		MqServiceIF *	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1708 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_SUB() [1/6]

void ccmqmsgque::MqContextC::SendEND_AND_SUB	(	const std::string &	token,
		MqServiceCCB	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1733 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_SUB() [2/6]

void ccmqmsgque::MqContextC::SendEND_AND_SUB	(	const std::string &	token,
		MqServiceICB	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1750 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_SUB() [3/6]

void ccmqmsgque::MqContextC::SendEND_AND_SUB	(	const std::string &	token,
		MqServiceIF *	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1767 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_SUB() [4/6]

void ccmqmsgque::MqContextC::SendEND_AND_SUB	(	MQ_TOK	token,
		MqServiceCCB	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1725 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_SUB() [5/6]

void ccmqmsgque::MqContextC::SendEND_AND_SUB	(	MQ_TOK	token,
		MqServiceICB	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1742 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_SUB() [6/6]

void ccmqmsgque::MqContextC::SendEND_AND_SUB	(	MQ_TOK	token,
		MqServiceIF *	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1759 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_TRANSACTION() [1/2]

void ccmqmsgque::MqContextC::SendEND_AND_TRANSACTION	(	const std::string &	token,
		const std::string &	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1783 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_TRANSACTION() [2/2]

void ccmqmsgque::MqContextC::SendEND_AND_TRANSACTION	(	MQ_TOK	token,
		MQ_TOK	callback,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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 …

Definition at line 1776 of file MqContextC_inline_cc.hh.

                                                                                                    {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendEND_AND_TRANSACTION(ctx, token, callback, timeout);
    MkErrorC_Check(ctx, errVal);
  }

◆ SendEND_AND_WAIT() [1/2]

void ccmqmsgque::MqContextC::SendEND_AND_WAIT	(	const std::string &	token,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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…

Definition at line 1799 of file MqContextC_inline_cc.hh.

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

◆ SendEND_AND_WAIT() [2/2]

void ccmqmsgque::MqContextC::SendEND_AND_WAIT	(	MQ_TOK	token,
		MK_TIME_T	timeout = MK_TIMEOUT_DEFAULT )

inline

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…

Definition at line 1792 of file MqContextC_inline_cc.hh.

                                                                            {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendEND_AND_WAIT(ctx, token, timeout);
    MkErrorC_Check(ctx, errVal);
  }

Here is the caller graph for this function:

◆ SendSTART()

void ccmqmsgque::MqContextC::SendSTART ( )

inline

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

Definition at line 1807 of file MqContextC_inline_cc.hh.

                                      {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendSTART(ctx);
    MkErrorC_Check(ctx, errVal);
  }

Here is the caller graph for this function:

◆ SendSYNC()

void ccmqmsgque::MqContextC::SendSYNC ( )

inline

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

Definition at line 1814 of file MqContextC_inline_cc.hh.

                                     {
    MK_UNUSED auto ctx = getCTX();
    enum MkErrorE errVal = MqSendSYNC(ctx);
    MkErrorC_Check(ctx, errVal);
  }

Functions

Detailed Description

Function Documentation

◆ SendEND() [1/2]

◆ SendEND() [2/2]

◆ SendEND_AND_CALLBACK() [1/6]

◆ SendEND_AND_CALLBACK() [2/6]

◆ SendEND_AND_CALLBACK() [3/6]

◆ SendEND_AND_CALLBACK() [4/6]

◆ SendEND_AND_CALLBACK() [5/6]

◆ SendEND_AND_CALLBACK() [6/6]

◆ SendEND_AND_SUB() [1/6]

◆ SendEND_AND_SUB() [2/6]

◆ SendEND_AND_SUB() [3/6]

◆ SendEND_AND_SUB() [4/6]

◆ SendEND_AND_SUB() [5/6]

◆ SendEND_AND_SUB() [6/6]

◆ SendEND_AND_TRANSACTION() [1/2]

◆ SendEND_AND_TRANSACTION() [2/2]

◆ SendEND_AND_WAIT() [1/2]

◆ SendEND_AND_WAIT() [2/2]

◆ SendSTART()

◆ SendSYNC()