MkObjectC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
/*****************************************************************************/
/*                                                                           */
/*                                context                                    */
/*                                                                           */
/*****************************************************************************/
 
#define MkObjectErrorCatchTmpl(hd,...)        MkExceptionC::Catch(static_cast<MK_MNGN>(hd),__VA_ARGS__)
#define MkObjectToNameOfClassTmpl(...)        MkObjectToNameOfClass(__VA_ARGS__)
#define MkDbgDumpTmpl(...)                    MkDbgDump(__VA_ARGS__)
 
#include "MkCall_cc.hh"
 
namespace ccmkkernel {
 
  // ----------------------------------------------------------------------------------------
 
  //   BEGIN-MkObjectC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
  // doc-key: MkObjectC,MkObjectC-Class-Export,sc_
 
  inline MkObjectC* MkObjectC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    MK_OBJ __retVal__L = MkObjectHandleResolve(netHdl);
    return MkObjectC::MkObjectC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkObjectC,MkObjectC-Class-Export,om_
 
  inline void MkObjectC::HandleDelete ()  {
    MK_UNUSED auto netObj = getOBJ();
    MkObjectHandleDelete(netObj);
  }
 
  inline MK_BOOL MkObjectC::HandleExists ()  {
    MK_UNUSED auto obj = getOBJ__null_allow();
    MK_BOOL __retVal__L = MkObjectHandleExists(obj);
    return __retVal__L;
  }
 
  inline MK_HDL MkObjectC::HandleGet ()  {
    MK_UNUSED auto obj = getOBJ__null_allow();
    MK_HDL __retVal__L = MkObjectHandleGet(obj);
    return __retVal__L;
  }
 
  inline MK_HDL MkObjectC::HandleGetOfType ()  {
    MK_UNUSED auto obj = getOBJ();
    MK_HDL __retVal__L = MkObjectHandleGetOfType(obj);
    return __retVal__L;
  }
 
  inline MK_HDL MkObjectC::HandleGetOr0 ()  {
    MK_UNUSED auto obj = getOBJ__null_allow();
    MK_HDL __retVal__L = MkObjectHandleGetOr0(obj);
    return __retVal__L;
  }
 
  // doc-key: MkObjectC,MkObjectC-Class-Export,sm_
 
  inline void MkObjectC::HandleDeleteByNetHdl (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    MkObjectHandleDeleteByNetHdl(netHdl);
  }
 
  // MkObjectC_Class_CC_API
 
 
  // doc-key: MkObjectC,MkObjectC-Class-Introspection,oc_
 
  inline MkObjectC* MkObjectC::Next ()  {
    MK_UNUSED auto obj = getOBJ();
    MK_OBJ __retVal__L = MkObjectNext(obj);
    return MkObjectC::MkObjectC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkObjectC* MkObjectC::Prev ()  {
    MK_UNUSED auto obj = getOBJ();
    MK_OBJ __retVal__L = MkObjectPrev(obj);
    return MkObjectC::MkObjectC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkObjectC,MkObjectC-Class-Introspection,sc_
 
  inline MkObjectC* MkObjectC::Instances ()  {
    MkRtSetup_NULL;
    MK_OBJ __retVal__L = MkObjectInstances();
    return MkObjectC::MkObjectC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkObjectC_Class_CC_API
 
 
  // doc-key: MkObjectC,MkObjectC-Class-Misc,sc_
 
  inline MkObjectC* MkObjectC::GetNull ()  {
    MkRtSetup_NULL;
    MK_OBJ __retVal__L = MkObjectGetNull();
    return MkObjectC::MkObjectC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkObjectC_Class_CC_API
 
 
  // doc-key: MkObjectC,MkObjectC-Dbg,om_
 
  inline void MkObjectC::DbgDump (MK_STRN message, MK_STRN callfunc) const {
    MK_UNUSED auto obj = getOBJN();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    enum MkErrorE errVal = MkDbgDumpTmpl(obj, message, callfunc);
    MkErrorC_Check(obj, errVal);
  }
 
  inline void MkObjectC::DbgL (MK_STRN message, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkDbgL(fmtobj, message, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::DbgL (const std::string& message, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    const MK_STRN message_hdl = message.c_str();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkDbgL(fmtobj, message_hdl, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::DbgLogC (MK_STRN callfunc) const {
    MK_UNUSED auto obj = getOBJN();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkDbgLogC(obj, callfunc);
  }
 
  inline void MkObjectC::DbgO (MK_STRN callfunc) const {
    MK_UNUSED auto obj = getOBJN();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkDbgO(obj, callfunc);
  }
 
  inline void MkObjectC::DbgSTACK (MK_I32 skip, MK_I32 num, MK_STRN callfunc) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkDbgSTACK(fmtobj, skip, num, callfunc);
  }
 
  // doc-key: MkObjectC,MkObjectC-Dbg,sm_
 
  inline void MkObjectC::DbgM (MK_STRN message, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl)  {
    MkRtSetup_NULL;
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkDbgM(message, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::DbgM (const std::string& message, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl)  {
    MkRtSetup_NULL;
    const MK_STRN message_hdl = message.c_str();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkDbgM(message_hdl, debug, callfunc, lvl);
  }
 
  // MkObjectC_Dbg_CC_API
 
 
  // doc-key: MkObjectC,MkObjectC-Log,om_
 
  inline void MkObjectC::LogC (MK_STRN message, MK_DBG debug, MK_STRN callfunc) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkLogC(fmtobj, message, debug, callfunc);
  }
 
  inline void MkObjectC::LogC (const std::string& message, MK_DBG debug, MK_STRN callfunc) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    const MK_STRN message_hdl = message.c_str();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkLogC(fmtobj, message_hdl, debug, callfunc);
  }
 
  inline void MkObjectC::LogHEX (MK_STRN callfunc, MK_BNP data) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    const MkBinaryR data_ref = MkBinaryCreate(data.first,data.second);
    MkLogHEX(fmtobj, callfunc, data_ref);
  }
 
  inline void MkObjectC::LogHEX (const std::string& callfunc, MK_BNP data) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    const MK_STRN callfunc_hdl = callfunc.c_str();
    const MkBinaryR data_ref = MkBinaryCreate(data.first,data.second);
    MkLogHEX(fmtobj, callfunc_hdl, data_ref);
  }
 
  inline void MkObjectC::LogV (MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, ... ) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    va_list ap;
    va_start (ap, printfmt);
    MkLogVL(fmtobj, callfunc, debug, printfmt, ap);
    va_end (ap);
  }
 
  inline void MkObjectC::LogV (const std::string& callfunc, MK_DBG debug, MK_FST printfmt, ... ) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    const MK_STRN callfunc_hdl = callfunc.c_str();
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    va_list ap;
    va_start (ap, printfmt);
    MkLogVL(fmtobj, callfunc_hdl, debug, printfmt, ap);
    va_end (ap);
  }
 
  inline void MkObjectC::LogVL (MK_STRN callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkLogVL(fmtobj, callfunc, debug, printfmt, var_list);
  }
 
  inline void MkObjectC::LogVL (const std::string& callfunc, MK_DBG debug, MK_FST printfmt, va_list var_list) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    const MK_STRN callfunc_hdl = callfunc.c_str();
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkLogVL(fmtobj, callfunc_hdl, debug, printfmt, var_list);
  }
 
  inline void MkObjectC::Log (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto obj = getOBJN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkObjectLog(obj, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::Log (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto obj = getOBJN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkObjectLog(obj, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::LogLong (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto obj = getOBJN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkObjectLogLong(obj, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::LogLong (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto obj = getOBJN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkObjectLogLong(obj, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::LogShort (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto obj = getOBJN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkObjectLogShort(obj, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::LogShort (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto obj = getOBJN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkObjectLogShort(obj, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::LogType (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto obj = getOBJN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkObjectLogType(obj, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void MkObjectC::LogType (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto obj = getOBJN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    MkObjectLogType(obj, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  // MkObjectC_Log_CC_API
 
 
  // doc-key: MkObjectC,MkObjectC-Misc,oc_
 
  inline MkErrorC* MkObjectC::ErrorCatch (std::exception* exception, MK_STRN callfunc) const {
    MK_UNUSED auto obj = getOBJN();
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MK_ERR __retVal__L = MkObjectErrorCatchTmpl(obj, exception, callfunc);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkErrorC* MkObjectC::ErrorCatch (const std::exception& exception, MK_STRN callfunc) const {
    MK_UNUSED auto obj = getOBJN();
    const std::exception* exception_hdl = &exception;
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MK_ERR __retVal__L = MkObjectErrorCatchTmpl(obj, exception_hdl, callfunc);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkErrorC* MkObjectC::ToError ()  {
    MK_UNUSED auto obj = getOBJ();
    MK_ERR __retVal__L = MkObjectToError(obj);
    return MkErrorC::MkErrorC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkObjectC,MkObjectC-Misc,om_
 
  inline MK_BOOL MkObjectC::IsNull ()  {
    MK_UNUSED auto obj = getOBJ__null_allow();
    MK_BOOL __retVal__L = MkObjectIsNull(obj);
    return __retVal__L;
  }
 
  inline MK_STRN MkObjectC::ToName () const {
    MK_UNUSED auto obj = getOBJN__null_allow();
    MK_STRN __retVal__L = MkObjectToName(obj);
    return __retVal__L;
  }
 
  inline MK_STRN MkObjectC::ToNameOfClass ()  {
    MK_UNUSED auto obj = getOBJ();
    MK_STRN __retVal__L = MkObjectToNameOfClassTmpl(obj);
    return __retVal__L;
  }
 
  inline MK_STRN MkObjectC::ToNameOfType () const {
    MK_UNUSED auto obj = getOBJN();
    MK_STRN __retVal__L = MkObjectToNameOfType(obj);
    return __retVal__L;
  }
 
  inline MK_STRN MkObjectC::ToString () const {
    MK_UNUSED auto inst = getOBJN__null_allow();
    MK_STRN __retVal__L = MkObjectToString(inst);
    return __retVal__L;
  }
 
  // MkObjectC_Misc_CC_API
 
 
  // doc-key: MkObjectC,MkObjectC-Obj,om_
 
  inline MK_I32 MkObjectC::RefGet ()  {
    MK_UNUSED auto obj = getOBJ();
    MK_I32 __retVal__L = MkRefGet(obj);
    return __retVal__L;
  }
 
  // MkObjectC_Obj_CC_API
 
 
  // doc-key: MkObjectC,MkObjectC-Sys,om_
 
  inline void MkObjectC::SysKill (MK_I32 pid, MK_I32 signal) const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    enum MkErrorE errVal = MkSysKill(fmtobj, pid, signal);
    MkErrorC_Check(fmtobj, errVal);
  }
 
  // doc-key: MkObjectC,MkObjectC-Sys,omo
 
  inline MK_I32 MkObjectC::SysGetPid () const {
    MK_UNUSED auto fmtobj = getOBJN__null_allow();
    MK_I32 pid_out;
    enum MkErrorE errVal = MkSysGetPid(fmtobj, &pid_out);
    MkErrorC_Check(fmtobj, errVal);
    return pid_out;
  }
 
  // doc-key: MkObjectC,MkObjectC-Sys,sm_
 
  inline MK_I32 MkObjectC::SysHashI32 (MK_STRN key, MK_NUM length)  {
    MkRtSetup_NULL;
    MK_I32 __retVal__L = MkSysHashI32(key, length);
    return __retVal__L;
  }
 
  inline MK_I32 MkObjectC::SysHashI32 (const std::string& key, MK_NUM length)  {
    MkRtSetup_NULL;
    const MK_STRN key_hdl = key.c_str();
    MK_I32 __retVal__L = MkSysHashI32(key_hdl, length);
    return __retVal__L;
  }
 
  inline MK_STRN MkObjectC::SysHashSTR (MK_STRN key, MK_NUM length)  {
    MkRtSetup_NULL;
    MK_STRN __retVal__L = MkSysHashSTR(key, length);
    return __retVal__L;
  }
 
  inline MK_STRN MkObjectC::SysHashSTR (const std::string& key, MK_NUM length)  {
    MkRtSetup_NULL;
    const MK_STRN key_hdl = key.c_str();
    MK_STRN __retVal__L = MkSysHashSTR(key_hdl, length);
    return __retVal__L;
  }
 
  // MkObjectC_Sys_CC_API
 
 
  // doc-key: MkObjectC,MkObjectC-TOR,od_
 
  inline void MkObjectC::Dispose ()  {
    MK_UNUSED auto obj = getOBJ();
    MkObjectDispose(hdl); // need 'hdl' to be set to NULL
  }
 
  // doc-key: MkObjectC,MkObjectC-TOR,oD_
 
  inline void MkObjectC::Delete ()  {
    MK_UNUSED auto obj = getOBJ();
    delete this;
  }
 
  // doc-key: MkObjectC,MkObjectC-TOR,sm_
 
  inline void MkObjectC::DeleteCallbackCleanup (MK_STRN ident)  {
    MkRtSetup_NULL;
    MkObjectDeleteCallbackCleanup(ident);
  }
 
  inline void MkObjectC::DeleteCallbackCleanup (const std::string& ident)  {
    MkRtSetup_NULL;
    const MK_STRN ident_hdl = ident.c_str();
    MkObjectDeleteCallbackCleanup(ident_hdl);
  }
 
  inline void MkObjectC::DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteCCB callback, MK_STRN filter)  {
    MkRtSetup_O(getOBJ());
    auto fCall = MkObjectDeleteCallbackC::Call;
    auto callback_ptr = MkObjectDeleteCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    enum MkErrorE errVal = MkObjectDeleteCallbackSetup(ident, fCall, callback_ptr, MkObjectDeleteCallbackC::Free, filter);
    MkErrorC_Check(NULL, errVal);
  }
 
  inline void MkObjectC::DeleteCallbackSetup (const std::string& ident, MkObjectDeleteCCB callback, MK_STRN filter)  {
    MkRtSetup_O(getOBJ());
    auto fCall = MkObjectDeleteCallbackC::Call;
    const MK_STRN ident_hdl = ident.c_str();
    auto callback_ptr = MkObjectDeleteCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    enum MkErrorE errVal = MkObjectDeleteCallbackSetup(ident_hdl, fCall, callback_ptr, MkObjectDeleteCallbackC::Free, filter);
    MkErrorC_Check(NULL, errVal);
  }
 
  inline void MkObjectC::DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteICB callback, MK_STRN filter)  {
    MkRtSetup_O(getOBJ());
    auto fCall = MkObjectDeleteCallbackC::Call;
    auto callback_ptr = MkObjectDeleteCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    enum MkErrorE errVal = MkObjectDeleteCallbackSetup(ident, fCall, callback_ptr, MkObjectDeleteCallbackC::Free, filter);
    MkErrorC_Check(NULL, errVal);
  }
 
  inline void MkObjectC::DeleteCallbackSetup (const std::string& ident, MkObjectDeleteICB callback, MK_STRN filter)  {
    MkRtSetup_O(getOBJ());
    auto fCall = MkObjectDeleteCallbackC::Call;
    const MK_STRN ident_hdl = ident.c_str();
    auto callback_ptr = MkObjectDeleteCallbackC::Create(MK_RT_CALL callback, this);
    if (callback_ptr == NULL) fCall = NULL;
    enum MkErrorE errVal = MkObjectDeleteCallbackSetup(ident_hdl, fCall, callback_ptr, MkObjectDeleteCallbackC::Free, filter);
    MkErrorC_Check(NULL, errVal);
  }
 
  inline void MkObjectC::DeleteCallbackSetup (MK_STRN ident, MkObjectDeleteSCB callback, MK_STRN filter)  {
    MkRtSetup_NULL;
    auto fCall = MkObjectDeleteCallbackC::Call;
    auto callback_ptr = MkObjectDeleteCallbackC::Create(MK_RT_CALL callback, NULL);
    if (callback_ptr == NULL) fCall = NULL;
    enum MkErrorE errVal = MkObjectDeleteCallbackSetup(ident, fCall, callback_ptr, MkObjectDeleteCallbackC::Free, filter);
    MkErrorC_Check(NULL, errVal);
  }
 
  inline void MkObjectC::DeleteCallbackSetup (const std::string& ident, MkObjectDeleteSCB callback, MK_STRN filter)  {
    MkRtSetup_NULL;
    auto fCall = MkObjectDeleteCallbackC::Call;
    const MK_STRN ident_hdl = ident.c_str();
    auto callback_ptr = MkObjectDeleteCallbackC::Create(MK_RT_CALL callback, NULL);
    if (callback_ptr == NULL) fCall = NULL;
    enum MkErrorE errVal = MkObjectDeleteCallbackSetup(ident_hdl, fCall, callback_ptr, MkObjectDeleteCallbackC::Free, filter);
    MkErrorC_Check(NULL, errVal);
  }
 
  // MkObjectC_TOR_CC_API
 
  //   END-MkObjectC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ########################################################################################
// OVERLOAD
 
/*
  inline MK_PTR MkObjectC::MkObjectC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
    return new MkObjectC(obj);
  }
*/
 
} // END - namespace "ccmkkernel"