The data-type to store and handle the error-condition … → C-API: libmkkernel::MkErrorS More...

#include <MkErrorC_cc.hh>

Inheritance diagram for ccmkkernel::MkErrorC:

Collaboration diagram for ccmkkernel::MkErrorC:

Public Member Functions
	MkErrorC (MK_ERR hdl)

MK_ERR	getERR () const
	return the LibMsgqueObject from current MkErrorC instance

MK_ERR	getERR__null_allow () const
	return the LibMsgqueObject from current MkErrorC instance

MK_ERRN	getERRN () const
	(const) return the LibMsgqueObject from current MkErrorC instance

MK_ERRN	getERRN__null_allow () const
	(const) return the LibMsgqueObject from current MkErrorC instance

bool	Check () const
	check if pointer is still valid

	MkErrorC (const MkErrorC &e)

	MkErrorC (const MkExceptionC &ex)

MkErrorC *	Next ()
	`C++: MkErrorC* err.Next()` → C-API get next instance from linked-list of MkErrorS type

MkErrorC *	Prev ()
	`C++: MkErrorC* err.Prev()` → C-API get previous instance from linked-list of MkErrorS type

MkErrorE	GetCode () const
	`C++: MkErrorE err.GetCode()` → C-API get the value of MkErrorS::code …

MK_I32	GetNum () const
	`C++: MK_I32 err.GetNum()` → C-API get the MkErrorS::num. The number can be used as exit-code …

MK_SIZE	GetSize () const
	`C++: MK_SIZE err.GetSize()` → C-API get the error-message-size from the exception-object …

MK_STRN	GetText () const
	`C++: MK_STRN err.GetText()` → C-API get the MkErrorS::text …

MkErrorC *	Catch (std::exception *exception=NULL, MK_STRN callfunc=__builtin_FUNCTION())
	`C++: MkErrorC* err.Catch(std::exception* exception = NULL, MK_STRN callfunc = __builtin_FUNCTION())` → C-API convert a programming-language-error into an ccmkkernel error …

MkErrorC *	Catch (const std::exception &exception, MK_STRN callfunc=__builtin_FUNCTION())
	`C++: MkErrorC* err.Catch(std::exception* exception = NULL, MK_STRN callfunc = __builtin_FUNCTION())` → C-API convert a programming-language-error into an ccmkkernel error …

void	Cleanup (MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 callline=__builtin_LINE())
	`C++: err.Cleanup(MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 callline = __builtin_LINE())` → C-API cleanup and print unwanted active error …

void	Println (MK_STRN msg="", MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 callline=__builtin_LINE())
	`C++: err.Println(MK_STRN msg = "", MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 callline = __builtin_LINE())` → C-API print the default-error to the MkLogFileC (default: stderr) and clear the error afterwards …

void	Reset (MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 callline=__builtin_LINE(), MK_BOOL force=false)
	`C++: err.Reset(MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 callline = __builtin_LINE(), MK_BOOL force = false)` → C-API This function clears the err and resets to libmkkernel::MK_OK …

MkErrorE	Stack (MK_STRN callfunc=__builtin_FUNCTION(), MK_STRN callfile=__builtin_FILE(), MK_I32 callline=__builtin_LINE())
	`C++: MkErrorE err.Stack(MK_STRN callfunc = __builtin_FUNCTION(), MK_STRN callfile = __builtin_FILE(), MK_I32 callline = __builtin_LINE())` → C-API check on error and if yes append an ErrorStackFormat to the error-message …

void	StackFormat (MK_STRN callfunc=__builtin_FUNCTION(), MK_STRN callfile=__builtin_FILE(), MK_I32 callline=__builtin_LINE())
	`C++: err.StackFormat(MK_STRN callfunc = __builtin_FUNCTION(), MK_STRN callfile = __builtin_FILE(), MK_I32 callline = __builtin_LINE())` → C-API append an ensemble of func, file and line to the error-message …

MkErrorC *	NoRaise ()
	`C++: MkErrorC* err.NoRaise()` → C-API ignore the next return of libmkkernel::MK_ERROR and do not raise an target-language-exception …

void	AppendC (MK_STRN message)
	`C++: err.AppendC(MK_STRN message)` → C-API append the message to the MkErrorS::text …

void	AppendC (const std::string &message)
	`C++: err.AppendC(MK_STRN message)` → C-API append the message to the MkErrorS::text …

void	AppendV (MK_FST printfmt,...)
	`C++: err.AppendV(MK_FST printfmt, ... )` → C-API append a vararg string to the MkErrorC …

void	AppendVL (MK_FST printfmt, va_list var_list)
	`C++: err.AppendVL(MK_FST printfmt, va_list var_list)` → C-API append a va_list string to the MkErrorC …

void	Raise () const
	`C++: err.Raise()` → C-API convert an ccmkkernel error into an programming-language-error and raise afterwards. …

void	SetC (MK_STRN message, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 errnum=-1)
	`C++: err.SetC(MK_STRN message, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 errnum = -1)` → C-API 'set' and 'raise' the MkErrorC using a string-message and a errnum-number …

void	SetC (const std::string &message, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 errnum=-1)
	`C++: err.SetC(MK_STRN message, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 errnum = -1)` → C-API 'set' and 'raise' the MkErrorC using a string-message and a errnum-number …

void	SetV (MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt,...)
	`C++: err.SetV(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )` → C-API set the MkErrorS object using a format string argument list and raise an error …

void	SetV (const std::string &callfunc, MK_I32 errnum, MK_FST printfmt,...)
	`C++: err.SetV(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )` → C-API set the MkErrorS object using a format string argument list and raise an error …

void	SetVL (MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
	`C++: err.SetVL(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)` → C-API 'set' and 'raise' the MkErrorC using a vararg-list message …

void	SetVL (const std::string &callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
	`C++: err.SetVL(MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)` → C-API 'set' and 'raise' the MkErrorC using a vararg-list message …

MK_BOOL	IsABORT () const
	`C++: MK_BOOL err.IsABORT()` → C-API check on *ABORT* signal …

MK_BOOL	IsEXIT ()
	`C++: MK_BOOL err.IsEXIT()` → C-API check on APPLICATION-EXIT error …

MK_BOOL	IsSOCKET () const
	`C++: MK_BOOL err.IsSOCKET()` → C-API check on SOCKET-DOWN error …

MK_BOOL	IsTIMEOUT () const
	`C++: MK_BOOL err.IsTIMEOUT()` → C-API check on *TIMEOUT* error …

void	SetABORT (MK_STRN detail="UNKNOWN", MK_STRN callfunc=__builtin_FUNCTION())
	`C++: err.SetABORT(MK_STRN detail = "UNKNOWN", MK_STRN callfunc = __builtin_FUNCTION())` → C-API send the *ABORT* signal to the calling stack…

void	SetCONTINUE ()
	`C++: err.SetCONTINUE()` → C-API signal end of processing in an MqMqEventIF callback …

void	SetCode (MkErrorE code)
	`C++: err.SetCode(MkErrorE code)` → C-API set the MkErrorS::code value …

void	SetEXIT (MK_STRN callfunc=__builtin_FUNCTION())
	`C++: err.SetEXIT(MK_STRN callfunc = __builtin_FUNCTION())` → C-API finish the current callback, return to toplevel and MqExit the application …

void	SetSOCKET (MK_STRN detail="UNKNOWN", MK_STRN callfunc=__builtin_FUNCTION())
	`C++: err.SetSOCKET(MK_STRN detail = "UNKNOWN", MK_STRN callfunc = __builtin_FUNCTION())` → C-API create SOCKET-DOWN error …

MkErrorC *	Dup () const
	`C++: [constructor] MkErrorC* srce.Dup()` → C-API Dup-Constructor - create a new MkErrorC instance as copy from an existing MkErrorC instance …

void	Copy (const MkErrorC *srce)
	`C++: dest.Copy(const MkErrorC* srce)` → C-API Copy-Constructor - sync an existing MkErrorC instance with the values from an existing MkErrorC instance …

void	Copy (const MkErrorC &srce)
	`C++: dest.Copy(const MkErrorC* srce)` → C-API Copy-Constructor - sync an existing MkErrorC instance with the values from an existing MkErrorC instance …

Public Member Functions inherited from ccmkkernel::MkObjectC
MK_OBJ	getOBJ () const
	return the LibMsgqueObject from current MkObjectC instance

MK_OBJ	getOBJ__null_allow () const
	return the LibMsgqueObject from current MkObjectC instance

MK_OBJN	getOBJN () const
	(const) return the LibMsgqueObject from current MkObjectC instance

MK_OBJN	getOBJN__null_allow () const
	(const) return the LibMsgqueObject from current MkObjectC instance

bool	Check () const
	check if pointer is still valid

virtual	~MkObjectC ()

MK_MNG	getMNG () const

MK_STRN	ToNativeNameOfClass () const

MK_STR	SysStrDup (MK_STRN str)
	strdup syscall with ccmkkernel error plugin → C-API: libmkkernel::MkSysStrDup

void	SysFree (MK_PTR tgt)
	implements the ccmkkernel API object: MkSysFree

void	Sleep (unsigned int const sec)
	sleep syscall with ccmkkernel error plugin → C-API: libmkkernel::MkSysSleep

void	USleep (unsigned int const usec)
	usleep syscall with ccmkkernel error plugin → C-API: libmkkernel::MkSysUSleep

void	HandleDelete ()
	`C++: netObj.HandleDelete()` → C-API Handle-Delete-Slot - delete a *netObj* from handle-storage …

MK_BOOL	HandleExists ()
	`C++: MK_BOOL obj.HandleExists()` → C-API check if *obj* has already a handle defined…

MK_HDL	HandleGet ()
	`C++: MK_HDL obj.HandleGet()` → C-API Handle-Get-Slot - returns a *export-hdl* to the MkObjectC useable for external storage

MK_HDL	HandleGetOfType ()
	`C++: MK_HDL obj.HandleGetOfType()` → C-API Export-Slot - returns *typeHdl* of the *obj* .

MK_HDL	HandleGetOr0 ()
	`C++: MK_HDL obj.HandleGetOr0()` → C-API return *export-hdl* or 0 in not created…

MkObjectC *	Next ()
	`C++: MkObjectC* obj.Next()` → C-API get next instance from linked-list of MkObjectS type

MkObjectC *	Prev ()
	`C++: MkObjectC* obj.Prev()` → C-API get previous instance from linked-list of MkObjectS type

void	DbgDump (MK_STRN message="var", MK_STRN callfunc=__builtin_FUNCTION()) const
	`C++: obj.DbgDump(MK_STRN message = "var", MK_STRN callfunc = __builtin_FUNCTION())` → C-API debug: Dump a instance to stderr with LNG and MQ internal data…

void	DbgL (MK_STRN message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: fmtobj.DbgL(MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API debug: write a instance-marker to the MkLogFileC (default: stderr) using the fmtobj as prefix …

void	DbgL (const std::string &message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: fmtobj.DbgL(MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API debug: write a instance-marker to the MkLogFileC (default: stderr) using the fmtobj as prefix …

void	DbgLogC (MK_STRN callfunc=__builtin_FUNCTION()) const
	`C++: obj.DbgLogC(MK_STRN callfunc = __builtin_FUNCTION())` → C-API debug: write a short-obj-summary to MkLogFileC (default: stderr) …

void	DbgO (MK_STRN callfunc=__builtin_FUNCTION()) const
	`C++: obj.DbgO(MK_STRN callfunc = __builtin_FUNCTION())` → C-API debug: write the object-details to MkLogFileC (default: stderr) …

void	DbgSTACK (MK_I32 skip=0, MK_I32 num=-1, MK_STRN callfunc=__builtin_FUNCTION()) const
	`C++: fmtobj.DbgSTACK(MK_I32 skip = 0, MK_I32 num = -1, MK_STRN callfunc = __builtin_FUNCTION())` → C-API debug: write the stack-trace to MkLogFileC (default: stderr) …

void	LogC (MK_STRN message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION()) const
	`C++: fmtobj.LogC(MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION())` → C-API write a logging-message to MkLogFileC (default: stderr) using the internal format …

void	LogC (const std::string &message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION()) const
	`C++: fmtobj.LogC(MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION())` → C-API write a logging-message to MkLogFileC (default: stderr) using the internal format …

void	LogHEX (MK_STRN callfunc, MK_BNP data) const
	`C++: fmtobj.LogHEX(MK_STRN callfunc, MK_BNP data)` → C-API log binaray data as HEX into the MkLogFileC (default: stderr) …

void	LogHEX (const std::string &callfunc, MK_BNP data) const
	`C++: fmtobj.LogHEX(MK_STRN callfunc, MK_BNP data)` → C-API log binaray data as HEX into the MkLogFileC (default: stderr) …

void	LogV (MK_STRN callfunc, MK_DBG debug, MK_FST printfmt,...) const
	`C++: fmtobj.LogV(MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, ... )` → C-API write a printf style logging-message to MkLogFileC (default: stderr) using the internal format …

void	LogV (const std::string &callfunc, MK_DBG debug, MK_FST printfmt,...) const
	`C++: fmtobj.LogV(MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, ... )` → C-API write a printf style logging-message to MkLogFileC (default: stderr) using the internal format …

void	LogVL (MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list) const
	`C++: fmtobj.LogVL(MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list)` → C-API write a vprintf style logging-message to MkLogFileC using the internal format …

void	LogVL (const std::string &callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list) const
	`C++: fmtobj.LogVL(MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list)` → C-API write a vprintf style logging-message to MkLogFileC using the internal format …

void	Log (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: obj.Log(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API Log-Slot - log a summary of an object to the MkLogFileC (default: stderr) target …

void	Log (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: obj.Log(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API Log-Slot - log a summary of an object to the MkLogFileC (default: stderr) target …

void	LogLong (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: obj.LogLong(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MkObjectS verbose into the MkLogFileC (default: stderr) …

void	LogLong (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: obj.LogLong(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MkObjectS verbose into the MkLogFileC (default: stderr) …

void	LogShort (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: obj.LogShort(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MkObjectS into the MkLogFileC (default: stderr) …

void	LogShort (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: obj.LogShort(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the MkObjectS into the MkLogFileC (default: stderr) …

void	LogType (const MkObjectC *fmtobj=NULL, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: obj.LogType(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the tyoe of the MkObjectS into the MkLogFileC (default: stderr) …

void	LogType (const MkObjectC &fmtobj, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0) const
	`C++: obj.LogType(const MkObjectC* fmtobj = NULL, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API log the tyoe of the MkObjectS into the MkLogFileC (default: stderr) …

MkErrorC *	ErrorCatch (std::exception *exception=NULL, MK_STRN callfunc=__builtin_FUNCTION()) const
	`C++: MkErrorC* obj.ErrorCatch(std::exception* exception = NULL, MK_STRN callfunc = __builtin_FUNCTION())` → C-API convert a programming-language-error into an ccmkkernel error …

MkErrorC *	ErrorCatch (const std::exception &exception, MK_STRN callfunc=__builtin_FUNCTION()) const
	`C++: MkErrorC* obj.ErrorCatch(std::exception* exception = NULL, MK_STRN callfunc = __builtin_FUNCTION())` → C-API convert a programming-language-error into an ccmkkernel error …

MkErrorC *	ToError ()
	`C++: MkErrorC* obj.ToError()` → C-API Error-Slot - return an error-object pre initialized with *obj* data.

MK_BOOL	IsNull ()
	`C++: MK_BOOL obj.IsNull()` → C-API ckeck if the object is `MK_NULL`

MK_STRN	ToName () const
	`C++: MK_STRN obj.ToName()` → C-API Info-Slot - returns brief information about the obj as a string

MK_STRN	ToNameOfClass ()
	`C++: MK_STRN obj.ToNameOfClass()` → C-API Class-Slot - returns the C++-Class-Name of the obj as string

MK_STRN	ToNameOfType () const
	`C++: MK_STRN obj.ToNameOfType()` → C-API Type-Slot - returns the LibMkKernel-Type-Name of the obj as a string

MK_STRN	ToString () const
	`C++: MK_STRN inst.ToString()` → C-API String-Slot - returns the string representation of the *inst* …

MK_I32	RefGet ()
	libmkkernel::MkRefGet

void	SysKill (MK_I32 pid, MK_I32 signal) const
	libmkkernel::MkSysKill

MK_I32	SysGetPid () const
	libmkkernel::MkSysGetPid

void	Delete ()
	`C++: [destructor] obj.Delete()` → C-API Delete-Slot - delete an instance.

void	Dispose ()
	`C++: [destructor] obj.Dispose()` → C-API Dispose-Slot - untie the connection between the Native-C++-Instance and the ccmkkernel-Instance.

void	DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteCCB callback=NULL, MK_STRN filter=NULL)
	`C++: [static] MkObjectC::DeleteCallbackSetup(MK_STRN ident, MkObjectDeleteICB MkObjectDeleteCCB MkObjectDeleteSCB callback = NULL, MK_STRN filter = NULL)` → C-API Create/Delete the instance-delete-callback …

void	DeleteCallbackSetup (const std::string &ident, MkObjectDeleteCCB callback=NULL, MK_STRN filter=NULL)
	`C++: [static] MkObjectC::DeleteCallbackSetup(MK_STRN ident, MkObjectDeleteICB MkObjectDeleteCCB MkObjectDeleteSCB callback = NULL, MK_STRN filter = NULL)` → C-API Create/Delete the instance-delete-callback …

void	DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteICB callback=NULL, MK_STRN filter=NULL)
	`C++: [static] MkObjectC::DeleteCallbackSetup(MK_STRN ident, MkObjectDeleteICB MkObjectDeleteCCB MkObjectDeleteSCB callback = NULL, MK_STRN filter = NULL)` → C-API Create/Delete the instance-delete-callback …

void	DeleteCallbackSetup (const std::string &ident, MkObjectDeleteICB callback=NULL, MK_STRN filter=NULL)
	`C++: [static] MkObjectC::DeleteCallbackSetup(MK_STRN ident, MkObjectDeleteICB MkObjectDeleteCCB MkObjectDeleteSCB callback = NULL, MK_STRN filter = NULL)` → C-API Create/Delete the instance-delete-callback …

Static Public Member Functions
static MkErrorC *	MkErrorC_ObjNew (MK_RT_ARGS MK_ERR hdl)
	return MkErrorC from LibMsgqueObject

static MK_ERR	getERR (MkErrorC *clsHdl)
	return LibMsgqueObject from current MkErrorC pointer

static MK_ERR	getERR__null_allow (MkErrorC *clsHdl)
	return LibMsgqueObject from current MkErrorC pointer

static MK_ERRN	getERRN (const MkErrorC *clsHdl)
	(const) return LibMsgqueObject from current MkErrorC pointer

static MK_ERRN	getERRN__null_allow (const MkErrorC *clsHdl)
	(const) return LibMsgqueObject from current MkErrorC pointer

static MK_ERR	getERR (const MkErrorC &clsHdl)
	return LibMsgqueObject from current MkErrorC reference

static MK_ERR	getERR__null_allow (const MkErrorC &clsHdl)
	return LibMsgqueObject from current MkErrorC reference

static MK_ERRN	getERRN (const MkErrorC &clsHdl)
	(const) return LibMsgqueObject from current MkErrorC reference

static MK_ERRN	getERRN__null_allow (const MkErrorC &clsHdl)
	(const) return LibMsgqueObject from current MkErrorC reference

static void	Check (MK_MNGN mng, enum MkErrorE err)

static void	Check (enum MkErrorE err)

static MkErrorC *	FORMAT (MK_OBJ const fmtobj)

static bool	IsEXIT_DEFAULT ()

static bool	IsSOCKET_DEFAULT ()

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

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

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

static void	PanicC (const MkObjectC *fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)
	`C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)` → C-API do a panic with string as argument …

static void	PanicC (const MkObjectC &fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)
	`C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)` → C-API do a panic with string as argument …

static void	PanicC (const MkObjectC *fmtobj, const std::string &callfunc, MK_I32 errnum, const std::string &message)
	`C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)` → C-API do a panic with string as argument …

static void	PanicC (const MkObjectC &fmtobj, const std::string &callfunc, MK_I32 errnum, const std::string &message)
	`C++: [static] MkErrorC::PanicC(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_STRN message)` → C-API do a panic with string as argument …

static void	PanicDEFAULT (const MkObjectC *fmtobj=NULL, MK_STRN callfunc=__builtin_FUNCTION())
	`C++: [static] MkErrorC::PanicDEFAULT(const MkObjectC* fmtobj = NULL, MK_STRN callfunc = __builtin_FUNCTION())` → C-API make panic from libmkkernel::MkErrorDEFAULT_RT …

static void	PanicDEFAULT (const MkObjectC &fmtobj, MK_STRN callfunc=__builtin_FUNCTION())
	`C++: [static] MkErrorC::PanicDEFAULT(const MkObjectC* fmtobj = NULL, MK_STRN callfunc = __builtin_FUNCTION())` → C-API make panic from libmkkernel::MkErrorDEFAULT_RT …

static void	PanicV (const MkObjectC *fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt,...)
	`C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )` → C-API do a panic with a vararg as argument …

static void	PanicV (const MkObjectC &fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt,...)
	`C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )` → C-API do a panic with a vararg as argument …

static void	PanicV (const MkObjectC *fmtobj, const std::string &callfunc, MK_I32 errnum, MK_FST printfmt,...)
	`C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )` → C-API do a panic with a vararg as argument …

static void	PanicV (const MkObjectC &fmtobj, const std::string &callfunc, MK_I32 errnum, MK_FST printfmt,...)
	`C++: [static] MkErrorC::PanicV(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, ... )` → C-API do a panic with a vararg as argument …

static void	PanicVL (const MkObjectC *fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
	`C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)` → C-API do a panic with a vararg-list as argument …

static void	PanicVL (const MkObjectC &fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
	`C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)` → C-API do a panic with a vararg-list as argument …

static void	PanicVL (const MkObjectC *fmtobj, const std::string &callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
	`C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)` → C-API do a panic with a vararg-list as argument …

static void	PanicVL (const MkObjectC &fmtobj, const std::string &callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)
	`C++: [static] MkErrorC::PanicVL(const MkObjectC* fmtobj, MK_STRN callfunc, MK_I32 errnum, MK_FST printfmt, va_list var_list)` → C-API do a panic with a vararg-list as argument …

static MkErrorC *	DEFAULT ()
	`C++: [static] MkErrorC* MkErrorC::DEFAULT()` → C-API default-system-error - default-error …

static MkErrorC *	FORMAT (const MkObjectC *fmtobj=NULL)
	`C++: [static] MkErrorC* MkErrorC::FORMAT(const MkObjectC* fmtobj = NULL)` → C-API system-error-format - format and return the default-error …

static MkErrorC *	FORMAT (const MkObjectC &fmtobj)
	`C++: [static] MkErrorC* MkErrorC::FORMAT(const MkObjectC* fmtobj = NULL)` → C-API system-error-format - format and return the default-error …

static MkErrorC *	IGNORE ()
	`C++: [static] MkErrorC* MkErrorC::IGNORE()` → C-API ignore-system-error - ignore the next error …

static MkErrorC *	PRINT ()
	`C++: [static] MkErrorC* MkErrorC::PRINT()` → C-API ignore-system-error - print the next error into MkLogFileC …

Static Public Member Functions inherited from ccmkkernel::MkObjectC
static MkObjectC *	MkObjectC_ObjNew (MK_RT_ARGS MK_OBJ hdl)
	return MkObjectC from LibMsgqueObject

static MK_OBJ	getOBJ (MkObjectC *clsHdl)
	return LibMsgqueObject from current MkObjectC pointer

static MK_OBJ	getOBJ__null_allow (MkObjectC *clsHdl)
	return LibMsgqueObject from current MkObjectC pointer

static MK_OBJN	getOBJN (const MkObjectC *clsHdl)
	(const) return LibMsgqueObject from current MkObjectC pointer

static MK_OBJN	getOBJN__null_allow (const MkObjectC *clsHdl)
	(const) return LibMsgqueObject from current MkObjectC pointer

static MK_OBJ	getOBJ (const MkObjectC &clsHdl)
	return LibMsgqueObject from current MkObjectC reference

static MK_OBJ	getOBJ__null_allow (const MkObjectC &clsHdl)
	return LibMsgqueObject from current MkObjectC reference

static MK_OBJN	getOBJN (const MkObjectC &clsHdl)
	(const) return LibMsgqueObject from current MkObjectC reference

static MK_OBJN	getOBJN__null_allow (const MkObjectC &clsHdl)
	(const) return LibMsgqueObject from current MkObjectC reference

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

static void	HandleDeleteByNetHdl (MK_HDL netHdl)
	`C++: [static] MkObjectC::HandleDeleteByNetHdl(MK_HDL netHdl)` → C-API Handle-Delete-Slot - delete a *netHdl* from handle-storage …

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

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

static void	DbgM (MK_STRN message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0)
	`C++: [static] MkObjectC::DbgM(MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API debug: write a static-marker to the MkLogFileC (default: stderr) …

static void	DbgM (const std::string &message, MK_DBG debug=0, MK_STRN callfunc=__builtin_FUNCTION(), MK_I32 lvl=0)
	`C++: [static] MkObjectC::DbgM(MK_STRN message, MK_DBG debug = 0, MK_STRN callfunc = __builtin_FUNCTION(), MK_I32 lvl = 0)` → C-API debug: write a static-marker to the MkLogFileC (default: stderr) …

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

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

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

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

static void	DeleteCallbackCleanup (MK_STRN ident)
	`C++: [static] MkObjectC::DeleteCallbackCleanup(MK_STRN ident)` → C-API cleanup the DeleteCallback installed with MkObjectDeleteCallbackSetup …

static void	DeleteCallbackCleanup (const std::string &ident)
	`C++: [static] MkObjectC::DeleteCallbackCleanup(MK_STRN ident)` → C-API cleanup the DeleteCallback installed with MkObjectDeleteCallbackSetup …

static void	DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteSCB callback=NULL, MK_STRN filter=NULL)
	`C++: [static] MkObjectC::DeleteCallbackSetup(MK_STRN ident, MkObjectDeleteICB MkObjectDeleteCCB MkObjectDeleteSCB callback = NULL, MK_STRN filter = NULL)` → C-API Create/Delete the instance-delete-callback …

static void	DeleteCallbackSetup (const std::string &ident, MkObjectDeleteSCB callback=NULL, MK_STRN filter=NULL)
	`C++: [static] MkObjectC::DeleteCallbackSetup(MK_STRN ident, MkObjectDeleteICB MkObjectDeleteCCB MkObjectDeleteSCB callback = NULL, MK_STRN filter = NULL)` → C-API Create/Delete the instance-delete-callback …

Static Public Attributes
static thread_local MkErrorC	MK_NULL_REF = {(MK_OBJ)0}

Static Public Attributes inherited from ccmkkernel::MkObjectC
static thread_local MkObjectC	MK_NULL_REF = {(MK_OBJ)0}

Friends
class	MkKernel

Additional Inherited Members
Public Types inherited from ccmkkernel::MkObjectC
typedef void(MkObjectC::*)	MkObjectDeleteICB(MK_STRN const, MK_HDL const, MK_HDL const)
	instance-callback

typedef void(*)	MkObjectDeleteCCB(MkObjectC *, MK_STRN const, MK_HDL const, MK_HDL const)
	class-callback

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

void	atomUnlink ()

	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_ARGS MK_OBJ obj)

static MK_PTR	atomObjCreate (MK_RT_ARGS MK_OBJ obj)

Protected Attributes inherited from ccmkkernel::MkObjectC
MK_OBJ	hdl = NULL

MK_RT	mkrt = NULL

Detailed Description

The data-type to store and handle the error-condition … → C-API: libmkkernel::MkErrorS

Definition at line 24 of file MkErrorC_cc.hh.

Friends And Related Symbol Documentation

◆ MkKernel

friend class MkKernel

friend

Definition at line 26 of file MkErrorC_cc.hh.

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Friends

Additional Inherited Members

Detailed Description

Friends And Related Symbol Documentation

◆ MkKernel