MqContextC.cs

Go to the documentation of this file.

 
/* LABEL-INIT */
 
#define META_STATIC_OVERWRITE
 
using csmkkernel;
using System.Diagnostics;
using System.Threading.Tasks;
 
/* LABEL-START */
 
using System;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;
using System.Collections.Generic;
using System.Threading;
 
namespace csmqmsgque {
 
#if META_IS_OBJECT
  public partial class MqContextC
#else
  public partial class MqContextC : MkObjectC
#endif
  {
    private readonly static ConstructorInfo ctor = getCtor(typeof(MqContextC));
    private readonly static ThreadLocal<MqContextC> MK_NULL = new ThreadLocal<MqContextC>(() => {
      return (MqContextC) atomSelfNull(ctor);
    });
 
    public static MqContextC MqContextC_ObjNew (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MqContextC) atomObjNew(typeof(MqContextC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static MqContextC MqContextC_ObjCreate (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MqContextC) atomObjCreate(typeof(MqContextC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static IntPtr MqContextC_SelfCreate (IntPtr mkrt, IntPtr obj, IntPtr env) {
      return atomSelfCreate(ctor, obj, env);
    }
 
    private static void MqContextC_SelfUnlink (IntPtr mkrt, IntPtr self, IntPtr env) {
      atomSelfUnlink(self, env);
    }
 
    internal static void SetupThreadCTX (IntPtr mkrt) {
      Mq.MqCsTypeUpdate(mkrt, MqCsTypeLookupE.CTX, MqContextC_SelfCreate, MqContextC_SelfUnlink);
    }
 
    #if !META_STATIC_OVERWRITE
 
    static MqContextC() {
      // M0("MqContextC");
      MqMsgque.Setup();
      SetupThreadCTX(IntPtr.Zero);
    }
 
    #endif
/* LABEL-END */
 
  }
 
  // USER DEFINED CONFIG
  public partial class MqContextC
  {
    public static MqContextC MqContextC_ObjNewOrNull (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MqContextC) atomObjNew(typeof(MqContextC), ctor, hdl) : null;
    }
 
    private static IntPtr MqContextCTT = IntPtr.Zero;
    private static string APP  = Assembly.GetEntryAssembly().Location;
 
    // START class config
    static MqContextC() {
      // init libmqmsgque
      MqMsgque.Setup();
      var mkrt = Mk.MkRuntimeGet();
      SetupThreadCTX(mkrt);
 
      // START type config
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi("CsMqContextC");
        unsafe {
          MqContextCTT = Mq.MqCsContextTypeCreate(mkrt, ident_cstr,
                          fDefaultLinkCreate, null, fDefaultLinkCreate, null, 
                            ProcessExit, ThreadExit, WaitForPipe);
        }
      Marshal.FreeHGlobal(ident_cstr);
      // END type config
 
      // setup default "starter"
      if (Mq.MqInitGetArg0() == IntPtr.Zero) {
        IntPtr initB = Mq.MqInitResetArg0();
        if(Type.GetType("Mono.Runtime") != null) {
          IntPtr cstr1 = Marshal.StringToHGlobalAnsi("mono");
            Mk.MkBufferListAppendSTR(mkrt, initB, cstr1);
          Marshal.FreeHGlobal(cstr1);
        }
        IntPtr cstr2 = Marshal.StringToHGlobalAnsi(APP);
          Mk.MkBufferListAppendSTR(mkrt, initB, cstr2);
        Marshal.FreeHGlobal(cstr2);
      }
      // END class config
    }
 
    internal MqContextC (IntPtr hdl) : base(hdl) {
      if (this is MqServerSetupIF) {
        IntPtr data = (IntPtr) GCHandle.Alloc(new MqCall(mkrt, (MqServiceICB)((MqServerSetupIF) this).ServerSetup));
        Mq.MqConfigSetServerSetup (mkrt, hdl, ServiceCall, data, ServiceFree, null);
      }
 
      if (this is MqServerCleanupIF) {
        IntPtr data = (IntPtr) GCHandle.Alloc(new MqCall(mkrt, (MqServiceICB)((MqServerCleanupIF) this).ServerCleanup));
        Mq.MqConfigSetServerCleanup (mkrt, hdl, ServiceCall, data, ServiceFree, null);
      }
 
      if (this is MqBgErrorIF) {
        Mq.MqConfigSetBgError (mkrt, hdl, ServiceCall, (IntPtr) GCHandle.Alloc(
          new MqCall(mkrt, (MqServiceICB)((MqBgErrorIF) this).BgError)), ServiceFree, null);
      }
 
      if (this is MqEventIF) {
        Mq.MqConfigSetEvent (mkrt, hdl, ServiceCall, (IntPtr) GCHandle.Alloc(
          new MqCall(mkrt, (MqServiceICB)((MqEventIF) this).Event)), ServiceFree, null);
      }
    }
 
    // https://stackoverflow.com/questions/4257372/how-to-force-garbage-collector-to-run
    // System.GC.Collect();
    private static int ProcessExit (IntPtr mkrt, int num) {
      Environment.Exit (num);
      return num;
    }
 
    // https://stackoverflow.com/questions/4257372/how-to-force-garbage-collector-to-run
    // System.GC.Collect();
    private static int ThreadExit (IntPtr mkrt, int num) {
      return num;
    }
 
    private unsafe static bool WaitForPipe ( IntPtr mkrt, IntPtr ctx, MkIdS *idP ) {
      bool retB = false;
      switch ((*idP).type) {  
        case MkIdSE.PROCESS: { 
          // attention: theKernel/c/sys_mk.c -> SysWaitForProcess -> MK_ID_PROCESS
          var p = Process.GetProcessById((*idP).val.ToInt32());
          p.WaitForExit(200);
          retB = true;
          break;
        }
        case MkIdSE.THREAD: {
          if ((*idP).setByExtern) {
            var hdl  = GCHandle.FromIntPtr((*idP).val);
            var task = (Task) hdl.Target;
            if (task != null) {
              task.Wait(200);
              retB = true;
            }
            hdl.Free();
          }
          break;
        }
        case MkIdSE.UNUSED: {
          break;
        }
      }
      return retB;
    }
    
  // PUBLIC
 
  // ----------------------------------------------------------------------------------------------
 
 
    static private csmqmsgque.MqCreateF    fDefaultLinkCreate  = Mq.MqLinkDefault;
 
 
  // ----------------------------------------------------------------------------------------------
 
 
 
    public object ReadNEXT() {
      return ReadBUF().ToObject();
    }
 
    public List<object> ReadLIST() {
      return ReadALL().ToList();
    }
 
 
 
    public void ConfigSetIoTcp (List<object> items) {
      IntPtr cstr0 = Marshal.StringToHGlobalAnsi((string)items[0]);
      IntPtr cstr1 = Marshal.StringToHGlobalAnsi((string)items[1]);
      IntPtr cstr2 = Marshal.StringToHGlobalAnsi((string)items[2]);
      IntPtr cstr3 = Marshal.StringToHGlobalAnsi((string)items[3]);
      MkErrorE errVal = Mq.MqConfigSetIoTcp (mkrt, hdl, cstr0, cstr1, cstr2, cstr3);
      Marshal.FreeHGlobal(cstr0);
      Marshal.FreeHGlobal(cstr1);
      Marshal.FreeHGlobal(cstr2);
      Marshal.FreeHGlobal(cstr3);
      ErrorCheck(errVal);
    }
 
    public void ConfigSetIoTcp (params object[] items) {
      IntPtr cstr0 = Marshal.StringToHGlobalAnsi((string)items[0]);
      IntPtr cstr1 = Marshal.StringToHGlobalAnsi((string)items[1]);
      IntPtr cstr2 = Marshal.StringToHGlobalAnsi((string)items[2]);
      IntPtr cstr3 = Marshal.StringToHGlobalAnsi((string)items[3]);
      MkErrorE errVal = Mq.MqConfigSetIoTcp (mkrt, hdl, cstr0, cstr1, cstr2, cstr3);
      Marshal.FreeHGlobal(cstr0);
      Marshal.FreeHGlobal(cstr1);
      Marshal.FreeHGlobal(cstr2);
      Marshal.FreeHGlobal(cstr3);
      ErrorCheck(errVal);
    }
 
    public void ConfigSetIoTcp (params string[] items) {
      IntPtr cstr0 = Marshal.StringToHGlobalAnsi(items[0]);
      IntPtr cstr1 = Marshal.StringToHGlobalAnsi(items[1]);
      IntPtr cstr2 = Marshal.StringToHGlobalAnsi(items[2]);
      IntPtr cstr3 = Marshal.StringToHGlobalAnsi(items[3]);
      MkErrorE errVal = Mq.MqConfigSetIoTcp (mkrt, hdl, cstr0, cstr1, cstr2, cstr3);
      Marshal.FreeHGlobal(cstr0);
      Marshal.FreeHGlobal(cstr1);
      Marshal.FreeHGlobal(cstr2);
      Marshal.FreeHGlobal(cstr3);
      ErrorCheck(errVal);
    }
 
 
  } // END - class "MqContextC"
 
  // BEGIN-MqContextC - created by 'cs_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-Class-Export,sc_
 
    new public static MqContextC HandleResolve (Int32 netHdl)  {
      IntPtr __retVal__L = Mq.MqContextHandleResolve(IntPtr.Zero, netHdl);
      return MqContextC.MqContextC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqContextC,MqContextC-Class-Export,om_
 
    // skip class-overload: HandleGet = MqContextHandleGet → MkObjectHandleGet
 
    // MqContextC_Class_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-Class-Introspection,oc_
 
    new public MqContextC Next ()  {
      IntPtr __retVal__L = Mq.MqContextNext(hdl);
      return MqContextC.MqContextC_ObjNew(__retVal__L);
    }
 
    new public MqContextC Prev ()  {
      IntPtr __retVal__L = Mq.MqContextPrev(hdl);
      return MqContextC.MqContextC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqContextC,MqContextC-Class-Introspection,sc_
 
    new public static MqContextC Instances ()  {
      IntPtr __retVal__L = Mq.MqContextInstances(IntPtr.Zero);
      return MqContextC.MqContextC_ObjNew(__retVal__L);
    }
 
    // MqContextC_Class_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-Class-Misc,sc_
 
    new public static MqContextC GetNull ()  {
      IntPtr __retVal__L = Mq.MqContextGetNull();
      return MqContextC.MqContextC_ObjNew(__retVal__L);
    }
 
    // MqContextC_Class_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ClassApi-Class,oc_
 
    public MqFactoryC ClassFactoryGet ()  {
      IntPtr __retVal__L = Mq.MqClassFactoryGet(hdl);
      return MqFactoryC.MqFactoryC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqContextC,MqContextC-ClassApi-Class,om_
 
    public void ClassFactorySet (MqFactoryC item)  {
      IntPtr item_hdl = MqFactoryC.getOBJ("MqFactoryC",item);
      MkErrorE errVal = Mq.MqClassFactorySet(mkrt, hdl, item_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public string ClassIdentGet ()  {
      IntPtr __retVal__L = Mq.MqClassIdentGet(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public void ClassIdentSet (string ident)  {
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      MkErrorE errVal = Mq.MqClassIdentSet(mkrt, hdl, ident_cstr);
      Marshal.FreeHGlobal(ident_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public string ClassOriginalIdentGet ()  {
      IntPtr __retVal__L = Mq.MqClassOriginalIdentGet(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // MqContextC_ClassApi_Class_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ConfigApi-Get,oco
 
    public MkBufferListC ConfigGetIoTcpL ()  {
      IntPtr vals_out;
      MkErrorE errVal = Mq.MqConfigGetIoTcpL(mkrt, hdl, out vals_out);
      MkErrorC.Check(hdl, errVal);
      return MkBufferListC.MkBufferListC_ObjNew(vals_out);
    }
 
    // doc-key: MqContextC,MqContextC-ConfigApi-Get,om_
 
    public int ConfigGetBuffersize ()  {
      Int32 __retVal__L = Mq.MqConfigGetBuffersize(hdl);
      return __retVal__L;
    }
 
    public MqIdentE ConfigGetIdentFrom ()  {
      MqIdentE __retVal__L = Mq.MqConfigGetIdentFrom(hdl);
      return __retVal__L;
    }
 
    public int ConfigGetIoPipe ()  {
      Int32 __retVal__L = Mq.MqConfigGetIoPipe(hdl);
      return __retVal__L;
    }
 
    public string ConfigGetIoUds ()  {
      IntPtr __retVal__L = Mq.MqConfigGetIoUds(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public bool ConfigGetIsParent ()  {
      bool __retVal__L = Mq.MqConfigGetIsParent(hdl);
      return __retVal__L;
    }
 
    public bool ConfigGetIsServer ()  {
      bool __retVal__L = Mq.MqConfigGetIsServer(hdl);
      return __retVal__L;
    }
 
    public bool ConfigGetIsString ()  {
      bool __retVal__L = Mq.MqConfigGetIsString(hdl);
      return __retVal__L;
    }
 
    public string ConfigGetName ()  {
      IntPtr __retVal__L = Mq.MqConfigGetName(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public int ConfigGetPkgsize ()  {
      Int32 __retVal__L = Mq.MqConfigGetPkgsize(hdl);
      return __retVal__L;
    }
 
    public string ConfigGetPostfix ()  {
      IntPtr __retVal__L = Mq.MqConfigGetPostfix(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public string ConfigGetPrefix ()  {
      IntPtr __retVal__L = Mq.MqConfigGetPrefix(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public MqStartE ConfigGetStartAs ()  {
      MqStartE __retVal__L = Mq.MqConfigGetStartAs(hdl);
      return __retVal__L;
    }
 
    public MqStatusIsEF ConfigGetStatusIs ()  {
      MqStatusIsEF __retVal__L = Mq.MqConfigGetStatusIs(hdl);
      return __retVal__L;
    }
 
    public string ConfigGetStorage ()  {
      IntPtr __retVal__L = Mq.MqConfigGetStorage(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public long ConfigGetTimeout ()  {
      long __retVal__L = Mq.MqConfigGetTimeout(hdl);
      return __retVal__L;
    }
 
    public void ConfigSetConfigFile (string filename)  {
      IntPtr filename_cstr = Marshal.StringToHGlobalAnsi(filename);
      MkErrorE errVal = Mq.MqConfigSetConfigFile(mkrt, hdl, filename_cstr);
      Marshal.FreeHGlobal(filename_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    // doc-key: MqContextC,MqContextC-ConfigApi-Get,omo
 
    public List<object> ConfigGetIoTcp ()  {
      IntPtr host_out;
      IntPtr port_out;
      IntPtr myhost_out;
      IntPtr myport_out;
      MkErrorE errVal = Mq.MqConfigGetIoTcp(hdl, out host_out, out port_out, out myhost_out, out myport_out);
      MkErrorC.Check(hdl, errVal);
      List<object> __retVal__L = new List<object>();
      __retVal__L.Add(host_out);
      __retVal__L.Add(port_out);
      __retVal__L.Add(myhost_out);
      __retVal__L.Add(myport_out);
      return __retVal__L;
    }
 
    // MqContextC_ConfigApi_Get_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ConfigApi-Misc,om_
 
    public void ConfigReset ()  {
      Mq.MqConfigReset(mkrt, hdl);
    }
 
    // MqContextC_ConfigApi_Misc_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ConfigApi-Set,om_
 
    public bool ConfigCheckStartAs (MqStartE data)  {
      bool __retVal__L = Mq.MqConfigCheckStartAs(hdl, data);
      return __retVal__L;
    }
 
    public void ConfigSetAllDebug (int data)  {
      MkErrorE errVal = Mq.MqConfigSetAllDebug(mkrt, hdl, data);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ConfigSetBuffersize (int data)  {
      Mq.MqConfigSetBuffersize(hdl, data);
    }
 
    public void ConfigSetDaemon (string pidfile)  {
      IntPtr pidfile_cstr = Marshal.StringToHGlobalAnsi(pidfile);
      MkErrorE errVal = Mq.MqConfigSetDaemon(mkrt, hdl, pidfile_cstr);
      Marshal.FreeHGlobal(pidfile_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ConfigSetIdentFrom (MqIdentE data)  {
      Mq.MqConfigSetIdentFrom(hdl, data);
    }
 
    public void ConfigSetIgnoreExit (bool data)  {
      Mq.MqConfigSetIgnoreExit(hdl, data);
    }
 
    public void ConfigSetIoPipe (int fh)  {
      MkErrorE errVal = Mq.MqConfigSetIoPipe(mkrt, hdl, fh);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ConfigSetIoTcp (string host = null, string port = null, string myhost = null, string myport = null)  {
      IntPtr host_cstr = Marshal.StringToHGlobalAnsi(host);
      IntPtr port_cstr = Marshal.StringToHGlobalAnsi(port);
      IntPtr myhost_cstr = Marshal.StringToHGlobalAnsi(myhost);
      IntPtr myport_cstr = Marshal.StringToHGlobalAnsi(myport);
      MkErrorE errVal = Mq.MqConfigSetIoTcp(mkrt, hdl, host_cstr, port_cstr, myhost_cstr, myport_cstr);
      Marshal.FreeHGlobal(host_cstr);
      Marshal.FreeHGlobal(port_cstr);
      Marshal.FreeHGlobal(myhost_cstr);
      Marshal.FreeHGlobal(myport_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ConfigSetIoTcp (MkBufferListC vals)  {
      IntPtr vals_hdl = MkBufferListC.getOBJ("MkBufferListC",vals);
      MkErrorE errVal = Mq.MqConfigSetIoTcpL(mkrt, hdl, vals_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ConfigSetIoUds (string file)  {
      IntPtr file_cstr = Marshal.StringToHGlobalAnsi(file);
      MkErrorE errVal = Mq.MqConfigSetIoUds(mkrt, hdl, file_cstr);
      Marshal.FreeHGlobal(file_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ConfigSetIsServer (bool data)  {
      Mq.MqConfigSetIsServer(hdl, data);
    }
 
    public void ConfigSetIsString (bool data)  {
      Mq.MqConfigSetIsString(hdl, data);
    }
 
    public void ConfigSetName (string data)  {
      IntPtr data_cstr = Marshal.StringToHGlobalAnsi(data);
      Mq.MqConfigSetName(mkrt, hdl, data_cstr);
      Marshal.FreeHGlobal(data_cstr);
    }
 
    public void ConfigSetPkgsize (int data)  {
      Mq.MqConfigSetPkgsize(hdl, data);
    }
 
    public void ConfigSetPostfix (string data)  {
      IntPtr data_cstr = Marshal.StringToHGlobalAnsi(data);
      Mq.MqConfigSetPostfix(mkrt, hdl, data_cstr);
      Marshal.FreeHGlobal(data_cstr);
    }
 
    public void ConfigSetPrefix (string data)  {
      IntPtr data_cstr = Marshal.StringToHGlobalAnsi(data);
      Mq.MqConfigSetPrefix(mkrt, hdl, data_cstr);
      Marshal.FreeHGlobal(data_cstr);
    }
 
    public void ConfigSetStartAs (MqStartE data)  {
      MkErrorE errVal = Mq.MqConfigSetStartAs(hdl, data);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ConfigSetStartAsString (string data)  {
      IntPtr data_cstr = Marshal.StringToHGlobalAnsi(data);
      MkErrorE errVal = Mq.MqConfigSetStartAsString(hdl, data_cstr);
      Marshal.FreeHGlobal(data_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ConfigSetStorage (string data)  {
      IntPtr data_cstr = Marshal.StringToHGlobalAnsi(data);
      Mq.MqConfigSetStorage(mkrt, hdl, data_cstr);
      Marshal.FreeHGlobal(data_cstr);
    }
 
    public void ConfigSetTimeout (long data)  {
      Mq.MqConfigSetTimeout(hdl, data);
    }
 
    // MqContextC_ConfigApi_Set_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-EnvApi-Env,om_
 
    public void EnvProtect ()  {
      Mq.MqEnvProtect(mkrt, hdl);
    }
 
    public void EnvRestore ()  {
      Mq.MqEnvRestore(hdl);
    }
 
    // MqContextC_EnvApi_Env_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ErrorApi-Error,oc_
 
    public MkErrorC ErrorFORMAT ()  {
      IntPtr __retVal__L = Mq.MqContextErrorFORMAT(hdl_null_allow);
      return MkErrorC.MkErrorC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqContextC,MqContextC-ErrorApi-Error,om_
 
    public MkErrorE ErrorCopy (MqContextC sourceCtx)  {
      IntPtr sourceCtx_hdl = MqContextC.getOBJ("MqContextC",sourceCtx);
      MkErrorE errVal = Mq.MqContextErrorCopy(mkrt, hdl, sourceCtx_hdl);
      return errVal;
    }
 
    public MkErrorE ErrorMove (MqContextC sourceCtx)  {
      IntPtr sourceCtx_hdl = MqContextC.getOBJ("MqContextC",sourceCtx);
      MkErrorE errVal = Mq.MqContextErrorMove(mkrt, hdl, sourceCtx_hdl);
      return errVal;
    }
 
    // MqContextC_ErrorApi_Error_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-LinkApi-Link,oc_
 
    public MqContextC LinkGetParent ()  {
      IntPtr __retVal__L = Mq.MqLinkGetParent(hdl);
      return MqContextC.MqContextC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqContextC,MqContextC-LinkApi-Link,om_
 
    public void LinkConnect ()  {
      MkErrorE errVal = Mq.MqLinkConnect(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void LinkCreate (MkBufferListC args = null)  {
      IntPtr args_hdl = MkBufferListC.getOBJ_null_allow(args);
      MkErrorE errVal = Mq.MqLinkCreate(mkrt, hdl, args_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void LinkCreateChild (MqContextC parent, MkBufferListC args = null)  {
      IntPtr parent_hdl = MqContextC.getOBJ("MqContextC",parent);
      IntPtr args_hdl = MkBufferListC.getOBJ_null_allow(args);
      MkErrorE errVal = Mq.MqLinkCreateChild(mkrt, hdl, parent_hdl, args_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void LinkCreateChild (MqContextC parent, params string[] args)  {
      // OVERLOAD
      LinkCreateChild (parent, new MkBufferListC(args));
    }
 
    public void LinkCreate (params string[] args)  {
      // OVERLOAD
      LinkCreate (new MkBufferListC(args));
    }
 
    public void LinkDelete ()  {
      Mq.MqLinkDelete(mkrt, hdl);
    }
 
    public int LinkGetCtxId ()  {
      Int32 __retVal__L = Mq.MqLinkGetCtxId(hdl);
      return __retVal__L;
    }
 
    public string LinkGetTargetIdent ()  {
      IntPtr __retVal__L = Mq.MqLinkGetTargetIdent(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public bool LinkIsConnected ()  {
      bool __retVal__L = Mq.MqLinkIsConnected(hdl);
      return __retVal__L;
    }
 
    public bool LinkIsParent ()  {
      bool __retVal__L = Mq.MqLinkIsParent(hdl);
      return __retVal__L;
    }
 
    public void LinkShutdown ()  {
      MkErrorE errVal = Mq.MqLinkShutdown(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_LinkApi_Link_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-LogApi-Log,om_
 
    // skip class-overload: Log = MqContextLog → MkObjectLog
 
    public void LogConfig (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);
      Mq.MqContextLogConfig(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogEnv (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);
      Mq.MqContextLogEnv(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogLink (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);
      Mq.MqContextLogLink(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogSetup (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);
      Mq.MqContextLogSetup(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, string label = null)  {
      IntPtr fmtobj_hdl = MkObjectC.getOBJ_null_allow(fmtobj);
      if (debug > (int)(MkRuntimeC.DebugGet())) {return;}
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      IntPtr label_cstr = Marshal.StringToHGlobalAnsi(label);
      Mq.MqContextLogShort(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl, label_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
      Marshal.FreeHGlobal(label_cstr);
    }
 
    new 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);
      Mq.MqContextLogType(mkrt, hdl, fmtobj_hdl, debug, callfunc_cstr, lvl);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public string LogParentOrChild ()  {
      IntPtr __retVal__L = Mq.MqLogParentOrChild(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public string LogServerOrClient ()  {
      IntPtr __retVal__L = Mq.MqLogServerOrClient(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // MqContextC_LogApi_Log_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-MiscApi-Misc,oc_
 
    public MkBufferC GetBuffer ()  {
      IntPtr __retVal__L = Mq.MqContextGetBuffer(mkrt, hdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MqContextC GetRoot ()  {
      IntPtr __retVal__L = Mq.MqGetRoot(hdl);
      return MqContextC.MqContextC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqContextC,MqContextC-MiscApi-Misc,om_
 
    // skip class-overload: ToString = MqContextToString → MkObjectToString
 
    public int Exit ([CallerMemberName]string callfunc = null, [CallerFilePath]string callfile = null, [CallerLineNumber]int callline = -1)  {
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      IntPtr callfile_cstr = Marshal.StringToHGlobalAnsi(callfile);
      Int32 __retVal__L = Mq.MqExit(mkrt, hdl_null_allow, callfunc_cstr, callfile_cstr, callline);
      Marshal.FreeHGlobal(callfunc_cstr);
      Marshal.FreeHGlobal(callfile_cstr);
      return __retVal__L;
    }
 
    public void ProcessEvent (MqWaitOnEventE wait = MqWaitOnEventE.NO, long timeout = (long)MkTimeoutE.DEFAULT)  {
      MkErrorE errVal = Mq.MqProcessEvent(mkrt, hdl, wait, timeout);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_MiscApi_Misc_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ProxyApi-Proxy,om_
 
    public void ProxyForward (MqContextC targetCtx, MqDumpC dump = null, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr targetCtx_hdl = MqContextC.getOBJ("MqContextC",targetCtx);
      IntPtr dump_hdl = MqDumpC.getOBJ_null_allow(dump);
      MkErrorE errVal = Mq.MqProxyForward(mkrt, hdl, targetCtx_hdl, dump_hdl, timeout);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ProxyItem (MqContextC targetCtx)  {
      IntPtr targetCtx_hdl = MqContextC.getOBJ("MqContextC",targetCtx);
      MkErrorE errVal = Mq.MqProxyItem(mkrt, hdl, targetCtx_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_ProxyApi_Proxy_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ReadApi-Atom,oci
 
    public MkBufferListC ReadALL (MkBufferListC val_inout = null)  {
      IntPtr val_inout_hdl = MkBufferListC.getOBJ_null_allow(val_inout);
      MkErrorE errVal = Mq.MqReadALL(mkrt, hdl, ref val_inout_hdl);
      MkErrorC.Check(hdl, errVal);
      return MkBufferListC.MkBufferListC_ObjNew(val_inout_hdl);
    }
 
    // doc-key: MqContextC,MqContextC-ReadApi-Atom,oco
 
    public MkBufferListC ReadBFL ()  {
      IntPtr val_out;
      MkErrorE errVal = Mq.MqReadBFL(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return MkBufferListC.MkBufferListC_ObjNew(val_out);
    }
 
    public MkBufferC ReadBUF ()  {
      IntPtr val_out;
      MkErrorE errVal = Mq.MqReadBUF(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return MkBufferC.MkBufferC_ObjNew(val_out);
    }
 
    // doc-key: MqContextC,MqContextC-ReadApi-Atom,omo
 
    public byte[] ReadBIN ()  {
      Mk.MkBinaryR val_out_ref;
      MkErrorE errVal = Mq.MqReadBIN(mkrt, hdl, out val_out_ref);
      if (errVal > MkErrorE.CONTINUE) ErrorCheck(errVal);
      byte[] val_out = new byte[(int)val_out_ref.size];
      Marshal.Copy(val_out_ref.data,val_out,0,(int)val_out_ref.size);
      return val_out;
    }
 
    public bool ReadBOL ()  {
      Byte val_out;
      MkErrorE errVal = Mq.MqReadBOL(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out != 0;
    }
 
    public byte[] ReadBinaryR ()  {
      Mk.MkBinaryR val_out_ref;
      MkErrorE errVal = Mq.MqReadBinaryR(mkrt, hdl, out val_out_ref);
      if (errVal > MkErrorE.CONTINUE) ErrorCheck(errVal);
      byte[] val_out = new byte[(int)val_out_ref.size];
      Marshal.Copy(val_out_ref.data,val_out,0,(int)val_out_ref.size);
      return val_out;
    }
 
    public double ReadDBL ()  {
      Double val_out;
      MkErrorE errVal = Mq.MqReadDBL(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public float ReadFLT ()  {
      Single val_out;
      MkErrorE errVal = Mq.MqReadFLT(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public Int32 ReadHDL ()  {
      Int32 val_out;
      MkErrorE errVal = Mq.MqReadHDL(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public short ReadI16 ()  {
      Int16 val_out;
      MkErrorE errVal = Mq.MqReadI16(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public int ReadI32 ()  {
      Int32 val_out;
      MkErrorE errVal = Mq.MqReadI32(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public long ReadI64 ()  {
      Int64 val_out;
      MkErrorE errVal = Mq.MqReadI64(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public byte ReadI8 ()  {
      Byte val_out;
      MkErrorE errVal = Mq.MqReadI8(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return (byte)val_out;
    }
 
 
    public long ReadLONG ()  {
      long val_out;
      MkErrorE errVal = Mq.MqReadLONG(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
 
    public string ReadSTR ()  {
      IntPtr val_out;
      MkErrorE errVal = Mq.MqReadSTR(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return Marshal.PtrToStringAnsi(val_out);
    }
 
    public string ReadStringR ()  {
      Mk.MkStringR val_out_ref;
      MkErrorE errVal = Mq.MqReadStringR(mkrt, hdl, out val_out_ref);
      MkErrorC.Check(hdl, errVal);
      return Marshal.PtrToStringAnsi(val_out_ref.ptr,val_out_ref.len);
    }
 
    // MqContextC_ReadApi_Atom_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ReadApi-Block,om_
 
    public void ReadL_END ()  {
      MkErrorE errVal = Mq.MqReadL_END(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ReadL_START (MkBufferC buf = null)  {
      IntPtr buf_hdl = MkBufferC.getOBJ_null_allow(buf);
      MkErrorE errVal = Mq.MqReadL_START(mkrt, hdl, buf_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ReadT_END ()  {
      MkErrorE errVal = Mq.MqReadT_END(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ReadT_START ()  {
      MkErrorE errVal = Mq.MqReadT_START(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_ReadApi_Block_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ReadApi-Misc,om_
 
    public void ReadDbg ()  {
      Mq.MqReadDbg(mkrt, hdl);
    }
 
    public MkTypeE ReadGetNextType ()  {
      MkTypeE __retVal__L = Mq.MqReadGetNextType(hdl);
      return __retVal__L;
    }
 
    public int ReadGetNumItems ()  {
      Int32 __retVal__L = Mq.MqReadGetNumItems(hdl);
      return __retVal__L;
    }
 
    public bool ReadItemExists ()  {
      bool __retVal__L = Mq.MqReadItemExists(hdl);
      return __retVal__L;
    }
 
    public void ReadUndo ()  {
      MkErrorE errVal = Mq.MqReadUndo(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_ReadApi_Misc_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-RouteApi-Route,oco
 
    public MkBufferListC RouteGetTree ()  {
      IntPtr treeP_out;
      MkErrorE errVal = Mq.MqRouteGetTree(mkrt, hdl, out treeP_out);
      MkErrorC.Check(hdl, errVal);
      return MkBufferListC.MkBufferListC_ObjNew(treeP_out);
    }
 
    // doc-key: MqContextC,MqContextC-RouteApi-Route,om_
 
    public void RouteCreate (string route, string service, bool overwrite = false)  {
      IntPtr route_cstr = Marshal.StringToHGlobalAnsi(route);
      IntPtr service_cstr = Marshal.StringToHGlobalAnsi(service);
      MkErrorE errVal = Mq.MqRouteCreate(mkrt, hdl, route_cstr, service_cstr, overwrite);
      Marshal.FreeHGlobal(route_cstr);
      Marshal.FreeHGlobal(service_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void RouteDelete (string route, string service, bool overwrite = false)  {
      IntPtr route_cstr = Marshal.StringToHGlobalAnsi(route);
      IntPtr service_cstr = Marshal.StringToHGlobalAnsi(service);
      MkErrorE errVal = Mq.MqRouteDelete(mkrt, hdl, route_cstr, service_cstr, overwrite);
      Marshal.FreeHGlobal(route_cstr);
      Marshal.FreeHGlobal(service_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public MqContextC[] RouteResolve (string ident, int retnum = -1)  {
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      MkIntPtr_A __retVal__L = Mq.MqRouteResolve(mkrt, hdl, ident_cstr, retnum);
      Marshal.FreeHGlobal(ident_cstr);
      int elementSize = Marshal.SizeOf(typeof(IntPtr));
      MqContextC[] ret = new MqContextC[__retVal__L.size];
      for(int i=0; i<__retVal__L.size; i++) {
        ret[i] = MqContextC.MqContextC_ObjNewOrNull(Marshal.ReadIntPtr(__retVal__L.data,i*elementSize));
      }
      return ret;
    }
 
    public void RouteTraverse (string service, MkBufferListC args = null)  {
      IntPtr args_hdl = MkBufferListC.getOBJ_null_allow(args);
      IntPtr service_cstr = Marshal.StringToHGlobalAnsi(service);
      MkErrorE errVal = Mq.MqRouteTraverse(mkrt, hdl, service_cstr, args_hdl);
      Marshal.FreeHGlobal(service_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void RouteTraverse (string service, params string[] args)  {
      // OVERLOAD
      RouteTraverse (service, new MkBufferListC(args));
    }
 
    // doc-key: MqContextC,MqContextC-RouteApi-Route,omo
 
    public string RouteGetPath ()  {
      IntPtr path_out;
      MkErrorE errVal = Mq.MqRouteGetPath(mkrt, hdl, out path_out);
      MkErrorC.Check(hdl, errVal);
      return Marshal.PtrToStringAnsi(path_out);
    }
 
    // MqContextC_RouteApi_Route_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-SendApi-Atom,om_
 
    public void SendBFL (MkBufferListC val)  {
      IntPtr val_hdl = MkBufferListC.getOBJ("MkBufferListC",val);
      MkErrorE errVal = Mq.MqSendBFL(mkrt, hdl, val_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendBIN (byte[] val)  {
      var val_size = Marshal.SizeOf(val[0]) * val.Length;
      var val_data = Marshal.AllocHGlobal(val_size);
      Marshal.Copy(val,0,val_data,val_size);
      Mk.MkBinaryR val_ref = Mk.MkBinaryCreate(val_size,val_data);
      MkErrorE errVal = Mq.MqSendBIN(mkrt, hdl, val_ref);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendBOL (bool val)  {
      MkErrorE errVal = Mq.MqSendBOL(mkrt, hdl, (Byte)(val?1:0));
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendBUF (MkBufferC val)  {
      IntPtr val_hdl = MkBufferC.getOBJ("MkBufferC",val);
      MkErrorE errVal = Mq.MqSendBUF(mkrt, hdl, val_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendBUS_FLAT (MkBufferStreamC val)  {
      IntPtr val_hdl = MkBufferStreamC.getOBJ("MkBufferStreamC",val);
      MkErrorE errVal = Mq.MqSendBUS_FLAT(mkrt, hdl, val_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendBinaryR (byte[] val)  {
      var val_size = Marshal.SizeOf(val[0]) * val.Length;
      var val_data = Marshal.AllocHGlobal(val_size);
      Marshal.Copy(val,0,val_data,val_size);
      Mk.MkBinaryR val_ref = Mk.MkBinaryCreate(val_size,val_data);
      MkErrorE errVal = Mq.MqSendBinaryR(mkrt, hdl, val_ref);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendDBL (double val)  {
      MkErrorE errVal = Mq.MqSendDBL(mkrt, hdl, val);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendFLT (float val)  {
      MkErrorE errVal = Mq.MqSendFLT(mkrt, hdl, val);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendHDL (Int32 val)  {
      MkErrorE errVal = Mq.MqSendHDL(mkrt, hdl, val);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendI16 (short val)  {
      MkErrorE errVal = Mq.MqSendI16(mkrt, hdl, val);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendI32 (int val)  {
      MkErrorE errVal = Mq.MqSendI32(mkrt, hdl, val);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendI64 (long val)  {
      MkErrorE errVal = Mq.MqSendI64(mkrt, hdl, val);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendI8 (byte val)  {
      MkErrorE errVal = Mq.MqSendI8(mkrt, hdl, (Byte)(val));
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendLONG (long val)  {
      MkErrorE errVal = Mq.MqSendLONG(mkrt, hdl, val);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendLTR (int transLId)  {
      MkErrorE errVal = Mq.MqSendLTR(mkrt, hdl, transLId);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendL_FLAT (MkBufferListC val)  {
      IntPtr val_hdl = MkBufferListC.getOBJ("MkBufferListC",val);
      MkErrorE errVal = Mq.MqSendL_FLAT(mkrt, hdl, val_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendSTR (string val)  {
      IntPtr val_cstr = Marshal.StringToHGlobalAnsi(val);
      MkErrorE errVal = Mq.MqSendSTR(mkrt, hdl, val_cstr);
      Marshal.FreeHGlobal(val_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendStringR (string val)  {
      IntPtr val_ref_cstr = Marshal.StringToHGlobalAnsi(val);
      Mk.MkStringR val_ref = Mk.MkStringCreate_1(val_ref_cstr);
      MkErrorE errVal = Mq.MqSendStringR(mkrt, hdl, val_ref);
      Marshal.FreeHGlobal(val_ref_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_SendApi_Atom_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-SendApi-Basics,om_
 
    public void SendEND (string token, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      MkErrorE errVal = Mq.MqSendEND(mkrt, hdl, token_cstr, timeout);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendEND_AND_CALLBACK (string token, MqServiceCCB callback, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqSendEND_AND_CALLBACK(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, timeout);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendEND_AND_CALLBACK (string token, MqServiceICB callback, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqSendEND_AND_CALLBACK(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, timeout);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendEND_AND_CALLBACK (string token, MqServiceIF callback, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqSendEND_AND_CALLBACK(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, timeout);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendEND_AND_SUB (string token, MqServiceCCB callback, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqSendEND_AND_SUB(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, timeout);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendEND_AND_SUB (string token, MqServiceICB callback, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqSendEND_AND_SUB(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, timeout);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendEND_AND_SUB (string token, MqServiceIF callback, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqSendEND_AND_SUB(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, timeout);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendEND_AND_TRANSACTION (string token, string callback, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_cstr = Marshal.StringToHGlobalAnsi(callback);
      MkErrorE errVal = Mq.MqSendEND_AND_TRANSACTION(mkrt, hdl, token_cstr, callback_cstr, timeout);
      Marshal.FreeHGlobal(token_cstr);
      Marshal.FreeHGlobal(callback_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendEND_AND_WAIT (string token, long timeout = (long)MkTimeoutE.DEFAULT)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      MkErrorE errVal = Mq.MqSendEND_AND_WAIT(mkrt, hdl, token_cstr, timeout);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendSTART ()  {
      MkErrorE errVal = Mq.MqSendSTART(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendSYNC ()  {
      MkErrorE errVal = Mq.MqSendSYNC(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_SendApi_Basics_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-SendApi-Block,om_
 
    public void SendL_END ()  {
      MkErrorE errVal = Mq.MqSendL_END(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendL_START ()  {
      MkErrorE errVal = Mq.MqSendL_START(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendT_END ()  {
      MkErrorE errVal = Mq.MqSendT_END(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendT_START ()  {
      MkErrorE errVal = Mq.MqSendT_START(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_SendApi_Block_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-SendApi-Return,om_
 
    public void SendERROR ()  {
      MkErrorE errVal = Mq.MqSendERROR(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendRETURN ()  {
      MkErrorE errVal = Mq.MqSendRETURN(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SendRETURN_SUB ()  {
      MkErrorE errVal = Mq.MqSendRETURN_SUB(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    // MqContextC_SendApi_Return_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-ServiceApi-Service,om_
 
    public void ServiceCreate (string token, MqServiceCCB callback)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqServiceCreate(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, null);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ServiceCreate (string token, MqServiceICB callback)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqServiceCreate(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, null);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ServiceCreate (string token, MqServiceIF callback)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr callback_ptr = callback == null ? IntPtr.Zero : (IntPtr)GCHandle.Alloc(new MqCall(mkrt,callback));
      MkErrorE errVal = Mq.MqServiceCreate(mkrt, hdl, token_cstr, ServiceCall, callback_ptr, ServiceFree, null);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ServiceDelete (string token)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      MkErrorE errVal = Mq.MqServiceDelete(mkrt, hdl, token_cstr);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public bool ServiceIsTransaction ()  {
      bool __retVal__L = Mq.MqServiceIsTransaction(hdl);
      return __retVal__L;
    }
 
    public void ServiceProxy (string token, int id = (int)MqSlaveE.OTHER)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      MkErrorE errVal = Mq.MqServiceProxy(mkrt, hdl, token_cstr, id);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ServiceProxyCtx (string token, MqContextC target)  {
      IntPtr target_hdl = MqContextC.getOBJ("MqContextC",target);
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      MkErrorE errVal = Mq.MqServiceProxyCtx(mkrt, hdl, token_cstr, target_hdl);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public bool ServiceProxyCtxExists (string token, MqContextC target)  {
      IntPtr target_hdl = MqContextC.getOBJ("MqContextC",target);
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      bool __retVal__L = Mq.MqServiceProxyCtxExists(hdl, token_cstr, target_hdl);
      Marshal.FreeHGlobal(token_cstr);
      return __retVal__L;
    }
 
    public void ServiceProxyRoundRobin (string token, string ident)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      IntPtr ident_cstr = Marshal.StringToHGlobalAnsi(ident);
      MkErrorE errVal = Mq.MqServiceProxyRoundRobin(mkrt, hdl, token_cstr, ident_cstr);
      Marshal.FreeHGlobal(token_cstr);
      Marshal.FreeHGlobal(ident_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void ServiceStorage (string token)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      MkErrorE errVal = Mq.MqServiceStorage(mkrt, hdl, token_cstr);
      Marshal.FreeHGlobal(token_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public bool ServiceTokenCheck (string token)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      bool __retVal__L = Mq.MqServiceTokenCheck(hdl, token_cstr);
      Marshal.FreeHGlobal(token_cstr);
      return __retVal__L;
    }
 
    public bool ServiceTokenExists (string token)  {
      IntPtr token_cstr = Marshal.StringToHGlobalAnsi(token);
      bool __retVal__L = Mq.MqServiceTokenExists(hdl, token_cstr);
      Marshal.FreeHGlobal(token_cstr);
      return __retVal__L;
    }
 
    public string ServiceTokenGet ()  {
      IntPtr __retVal__L = Mq.MqServiceTokenGet(hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    // MqContextC_ServiceApi_Service_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-SlaveApi-Slave,oc_
 
    public MqContextC SlaveGetMaster ()  {
      IntPtr __retVal__L = Mq.MqSlaveGetMaster(hdl);
      return MqContextC.MqContextC_ObjNew(__retVal__L);
    }
 
    // doc-key: MqContextC,MqContextC-SlaveApi-Slave,oco
 
    public MqContextC SlaveGet (int id)  {
      IntPtr ctx_out;
      MkErrorE errVal = Mq.MqSlaveGet(mkrt, hdl, id, out ctx_out);
      MkErrorC.Check(hdl, errVal);
      return MqContextC.MqContextC_ObjNew(ctx_out);
    }
 
    public MqContextC SlaveGetFilter ()  {
      IntPtr ctx_out;
      MkErrorE errVal = Mq.MqSlaveGetFilter(mkrt, hdl, out ctx_out);
      MkErrorC.Check(hdl, errVal);
      return MqContextC.MqContextC_ObjNew(ctx_out);
    }
 
    public MqContextC SlaveGetProxy (int id)  {
      IntPtr ctx_out;
      MkErrorE errVal = Mq.MqSlaveGetProxy(mkrt, hdl, id, out ctx_out);
      MkErrorC.Check(hdl, errVal);
      return MqContextC.MqContextC_ObjNew(ctx_out);
    }
 
    // doc-key: MqContextC,MqContextC-SlaveApi-Slave,om_
 
    public bool SlaveCheck (int id)  {
      bool __retVal__L = Mq.MqSlaveCheck(hdl, id);
      return __retVal__L;
    }
 
    public void SlaveCreate (int id, MqContextC slave)  {
      IntPtr slave_hdl = MqContextC.getOBJ("MqContextC",slave);
      MkErrorE errVal = Mq.MqSlaveCreate(mkrt, hdl, id, slave_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SlaveDelete (int id)  {
      MkErrorE errVal = Mq.MqSlaveDelete(mkrt, hdl, id);
      MkErrorC.Check(hdl, errVal);
    }
 
    public bool SlaveIs ()  {
      bool __retVal__L = Mq.MqSlaveIs(hdl);
      return __retVal__L;
    }
 
    public void SlaveWorker (int id, string fct = "WORKER", MkBufferListC args = null)  {
      IntPtr args_hdl = MkBufferListC.getOBJ_null_allow(args);
      IntPtr fct_cstr = Marshal.StringToHGlobalAnsi(fct);
      MkErrorE errVal = Mq.MqSlaveWorker(mkrt, hdl, id, fct_cstr, args_hdl);
      Marshal.FreeHGlobal(fct_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void SlaveWorker (int id, string fct = "WORKER", params string[] args)  {
      // OVERLOAD
      SlaveWorker (id, fct, new MkBufferListC(args));
    }
 
    // MqContextC_SlaveApi_Slave_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-StorageApi-Storage,oci
 
    public int StorageDelete (int transLIdP_inout = 0)  {
      MkErrorE errVal = Mq.MqStorageDelete(mkrt, hdl, ref transLIdP_inout);
      MkErrorC.Check(hdl, errVal);
      return transLIdP_inout;
    }
 
    public int StorageImport (int transLIdP_inout = 0)  {
      MkErrorE errVal = Mq.MqStorageImport(mkrt, hdl, ref transLIdP_inout);
      MkErrorC.Check(hdl, errVal);
      return transLIdP_inout;
    }
 
    // doc-key: MqContextC,MqContextC-StorageApi-Storage,om_
 
    public void StorageClose ()  {
      MkErrorE errVal = Mq.MqStorageClose(mkrt, hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void StorageDecrRef (int transLId)  {
      MkErrorE errVal = Mq.MqStorageDecrRef(mkrt, hdl, transLId);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void StorageIncrRef (int transLId)  {
      MkErrorE errVal = Mq.MqStorageIncrRef(mkrt, hdl, transLId);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void StorageLog ([CallerMemberName]string callfunc = null)  {
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      MkErrorE errVal = Mq.MqStorageLog(mkrt, hdl, callfunc_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void StorageOpen (string storageFile)  {
      IntPtr storageFile_cstr = Marshal.StringToHGlobalAnsi(storageFile);
      MkErrorE errVal = Mq.MqStorageOpen(mkrt, hdl, storageFile_cstr);
      Marshal.FreeHGlobal(storageFile_cstr);
      MkErrorC.Check(hdl, errVal);
    }
 
    // doc-key: MqContextC,MqContextC-StorageApi-Storage,omo
 
    public int StorageCount ()  {
      Int32 cnt_out;
      MkErrorE errVal = Mq.MqStorageCount(mkrt, hdl, out cnt_out);
      MkErrorC.Check(hdl, errVal);
      return cnt_out;
    }
 
    public int StorageErrCnt (int transLId)  {
      Int32 cnt_out;
      MkErrorE errVal = Mq.MqStorageErrCnt(mkrt, hdl, transLId, out cnt_out);
      MkErrorC.Check(hdl, errVal);
      return cnt_out;
    }
 
    public int StorageExport ()  {
      Int32 ltid_out;
      MkErrorE errVal = Mq.MqStorageExport(mkrt, hdl, out ltid_out);
      MkErrorC.Check(hdl, errVal);
      return ltid_out;
    }
 
    public List<object> StorageResolve ()  {
      IntPtr otherCtxP_out;
      Int32 otherLIdP_out;
      MkErrorE errVal = Mq.MqStorageResolve(mkrt, hdl, out otherCtxP_out, out otherLIdP_out);
      MkErrorC.Check(hdl, errVal);
      List<object> __retVal__L = new List<object>();
      __retVal__L.Add(MqContextC.MqContextC_ObjNew(otherCtxP_out));
      __retVal__L.Add(otherLIdP_out);
      return __retVal__L;
    }
 
    // MqContextC_StorageApi_Storage_CS_API
  }
 
  public partial class MqContextC {
 
 
    // doc-key: MqContextC,MqContextC-TOR,sCc
 
    protected static IntPtr CTOR (MqContextC tmpl = null)  {
      IntPtr tmpl_hdl = MqContextC.getOBJ_null_allow(tmpl);
      IntPtr __retVal__L = Mq.MqContextCreate(IntPtr.Zero, MqContextCTT, tmpl_hdl);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MqContextC.CTOR");
      }
      return (IntPtr)__retVal__L;
    }
 
    public MqContextC(MqContextC tmpl = null) : this(CTOR(tmpl)) {}
 
    public static MqContextC Create (MqContextC tmpl = null)  {
      IntPtr tmpl_hdl = MqContextC.getOBJ_null_allow(tmpl);
      IntPtr __retVal__L = Mq.MqContextCreate(IntPtr.Zero, MqContextCTT, tmpl_hdl);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MqContextC.Create");
      }
      return MqContextC.MqContextC_ObjCreate(__retVal__L);
    }
 
    // MqContextC_TOR_CS_API
  }
 
  // END-MqContextC - created by 'cs_MqC.tcl -i NHI1_HOME/theLink/c/gen/c_mqmsgque.meta' - DO NOT change
 
} // END - namespace "csmqmsgque"