MkObjectC.cs

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#define META_IS_OBJECT
 
/* LABEL-START */
 
using System;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Collections.Generic;
using System.Threading;
 
namespace csmkkernel {
 
#if META_IS_OBJECT
  public partial class MkObjectC
#else
  public partial class MkObjectC : MkObjectC
#endif
  {
    private readonly static ConstructorInfo ctor = getCtor(typeof(MkObjectC));
    private readonly static ThreadLocal<MkObjectC> MK_NULL = new ThreadLocal<MkObjectC>(() => {
      return (MkObjectC) atomSelfNull(ctor);
    });
 
    public static MkObjectC MkObjectC_ObjNew (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MkObjectC) atomObjNew(typeof(MkObjectC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static MkObjectC MkObjectC_ObjCreate (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MkObjectC) atomObjCreate(typeof(MkObjectC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static IntPtr MkObjectC_SelfCreate (IntPtr mkrt, IntPtr obj, IntPtr env) {
      return atomSelfCreate(ctor, obj, env);
    }
 
    private static void MkObjectC_SelfUnlink (IntPtr mkrt, IntPtr self, IntPtr env) {
      atomSelfUnlink(self, env);
    }
 
    internal static void SetupThreadOBJ (IntPtr mkrt) {
      Mk.MkCsTypeUpdate(mkrt, MkCsTypeLookupE.OBJ, MkObjectC_SelfCreate, MkObjectC_SelfUnlink);
    }
 
    #if !META_STATIC_OVERWRITE
 
    static MkObjectC() {
      // M0("MkObjectC");
      MkKernel.Setup();
      SetupThreadOBJ(IntPtr.Zero);
    }
 
    #endif
/* LABEL-END */
 
    private IntPtr  phdl = IntPtr.Zero;
    protected IntPtr pmkrt = IntPtr.Zero;
 
    // after "Dispose" the "hdl" becomes "unusable=NULL" but the object is still alive.
    // goal is to raise an "Exception" on access to the "hdl" AFTER "Dispose"
    // WITHOUT "Exception" the LibMqMsgque function will be called with a "NULL" pointer…
    // and this will end the entire process.
    public IntPtr hdl {
      get {
        if (phdl == IntPtr.Zero) throw new NullReferenceException($"'{this.GetType().Name}' hdl is NULL");
        return phdl;
      }
      set {
        phdl = value;
      }
    }
 
    public IntPtr hdl_null_allow {
      get {
        return phdl;
      }
      set {
        phdl = value;
      }
    }
 
    protected IntPtr mkrt {
      get {
/*
        if (pmkrt != Mk.MkRuntimeGet()) {
          Console.Error.WriteLine($"runtime invalid: {pmkrt} != {Mk.MkRuntimeGet()}");
        }
*/
        return pmkrt;
      }
      set {
        pmkrt = value;
      }
    }
 
    public static IntPtr getOBJ (string cls, MkObjectC obj) {
      if (obj == null || obj.phdl == IntPtr.Zero) {
        throw new NullReferenceException($"'{obj != null ? obj.GetType().Name : cls}' hdl is NULL");
      }
      return obj.phdl;
    }
 
    public static IntPtr getOBJ_null_allow (MkObjectC obj) {
      if (obj == null) return IntPtr.Zero;
      return obj.phdl;
    }
 
    internal protected MkObjectC (IntPtr obj) {
      atomCreate(obj);
    }
 
    protected MkObjectC () {}
 
    internal void atomCreate (IntPtr obj) {
      if (obj == IntPtr.Zero) {
        hdl = obj;
        mkrt = Mk.MkRuntimeGet();
      } else if (Mk.MkObjCheck(obj)) {
        hdl = obj;
        mkrt = Mk.MkRuntimeGetFromObj(obj);
#if META_STRONG_REF
        Mk.MkRefIncrSelf(obj, (IntPtr) GCHandle.Alloc(this), IntPtr.Zero);
#else
        Mk.MkRefIncrSelf(obj, (IntPtr) GCHandle.Alloc(this,GCHandleType.Weak), IntPtr.Zero);
#endif
      } else {
        throw new MkSignatureExceptionC("MkObjectC");
      }
    }
 
    // C# object is already dead
    internal void atomDeleteSoft () {
      //printStack("atomDelete");
      //DbgSTACK();
      IntPtr self = Mk.CsGetSelfPtr(Mk.MkObj(phdl));
      if (self != IntPtr.Zero) {
        var gch = GCHandle.FromIntPtr(self);
        Mk.MkRefDecrWithoutSelf(mkrt,phdl);
        gch.Free();
      } else {
        Mk.MkRefDecr(mkrt,phdl);
      }
      phdl = IntPtr.Zero;
 
      // This object will be cleaned up by the Dispose method.
      // Therefore, you should call GC.SupressFinalize to
      // take this object off the finalization queue
      // and prevent finalization code for this object
      // from executing a second time.
      GC.SuppressFinalize(this);
    }
 
    // C# object is still alive 
    internal void atomDeleteHard () {
      //printStack("atomDelete");
      //DbgSTACK();
      IntPtr self = Mk.CsGetSelfPtr(Mk.MkObj(phdl));
      if (self != IntPtr.Zero) {
        var gch = GCHandle.FromIntPtr(self);
        Mk.MkRefDecrWithUnlinkSelf(mkrt,phdl);
        gch.Free();
      } else {
        Mk.MkRefDecr(mkrt,phdl);
      }
      phdl = IntPtr.Zero;
 
      // This object will be cleaned up by the Dispose method.
      // Therefore, you should call GC.SupressFinalize to
      // take this object off the finalization queue
      // and prevent finalization code for this object
      // from executing a second time.
      GC.SuppressFinalize(this);
    }
 
    // TODO: this is NOT the design standart because "MkSelfNew" is not used and also "selfCreate/selfDelete"
    protected static object atomObjNew (Type type, ConstructorInfo ctor, IntPtr obj) {
      IntPtr self = Mk.CsGetSelfPtr(obj);
      if (self != IntPtr.Zero) {
#if META_STRONG_REF
        return GCHandle.FromIntPtr(self).Target;
#else
        object ret =  GCHandle.FromIntPtr(self).Target;
        if (ret != null) return ret;
#endif
      }
      return ctor.Invoke(new Object[] {obj});
    }
 
    protected static object atomObjCreate (Type type, ConstructorInfo ctor, IntPtr obj) {
//printTyp(obj, getCallerProc(3) + "-" + type.Name);
      return ctor.Invoke(new Object[] {obj});
    }
 
    protected static IntPtr atomSelfCreate (ConstructorInfo ctor, IntPtr obj, IntPtr env) {
//printTyp(obj, getCallerProc(3) + "-" + type.Name);
      if (obj == IntPtr.Zero) {
        return IntPtr.Zero;
      } else {
        ctor.Invoke(new Object[] {obj});
        return Mk.CsGetSelfPtr(obj);
      }
    }
 
    protected static object atomSelfNull (ConstructorInfo ctor) {
//printTyp(obj, getCallerProc(3) + "-" + type.Name);
      return ctor.Invoke(new Object[] {IntPtr.Zero});
    }
 
    protected static void atomSelfUnlink (IntPtr self, IntPtr env) {
      var obj = (MkObjectC) GCHandle.FromIntPtr(self).Target;
#if META_STRONG_REF
      obj.hdl = IntPtr.Zero;
#else
      if (obj != null) obj.hdl = IntPtr.Zero;
#endif
    }
 
/*
HUGE problem that FINALIZE is called from other thread as the ORIGINAL thread created on…
AND that left-over instances are FINALIZED !! after !! the starting thread (and the libmkkernel ressources)
are already gone.
 
-> don't have a finalize will propably create a memory leak.
 
    ~MkObjectC () {
//printTyp(hdl, "~MkObjectC");
      Dispose(false);
    }
*/
 
    protected static ConstructorInfo getCtor (Type type) {
      Type[] types = new Type[1];
      types[0] = typeof(IntPtr);
      ConstructorInfo constr = type.GetConstructor(
        BindingFlags.Instance | BindingFlags.NonPublic, null, CallingConventions.HasThis, types, null
      );
      if (constr == null) {
        throw new Exception("internal constructor '" + type.Name + " (IntPtr)' not found.");
      }
      return constr;
    }
 
    protected static string Name (IntPtr mkrt, IntPtr obj) {
      return Marshal.PtrToStringAnsi(Mk.MkObjectToName(mkrt,obj));
    }
 
  // PROTECTED
 
    protected virtual void Dispose(bool disposing)
    {
//printStack("Dispose");
 
      // Check to see if Dispose has already been called.
      if(phdl != IntPtr.Zero)
      //if(hdl != IntPtr.Zero)
      {
        // If disposing equals true, dispose all managed
        // and unmanaged resources.
        if(disposing)
        {
          // Dispose managed resources. (not used here)
        }
 
        // Call the appropriate methods to clean up
        // unmanaged resources here.
        // If disposing is false,
        // only the following code is executed.
 
        // Note disposing has been done.
        // hint: MkRefDecr->FactoryDelete->Dispose => double-invoke
        atomDeleteSoft();
      }
    }
 
  // PUBLIC
 
    public bool Check() {
      return phdl != IntPtr.Zero;
    }
    
    // overload
    private static IntPtr MkObjectErrorCatchTmpl (IntPtr mkrt, IntPtr hdl, Exception exception, IntPtr callfunc)  {
      return MkExceptionC.Catch(mkrt, hdl, exception, callfunc);
    }
 
    // overload
    private string MkObjectToNameOfClassTmpl (IntPtr dummy)  {
      return this.GetType().Name;
    }
 
    private MkErrorE MkDbgDumpTmpl (IntPtr mkrt, IntPtr hdl, IntPtr message, IntPtr callfunc) {
      return Mk.MkDbgDump(mkrt,hdl,message,callfunc);
    }
 
    public string ToNameOfClass ()  {
      return GetType().Name;
    }
 
  } // END - class "MkObjectC"
 
  // BEGIN-MkObjectC - created by 'cs_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-Class-Export,sc_
 
    public static MkObjectC HandleResolve (Int32 netHdl)  {
      IntPtr __retVal__L = Mk.MkObjectHandleResolve(IntPtr.Zero, netHdl);
      return MkObjectC.MkObjectC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkObjectC,MkObjectC-Class-Export,om_
 
    public void HandleDelete ()  {
      Mk.MkObjectHandleDelete(mkrt, hdl);
    }
 
    public bool HandleExists ()  {
      bool __retVal__L = Mk.MkObjectHandleExists(hdl_null_allow);
      return __retVal__L;
    }
 
    public Int32 HandleGet ()  {
      Int32 __retVal__L = Mk.MkObjectHandleGet(mkrt, hdl_null_allow);
      return __retVal__L;
    }
 
    public Int32 HandleGetOfType ()  {
      Int32 __retVal__L = Mk.MkObjectHandleGetOfType(hdl);
      return __retVal__L;
    }
 
    public Int32 HandleGetOr0 ()  {
      Int32 __retVal__L = Mk.MkObjectHandleGetOr0(hdl_null_allow);
      return __retVal__L;
    }
 
    // doc-key: MkObjectC,MkObjectC-Class-Export,sm_
 
    public static void HandleDeleteByNetHdl (Int32 netHdl)  {
      Mk.MkObjectHandleDeleteByNetHdl(IntPtr.Zero, netHdl);
    }
 
    // MkObjectC_Class_CS_API
  }
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-Class-Introspection,oc_
 
    public MkObjectC Next ()  {
      IntPtr __retVal__L = Mk.MkObjectNext(hdl);
      return MkObjectC.MkObjectC_ObjNew(__retVal__L);
    }
 
    public MkObjectC Prev ()  {
      IntPtr __retVal__L = Mk.MkObjectPrev(hdl);
      return MkObjectC.MkObjectC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkObjectC,MkObjectC-Class-Introspection,sc_
 
    public static MkObjectC Instances ()  {
      IntPtr __retVal__L = Mk.MkObjectInstances(IntPtr.Zero);
      return MkObjectC.MkObjectC_ObjNew(__retVal__L);
    }
 
    // MkObjectC_Class_CS_API
  }
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-Class-Misc,sc_
 
    public static MkObjectC GetNull ()  {
      IntPtr __retVal__L = Mk.MkObjectGetNull();
      return MkObjectC.MkObjectC_ObjNew(__retVal__L);
    }
 
    // MkObjectC_Class_CS_API
  }
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-Dbg,om_
 
    public void DbgDump (string message = "var", [CallerMemberName]string callfunc = null)  {
      IntPtr message_cstr = Marshal.StringToHGlobalAnsi(message);
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      MkErrorE errVal = MkDbgDumpTmpl(mkrt, hdl, message_cstr, callfunc_cstr);
      Marshal.FreeHGlobal(message_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void DbgL (string message, int debug = 0, [CallerMemberName]string callfunc = null, int lvl = 0)  {
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr message_cstr = Marshal.StringToHGlobalAnsi(message);
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkDbgL(mkrt, hdl_null_allow, message_cstr, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(message_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void DbgLogC ([CallerMemberName]string callfunc = null)  {
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkDbgLogC(mkrt, hdl, callfunc_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void DbgO ([CallerMemberName]string callfunc = null)  {
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkDbgO(mkrt, hdl, callfunc_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void DbgSTACK (int skip = 0, int num = -1, [CallerMemberName]string callfunc = null)  {
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkDbgSTACK(mkrt, hdl_null_allow, skip, num, callfunc_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    // doc-key: MkObjectC,MkObjectC-Dbg,sm_
 
    public static void DbgM (string message, int debug = 0, [CallerMemberName]string callfunc = null, int lvl = 0)  {
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr message_cstr = Marshal.StringToHGlobalAnsi(message);
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkDbgM(IntPtr.Zero, message_cstr, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(message_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    // MkObjectC_Dbg_CS_API
  }
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-Log,om_
 
    public void LogC (string message, int debug = 0, [CallerMemberName]string callfunc = null)  {
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr message_cstr = Marshal.StringToHGlobalAnsi(message);
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkLogC(mkrt, hdl_null_allow, message_cstr, debug, callfunc_cstr);
      Marshal.FreeHGlobal(message_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogHEX (string callfunc, byte[] data)  {
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      var data_size = Marshal.SizeOf(data[0]) * data.Length;
      var data_data = Marshal.AllocHGlobal(data_size);
      Marshal.Copy(data,0,data_data,data_size);
      Mk.MkBinaryR data_ref = Mk.MkBinaryCreate(data_size,data_data);
      Mk.MkLogHEX(mkrt, hdl_null_allow, callfunc_cstr, data_ref);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void Log (MkObjectC fmtobj = null, int debug = 0, [CallerMemberName]string callfunc = null, int lvl = 0)  {
      IntPtr fmtobj_hdl = MkObjectC.getOBJ_null_allow(fmtobj);
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkObjectLog(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogLong (MkObjectC fmtobj = null, int debug = 0, [CallerMemberName]string callfunc = null, int lvl = 0)  {
      IntPtr fmtobj_hdl = MkObjectC.getOBJ_null_allow(fmtobj);
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkObjectLogLong(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogShort (MkObjectC fmtobj = null, int debug = 0, [CallerMemberName]string callfunc = null, int lvl = 0)  {
      IntPtr fmtobj_hdl = MkObjectC.getOBJ_null_allow(fmtobj);
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkObjectLogShort(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogType (MkObjectC fmtobj = null, int debug = 0, [CallerMemberName]string callfunc = null, int lvl = 0)  {
      IntPtr fmtobj_hdl = MkObjectC.getOBJ_null_allow(fmtobj);
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkObjectLogType(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    // MkObjectC_Log_CS_API
  }
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-Misc,oc_
 
    public MkErrorC ErrorCatch (Exception exception = null, [CallerMemberName]string callfunc = null)  {
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      IntPtr __retVal__L = MkObjectErrorCatchTmpl(mkrt, hdl, exception, callfunc_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
      return MkErrorC.MkErrorC_ObjNew(__retVal__L);
    }
 
    public MkErrorC ToError ()  {
      IntPtr __retVal__L = Mk.MkObjectToError(mkrt, hdl);
      return MkErrorC.MkErrorC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkObjectC,MkObjectC-Misc,om_
 
    public bool IsNull ()  {
      bool __retVal__L = Mk.MkObjectIsNull(hdl_null_allow);
      return __retVal__L;
    }
 
    public string ToName ()  {
      IntPtr __retVal__L = Mk.MkObjectToName(mkrt, hdl_null_allow);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
 
    public string ToNameOfType ()  {
      IntPtr __retVal__L = Mk.MkObjectToNameOfType(mkrt, hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    override public string ToString ()  {
      IntPtr __retVal__L = Mk.MkObjectToString(mkrt, hdl_null_allow);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // MkObjectC_Misc_CS_API
  }
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-Obj,om_
 
    public int RefGet ()  {
      Int32 __retVal__L = Mk.MkRefGet(hdl);
      return __retVal__L;
    }
 
    // MkObjectC_Obj_CS_API
  }
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-Sys,om_
 
    public void SysKill (int pid, int signal)  {
      MkErrorE errVal = Mk.MkSysKill(hdl_null_allow, pid, signal);
      MkErrorC.Check(hdl_null_allow, errVal);
    }
 
    // doc-key: MkObjectC,MkObjectC-Sys,omo
 
    public int SysGetPid ()  {
      Int32 pid_out;
      MkErrorE errVal = Mk.MkSysGetPid(hdl_null_allow, out pid_out);
      MkErrorC.Check(hdl_null_allow, errVal);
      return pid_out;
    }
 
    // doc-key: MkObjectC,MkObjectC-Sys,sm_
 
    public static int SysHashI32 (string key, int length = -1)  {
      IntPtr key_cstr = Marshal.StringToHGlobalAnsi(key);
      Int32 __retVal__L = Mk.MkSysHashI32(key_cstr, length);
      Marshal.FreeHGlobal(key_cstr);
      return __retVal__L;
    }
 
    public static string SysHashSTR (string key, int length = -1)  {
      IntPtr key_cstr = Marshal.StringToHGlobalAnsi(key);
      IntPtr __retVal__L = Mk.MkSysHashSTR(key_cstr, length);
      Marshal.FreeHGlobal(key_cstr);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // MkObjectC_Sys_CS_API
  }
 
  public partial class MkObjectC {
 
 
    // doc-key: MkObjectC,MkObjectC-TOR,od_
 
    public void Dispose ()  {
      // Do not make this method virtual. !!
      // A derived class should not be able to override this method.
      Dispose(true);
 
      // This object will be cleaned up by the Dispose method.
      // Therefore, you should call GC.SupressFinalize to
      // take this object off the finalization queue
      // and prevent finalization code for this object
      // from executing a second time.
      GC.SuppressFinalize(this);
    }
 
    // doc-key: MkObjectC,MkObjectC-TOR,oD_
 
    public void Delete ()  {
      // Do not make this method virtual. !!
      // A derived class should not be able to override this method.
      Dispose(true);
 
      // This object will be cleaned up by the Dispose method.
      // Therefore, you should call GC.SupressFinalize to
      // take this object off the finalization queue
      // and prevent finalization code for this object
      // from executing a second time.
      GC.SuppressFinalize(this);
    }
 
    // doc-key: MkObjectC,MkObjectC-TOR,sm_
 
    public static void DeleteCallbackCleanup (string ident)  {
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      Mk.MkObjectDeleteCallbackCleanup(IntPtr.Zero, ident_cstr);
      Marshal.FreeHGlobal(ident_cstr);
    }
 
    public static void DeleteCallbackSetup (string ident, MkObjectDeleteSCB callback = null, string filter = null)  {
      MkObjectDeleteCallF fCall = ObjectDeleteCall;
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MkCall(callback));
      if (callback_ptr == IntPtr.Zero) fCall = null;
      IntPtr filter_cstr = Marshal.StringToHGlobalAnsi(filter);
      MkErrorE errVal = Mk.MkObjectDeleteCallbackSetup(IntPtr.Zero, ident_cstr, fCall, callback_ptr, ObjectDeleteFree, filter_cstr);
      Marshal.FreeHGlobal(ident_cstr);
      Marshal.FreeHGlobal(filter_cstr);
      if (errVal > MkErrorE.CONTINUE) MkErrorC.Check(errVal);
    }
 
    // MkObjectC_TOR_CS_API
  }
 
  // END-MkObjectC - created by 'cs_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
} // END - namespace "csmkkernel"