MkBufferC.cs

Go to the documentation of this file.

 
/* 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 MkBufferC
#else
  public partial class MkBufferC : MkObjectC
#endif
  {
    private readonly static ConstructorInfo ctor = getCtor(typeof(MkBufferC));
    private readonly static ThreadLocal<MkBufferC> MK_NULL = new ThreadLocal<MkBufferC>(() => {
      return (MkBufferC) atomSelfNull(ctor);
    });
 
    public static MkBufferC MkBufferC_ObjNew (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MkBufferC) atomObjNew(typeof(MkBufferC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static MkBufferC MkBufferC_ObjCreate (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MkBufferC) atomObjCreate(typeof(MkBufferC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static IntPtr MkBufferC_SelfCreate (IntPtr mkrt, IntPtr obj, IntPtr env) {
      return atomSelfCreate(ctor, obj, env);
    }
 
    private static void MkBufferC_SelfUnlink (IntPtr mkrt, IntPtr self, IntPtr env) {
      atomSelfUnlink(self, env);
    }
 
    internal static void SetupThreadBUF (IntPtr mkrt) {
      Mk.MkCsTypeUpdate(mkrt, MkCsTypeLookupE.BUF, MkBufferC_SelfCreate, MkBufferC_SelfUnlink);
    }
 
    #if !META_STATIC_OVERWRITE
 
    static MkBufferC() {
      // M0("MkBufferC");
      MkKernel.Setup();
      SetupThreadBUF(IntPtr.Zero);
    }
 
    #endif
/* LABEL-END */
 
    internal MkBufferC (IntPtr bufP) : base(bufP) {
      // a "reference" is part of the context and is freed on context delete.
      if (bufP != IntPtr.Zero && Mk.MkBufferIsLocal(mkrt,bufP)) GC.SuppressFinalize(this);
    }
 
  } // END - class "MkBufferC"
 
  // BEGIN-MkBufferC - created by 'cs_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-Access,oc_
 
    public MkBufferC AppendC (string val)  {
      IntPtr val_cstr = Marshal.StringToHGlobalAnsi(val);
      IntPtr __retVal__L = Mk.MkBufferAppendC(mkrt, hdl, val_cstr);
      Marshal.FreeHGlobal(val_cstr);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC AppendStringR (string val)  {
      IntPtr val_ref_cstr = Marshal.StringToHGlobalAnsi(val);
      Mk.MkStringR val_ref = Mk.MkStringCreate_1(val_ref_cstr);
      IntPtr __retVal__L = Mk.MkBufferAppendStringR(mkrt, hdl, val_ref);
      Marshal.FreeHGlobal(val_ref_cstr);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkBufferC,MkBufferC-Access,om_
 
    public int Pop (string val)  {
      IntPtr val_cstr = Marshal.StringToHGlobalAnsi(val);
      Int32 __retVal__L = Mk.MkBufferPop(mkrt, hdl, val_cstr);
      Marshal.FreeHGlobal(val_cstr);
      return __retVal__L;
    }
 
    public int Push (string val)  {
      IntPtr val_cstr = Marshal.StringToHGlobalAnsi(val);
      Int32 __retVal__L = Mk.MkBufferPush(mkrt, hdl, val_cstr);
      Marshal.FreeHGlobal(val_cstr);
      return __retVal__L;
    }
 
    // doc-key: MkBufferC,MkBufferC-Access,omo
 
 
    // MkBufferC_Access_CS_API
  }
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-Class-Export,sc_
 
    new public static MkBufferC HandleResolve (Int32 netHdl)  {
      IntPtr __retVal__L = Mk.MkBufferHandleResolve(IntPtr.Zero, netHdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkBufferC,MkBufferC-Class-Export,om_
 
    // skip class-overload: HandleGet = MkBufferHandleGet → MkObjectHandleGet
 
    // MkBufferC_Class_CS_API
  }
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-Class-Introspection,oc_
 
    new public MkBufferC Next ()  {
      IntPtr __retVal__L = Mk.MkBufferNext(hdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    new public MkBufferC Prev ()  {
      IntPtr __retVal__L = Mk.MkBufferPrev(hdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkBufferC,MkBufferC-Class-Introspection,sc_
 
    new public static MkBufferC Instances ()  {
      IntPtr __retVal__L = Mk.MkBufferInstances(IntPtr.Zero);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // MkBufferC_Class_CS_API
  }
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-Class-Misc,sc_
 
    new public static MkBufferC GetNull ()  {
      IntPtr __retVal__L = Mk.MkBufferGetNull();
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // MkBufferC_Class_CS_API
  }
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-Get,oci
 
    public MkBufferListC GetBFL (MkBufferListC val_inout = null)  {
      IntPtr val_inout_hdl = MkBufferListC.getOBJ_null_allow(val_inout);
      MkErrorE errVal = Mk.MkBufferGetBFL(mkrt, hdl, ref val_inout_hdl);
      MkErrorC.Check(hdl, errVal);
      return MkBufferListC.MkBufferListC_ObjNew(val_inout_hdl);
    }
 
    // doc-key: MkBufferC,MkBufferC-Get,oco
 
    public MkBufferC GetBUF ()  {
      IntPtr val_out;
      MkErrorE errVal = Mk.MkBufferGetBUF(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return MkBufferC.MkBufferC_ObjNew(val_out);
    }
 
    // doc-key: MkBufferC,MkBufferC-Get,omo
 
    public byte[] GetBIN ()  {
      Mk.MkBinaryR val_out_ref;
      MkErrorE errVal = Mk.MkBufferGetBIN(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 GetBOL ()  {
      Byte val_out;
      MkErrorE errVal = Mk.MkBufferGetBOL(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out != 0;
    }
 
    public double GetDBL ()  {
      Double val_out;
      MkErrorE errVal = Mk.MkBufferGetDBL(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public float GetFLT ()  {
      Single val_out;
      MkErrorE errVal = Mk.MkBufferGetFLT(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public short GetI16 ()  {
      Int16 val_out;
      MkErrorE errVal = Mk.MkBufferGetI16(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public int GetI32 ()  {
      Int32 val_out;
      MkErrorE errVal = Mk.MkBufferGetI32(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public long GetI64 ()  {
      Int64 val_out;
      MkErrorE errVal = Mk.MkBufferGetI64(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public byte GetI8 ()  {
      Byte val_out;
      MkErrorE errVal = Mk.MkBufferGetI8(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return (byte)val_out;
    }
 
    public string GetSTR ()  {
      IntPtr val_out;
      MkErrorE errVal = Mk.MkBufferGetSTR(mkrt, hdl, out val_out);
      MkErrorC.Check(hdl, errVal);
      return Marshal.PtrToStringAnsi(val_out);
    }
 
    public string GetStringR ()  {
      Mk.MkStringR val_out_ref;
      MkErrorE errVal = Mk.MkBufferGetStringR(mkrt, hdl, out val_out_ref);
      MkErrorC.Check(hdl, errVal);
      return Marshal.PtrToStringAnsi(val_out_ref.ptr,val_out_ref.len);
    }
 
    // MkBufferC_Get_CS_API
  }
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-Info,om_
 
    public char GetType1 ()  {
      Char __retVal__L = Mk.MkBufferGetType1(mkrt, hdl);
      return __retVal__L;
    }
 
    public MkTypeE GetType2 ()  {
      MkTypeE __retVal__L = Mk.MkBufferGetType2(mkrt, hdl);
      return __retVal__L;
    }
 
    public string GetType3 ()  {
      IntPtr __retVal__L = Mk.MkBufferGetType3(mkrt, hdl);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public bool IsLocal ()  {
      bool __retVal__L = Mk.MkBufferIsLocal(mkrt, hdl);
      return __retVal__L;
    }
 
    // skip class-overload: Log = MkBufferLog → MkObjectLog
 
    public void LogS (string varname = "buf", MkObjectC fmtobj = null, [CallerMemberName]string callfunc = null)  {
      IntPtr fmtobj_hdl = MkObjectC.getOBJ_null_allow(fmtobj);
      IntPtr varname_cstr = Marshal.StringToHGlobalAnsi(varname);
      IntPtr callfunc_cstr = Marshal.StringToHGlobalAnsi(callfunc);
      Mk.MkBufferLogS(mkrt, hdl, varname_cstr, fmtobj_hdl, callfunc_cstr);
      Marshal.FreeHGlobal(varname_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    // MkBufferC_Info_CS_API
  }
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-Misc,oc_
 
    public MkBufferC Copy (MkBufferC srce)  {
      IntPtr srce_hdl = MkBufferC.getOBJ("MkBufferC",srce);
      IntPtr __retVal__L = Mk.MkBufferCopy(mkrt, hdl, srce_hdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC Reset ()  {
      IntPtr __retVal__L = Mk.MkBufferReset(mkrt, hdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SizeAdd (int size)  {
      IntPtr __retVal__L = Mk.MkBufferSizeAdd(mkrt, hdl, size);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SizeNew (int size)  {
      IntPtr __retVal__L = Mk.MkBufferSizeNew(mkrt, hdl, size);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC Temp ()  {
      IntPtr __retVal__L = Mk.MkBufferTemp(mkrt, hdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkBufferC,MkBufferC-Misc,om_
 
    public void CastTo (MkTypeE typ)  {
      MkErrorE errVal = Mk.MkBufferCastTo(mkrt, hdl, typ);
      MkErrorC.Check(hdl, errVal);
    }
 
    public int Cmp (MkBufferC buf2)  {
      IntPtr buf2_hdl = MkBufferC.getOBJ("MkBufferC",buf2);
      Int32 __retVal__L = Mk.MkBufferCmp(mkrt, hdl, buf2_hdl);
      return __retVal__L;
    }
 
    public void ResetFull ()  {
      Mk.MkBufferResetFull(mkrt, hdl);
    }
 
    // skip class-overload: ToString = MkBufferToString → MkObjectToString
 
    // MkBufferC_Misc_CS_API
  }
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-Set,oc_
 
    public MkBufferC SetBIN (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);
      IntPtr __retVal__L = Mk.MkBufferSetBIN(mkrt, hdl, val_ref);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetBOL (bool val)  {
      IntPtr __retVal__L = Mk.MkBufferSetBOL(mkrt, hdl, (Byte)(val?1:0));
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetBUF (MkBufferC val)  {
      IntPtr val_hdl = MkBufferC.getOBJ("MkBufferC",val);
      IntPtr __retVal__L = Mk.MkBufferSetBUF(mkrt, hdl, val_hdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetBinaryR (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);
      IntPtr __retVal__L = Mk.MkBufferSetBinaryR(mkrt, hdl, val_ref);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetDBL (double val)  {
      IntPtr __retVal__L = Mk.MkBufferSetDBL(mkrt, hdl, val);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetFLT (float val)  {
      IntPtr __retVal__L = Mk.MkBufferSetFLT(mkrt, hdl, val);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetI16 (short val)  {
      IntPtr __retVal__L = Mk.MkBufferSetI16(mkrt, hdl, val);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetI32 (int val)  {
      IntPtr __retVal__L = Mk.MkBufferSetI32(mkrt, hdl, val);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetI64 (long val)  {
      IntPtr __retVal__L = Mk.MkBufferSetI64(mkrt, hdl, val);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetI8 (byte val)  {
      IntPtr __retVal__L = Mk.MkBufferSetI8(mkrt, hdl, (Byte)(val));
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetSTR (string val)  {
      IntPtr val_cstr = Marshal.StringToHGlobalAnsi(val);
      IntPtr __retVal__L = Mk.MkBufferSetSTR(mkrt, hdl, val_cstr);
      Marshal.FreeHGlobal(val_cstr);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    public MkBufferC SetStringR (string val)  {
      IntPtr val_ref_cstr = Marshal.StringToHGlobalAnsi(val);
      Mk.MkStringR val_ref = Mk.MkStringCreate_1(val_ref_cstr);
      IntPtr __retVal__L = Mk.MkBufferSetStringR(mkrt, hdl, val_ref);
      Marshal.FreeHGlobal(val_ref_cstr);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // MkBufferC_Set_CS_API
  }
 
  public partial class MkBufferC {
 
 
    // doc-key: MkBufferC,MkBufferC-TOR,oC_
 
    public MkBufferC Merge ()  {
      IntPtr __retVal__L = Mk.MkBufferMerge(mkrt, hdl);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.Merge");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    // doc-key: MkBufferC,MkBufferC-TOR,oCx
 
    public MkBufferC Dup ()  {
      IntPtr __retVal__L = Mk.MkBufferDup(mkrt, hdl);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.Dup");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    // doc-key: MkBufferC,MkBufferC-TOR,sCc
 
    protected static IntPtr CTOR (int size = 0)  {
      IntPtr __retVal__L = Mk.MkBufferCreate(IntPtr.Zero, IntPtr.Zero, size);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CTOR");
      }
      return (IntPtr)__retVal__L;
    }
 
    public MkBufferC(int size = 0) : this(CTOR(size)) {}
 
    public static MkBufferC Create (int size = 0)  {
      IntPtr __retVal__L = Mk.MkBufferCreate(IntPtr.Zero, IntPtr.Zero, size);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.Create");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC Create1024 (int size = 0)  {
      IntPtr __retVal__L = Mk.MkBufferCreate1024(IntPtr.Zero, size);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.Create1024");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC Create256 (int size = 0)  {
      IntPtr __retVal__L = Mk.MkBufferCreate256(IntPtr.Zero, size);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.Create256");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC Create64 (int size = 0)  {
      IntPtr __retVal__L = Mk.MkBufferCreate64(IntPtr.Zero, size);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.Create64");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateBIN (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);
      IntPtr __retVal__L = Mk.MkBufferCreateBIN(IntPtr.Zero, val_ref);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateBIN");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateBOL (bool val)  {
      IntPtr __retVal__L = Mk.MkBufferCreateBOL(IntPtr.Zero, (Byte)(val?1:0));
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateBOL");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateBUF (MkBufferC val)  {
      IntPtr val_hdl = MkBufferC.getOBJ("MkBufferC",val);
      IntPtr __retVal__L = Mk.MkBufferCreateBUF(IntPtr.Zero, val_hdl);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateBUF");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateDBL (double val)  {
      IntPtr __retVal__L = Mk.MkBufferCreateDBL(IntPtr.Zero, val);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateDBL");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateFLT (float val)  {
      IntPtr __retVal__L = Mk.MkBufferCreateFLT(IntPtr.Zero, val);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateFLT");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateI16 (short val)  {
      IntPtr __retVal__L = Mk.MkBufferCreateI16(IntPtr.Zero, val);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateI16");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateI32 (int val)  {
      IntPtr __retVal__L = Mk.MkBufferCreateI32(IntPtr.Zero, val);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateI32");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateI64 (long val)  {
      IntPtr __retVal__L = Mk.MkBufferCreateI64(IntPtr.Zero, val);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateI64");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateI8 (byte val)  {
      IntPtr __retVal__L = Mk.MkBufferCreateI8(IntPtr.Zero, (Byte)(val));
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateI8");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferC CreateSTR (string val)  {
      IntPtr val_cstr = Marshal.StringToHGlobalAnsi(val);
      IntPtr __retVal__L = Mk.MkBufferCreateSTR(IntPtr.Zero, val_cstr);
      Marshal.FreeHGlobal(val_cstr);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferC.CreateSTR");
      }
      return MkBufferC.MkBufferC_ObjCreate(__retVal__L);
    }
 
    // doc-key: MkBufferC,MkBufferC-TOR,sc_
 
    public static MkBufferC CreateTLS (string tlsName, bool resetB = true)  {
      IntPtr tlsName_cstr = Marshal.StringToHGlobalAnsi(tlsName);
      IntPtr __retVal__L = Mk.MkBufferCreateTLS(IntPtr.Zero, tlsName_cstr, resetB);
      Marshal.FreeHGlobal(tlsName_cstr);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // MkBufferC_TOR_CS_API
  }
 
  // END-MkBufferC - created by 'cs_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// #################################################################################
  
  public partial class MkBufferC {
 
    public object ToObject () {
      object ret = null;
      switch (GetType1()) {
        case 'O': ret = GetBOL(); break;
        case 'Y': ret = GetI8(); break;
        case 'S': ret = GetI16(); break;
        case 'I': ret = GetI32(); break;
        case 'W': ret = GetI64(); break;
        case 'F': ret = GetFLT(); break;
        case 'D': ret = GetDBL(); break;
        case 'C': ret = GetSTR(); break;
        case 'L': ret = GetBFL().Dup().ToList(); break;
        case 'B': ret = GetBIN(); break;
        case 'T': {
          MkErrorC.FORMAT(this).SetC("INTERNAL ERROR: type 'TRA' not supported");
          break;
        }
      }
      return ret;
    } 
 
  }
 
} // END - namespace "csmkkernel"