MkBufferListC.cs

Go to the documentation of this file.

 
/* LABEL-INIT */
 
/* 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 MkBufferListC
#else
  public partial class MkBufferListC : MkObjectC
#endif
  {
    private readonly static ConstructorInfo ctor = getCtor(typeof(MkBufferListC));
    private readonly static ThreadLocal<MkBufferListC> MK_NULL = new ThreadLocal<MkBufferListC>(() => {
      return (MkBufferListC) atomSelfNull(ctor);
    });
 
    public static MkBufferListC MkBufferListC_ObjNew (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MkBufferListC) atomObjNew(typeof(MkBufferListC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static MkBufferListC MkBufferListC_ObjCreate (IntPtr hdl) {
      return hdl != IntPtr.Zero ? (MkBufferListC) atomObjCreate(typeof(MkBufferListC), ctor, hdl) : MK_NULL.Value;
    }
 
    private static IntPtr MkBufferListC_SelfCreate (IntPtr mkrt, IntPtr obj, IntPtr env) {
      return atomSelfCreate(ctor, obj, env);
    }
 
    private static void MkBufferListC_SelfUnlink (IntPtr mkrt, IntPtr self, IntPtr env) {
      atomSelfUnlink(self, env);
    }
 
    internal static void SetupThreadBFL (IntPtr mkrt) {
      Mk.MkCsTypeUpdate(mkrt, MkCsTypeLookupE.BFL, MkBufferListC_SelfCreate, MkBufferListC_SelfUnlink);
    }
 
    #if !META_STATIC_OVERWRITE
 
    static MkBufferListC() {
      // M0("MkBufferListC");
      MkKernel.Setup();
      SetupThreadBFL(IntPtr.Zero);
    }
 
    #endif
/* LABEL-END */
 
    internal MkBufferListC (IntPtr bufP) : base(bufP) {
    }
 
    public MkBufferListC (MkBufferListC copy) {
      if (Mk.MkRefGet(copy.hdl) > 1) {
        atomCreate(Mk.MkBufferListDup(mkrt,copy.hdl));
      } else {
        IntPtr bkp = copy.hdl;
        Mk.MkRefIncr(bkp);
        copy.Dispose();
        atomCreate(bkp);
        Mk.MkRefDecr(mkrt,bkp);
        bkp = IntPtr.Zero;
      }
    }
 
    public MkBufferListC(params string[] args) : base(CTOR(args.Length)) {
      if (args.Length != 0) {
        foreach (string a in args) {
          IntPtr a_cstr = Marshal.StringToHGlobalAnsi(a);
          Mk.MkBufferListAppendSTR(mkrt, hdl, a_cstr);
          Marshal.FreeHGlobal(a_cstr);
        }
      }
    }
 
    public MkBufferListC(params object[] args) : base(CTOR(args.Length)) {
      if (args.Length != 0) {
        foreach (object a in args) {
          IntPtr a_cstr = Marshal.StringToHGlobalAnsi((string)a);
          Mk.MkBufferListAppendSTR(mkrt, hdl, a_cstr);
          Marshal.FreeHGlobal(a_cstr);
        }
      }
    }
 
    public MkBufferListC AppendVC(string[] argv) {
      foreach (string a in argv) {
        IntPtr a_cstr = Marshal.StringToHGlobalAnsi(a);
        Mk.MkBufferListAppendSTR(mkrt, hdl, a_cstr);
        Marshal.FreeHGlobal(a_cstr);
      }
      return this;
    }
 
    public MkBufferListC AppendVA(params string[] argv) {
      foreach (string a in argv) {
        IntPtr a_cstr = Marshal.StringToHGlobalAnsi(a);
        Mk.MkBufferListAppendSTR(mkrt, hdl, a_cstr);
        Marshal.FreeHGlobal(a_cstr);
      }
      return this;
    }
 
  } // END - class "MkBufferListC"
 
  // BEGIN-MkBufferListC - created by 'cs_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-Append,oc_
 
    public MkBufferListC AppendLA (MkBufferListC args)  {
      IntPtr args_hdl = MkBufferListC.getOBJ("MkBufferListC",args);
      IntPtr __retVal__L = Mk.MkBufferListAppendLA(mkrt, hdl, args_hdl);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    public MkBufferListC AppendLP (MkBufferListC addBufL, int position = -1)  {
      IntPtr addBufL_hdl = MkBufferListC.getOBJ("MkBufferListC",addBufL);
      IntPtr __retVal__L = Mk.MkBufferListAppendLP(mkrt, hdl, addBufL_hdl, position);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    public MkBufferListC AppendLA (params string[] args)  {
      // OVERLOAD
      return AppendLA (new MkBufferListC(args));
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Append,om_
 
    public void AppendBIN (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);
      Mk.MkBufferListAppendBIN(mkrt, hdl, val_ref);
    }
 
    public void AppendBOL (bool val)  {
      Mk.MkBufferListAppendBOL(mkrt, hdl, (Byte)(val?1:0));
    }
 
    public void AppendBUF (MkBufferC val)  {
      IntPtr val_hdl = MkBufferC.getOBJ("MkBufferC",val);
      Mk.MkBufferListAppendBUF(mkrt, hdl, val_hdl);
    }
 
    public void AppendDBL (double val)  {
      Mk.MkBufferListAppendDBL(mkrt, hdl, val);
    }
 
    public void AppendFLT (float val)  {
      Mk.MkBufferListAppendFLT(mkrt, hdl, val);
    }
 
    public void AppendG (long val)  {
      Mk.MkBufferListAppendG(mkrt, hdl, val);
    }
 
    public void AppendI16 (short val)  {
      Mk.MkBufferListAppendI16(mkrt, hdl, val);
    }
 
    public void AppendI32 (int val)  {
      Mk.MkBufferListAppendI32(mkrt, hdl, val);
    }
 
    public void AppendI64 (long val)  {
      Mk.MkBufferListAppendI64(mkrt, hdl, val);
    }
 
    public void AppendI8 (byte val)  {
      Mk.MkBufferListAppendI8(mkrt, hdl, (Byte)(val));
    }
 
    public void AppendSTR (string val)  {
      IntPtr val_cstr = Marshal.StringToHGlobalAnsi(val);
      Mk.MkBufferListAppendSTR(mkrt, hdl, val_cstr);
      Marshal.FreeHGlobal(val_cstr);
    }
 
    public void AppendStringR (string val)  {
      IntPtr val_ref_cstr = Marshal.StringToHGlobalAnsi(val);
      Mk.MkStringR val_ref = Mk.MkStringCreate_1(val_ref_cstr);
      Mk.MkBufferListAppendStringR(mkrt, hdl, val_ref);
      Marshal.FreeHGlobal(val_ref_cstr);
    }
 
    public void AppendUP (MkBufferC addBuf, int position = -1)  {
      IntPtr addBuf_hdl = MkBufferC.getOBJ("MkBufferC",addBuf);
      Mk.MkBufferListAppendUP(mkrt, hdl, addBuf_hdl, position);
    }
 
    // MkBufferListC_Append_CS_API
  }
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-Check,oco
 
    public MkBufferC CheckOptionBUF (string opt, MkBufferC defval = null, bool onlyFirst = true)  {
      IntPtr val_out;
      IntPtr defval_hdl = MkBufferC.getOBJ_null_allow(defval);
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      MkErrorE errVal = Mk.MkBufferListCheckOptionBUF(mkrt, hdl, opt_cstr, defval_hdl, onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      MkErrorC.Check(hdl, errVal);
      return MkBufferC.MkBufferC_ObjNew(val_out);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Check,om_
 
    public bool CheckOption (string opt, bool onlyFirst = false)  {
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      bool __retVal__L = Mk.MkBufferListCheckOption(mkrt, hdl, opt_cstr, onlyFirst);
      Marshal.FreeHGlobal(opt_cstr);
      return __retVal__L;
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Check,omo
 
    public bool CheckOptionBOL (string opt, bool defval = false, bool onlyFirst = true)  {
      bool val_out;
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      MkErrorE errVal = Mk.MkBufferListCheckOptionBOL(mkrt, hdl, opt_cstr, defval, onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public double CheckOptionDBL (string opt, double defval = 0, bool onlyFirst = true)  {
      Double val_out;
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      MkErrorE errVal = Mk.MkBufferListCheckOptionDBL(mkrt, hdl, opt_cstr, defval, onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public float CheckOptionFLT (string opt, float defval = 0F, bool onlyFirst = true)  {
      Single val_out;
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      MkErrorE errVal = Mk.MkBufferListCheckOptionFLT(mkrt, hdl, opt_cstr, defval, onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public short CheckOptionI16 (string opt, short defval = 0, bool onlyFirst = true)  {
      Int16 val_out;
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      MkErrorE errVal = Mk.MkBufferListCheckOptionI16(mkrt, hdl, opt_cstr, defval, onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public int CheckOptionI32 (string opt, int defval = 0, bool onlyFirst = true)  {
      Int32 val_out;
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      MkErrorE errVal = Mk.MkBufferListCheckOptionI32(mkrt, hdl, opt_cstr, defval, onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public long CheckOptionI64 (string opt, long defval = 0, bool onlyFirst = true)  {
      Int64 val_out;
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      MkErrorE errVal = Mk.MkBufferListCheckOptionI64(mkrt, hdl, opt_cstr, defval, onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      MkErrorC.Check(hdl, errVal);
      return val_out;
    }
 
    public byte CheckOptionI8 (string opt, byte defval = 0, bool onlyFirst = true)  {
      Byte val_out;
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      MkErrorE errVal = Mk.MkBufferListCheckOptionI8(mkrt, hdl, opt_cstr, (Byte)(defval), onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      MkErrorC.Check(hdl, errVal);
      return (byte)val_out;
    }
 
    public string CheckOptionSTR (string opt, string defval = "", bool onlyFirst = true)  {
      IntPtr val_out;
      IntPtr opt_cstr = Marshal.StringToHGlobalAnsi(opt);
      IntPtr defval_cstr = Marshal.StringToHGlobalAnsi(defval);
      MkErrorE errVal = Mk.MkBufferListCheckOptionSTR(mkrt, hdl, opt_cstr, defval_cstr, onlyFirst, out val_out);
      Marshal.FreeHGlobal(opt_cstr);
      Marshal.FreeHGlobal(defval_cstr);
      MkErrorC.Check(hdl, errVal);
      return Marshal.PtrToStringAnsi(val_out);
    }
 
    // MkBufferListC_Check_CS_API
  }
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-Class-Export,sc_
 
    new public static MkBufferListC HandleResolve (Int32 netHdl)  {
      IntPtr __retVal__L = Mk.MkBufferListHandleResolve(IntPtr.Zero, netHdl);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Class-Export,om_
 
    // skip class-overload: HandleGet = MkBufferListHandleGet → MkObjectHandleGet
 
    // MkBufferListC_Class_CS_API
  }
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-Class-Introspection,oc_
 
    new public MkBufferListC Next ()  {
      IntPtr __retVal__L = Mk.MkBufferListNext(hdl);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    new public MkBufferListC Prev ()  {
      IntPtr __retVal__L = Mk.MkBufferListPrev(hdl);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Class-Introspection,sc_
 
    new public static MkBufferListC Instances ()  {
      IntPtr __retVal__L = Mk.MkBufferListInstances(IntPtr.Zero);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    // MkBufferListC_Class_CS_API
  }
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-Class-Misc,sc_
 
    new public static MkBufferListC GetNull ()  {
      IntPtr __retVal__L = Mk.MkBufferListGetNull();
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    // MkBufferListC_Class_CS_API
  }
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-Index,oc_
 
    public MkBufferC IndexGetBUF (int index)  {
      IntPtr __retVal__L = Mk.MkBufferListIndexGetBUF(mkrt, hdl, index);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Index,oco
 
    public MkBufferC IndexExtract (int index = 0)  {
      IntPtr val_out;
      MkErrorE errVal = Mk.MkBufferListIndexExtract(mkrt, hdl, index, out val_out);
      MkErrorC.Check(hdl, errVal);
      return MkBufferC.MkBufferC_ObjNew(val_out);
    }
 
    public MkBufferC IndexGet (int index)  {
      IntPtr val_out;
      MkErrorE errVal = Mk.MkBufferListIndexGet(mkrt, hdl, index, out val_out);
      MkErrorC.Check(hdl, errVal);
      return MkBufferC.MkBufferC_ObjNew(val_out);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Index,om_
 
    public void IndexDelete (int index, int numitems = 1, bool doDelete = true)  {
      MkErrorE errVal = Mk.MkBufferListIndexDelete(mkrt, hdl, index, numitems, doDelete);
      MkErrorC.Check(hdl, errVal);
    }
 
    public string IndexGetSTR (int index)  {
      IntPtr __retVal__L = Mk.MkBufferListIndexGetSTR(mkrt, hdl, index);
      return Marshal.PtrToStringAnsi(__retVal__L);
    }
 
    public void IndexSet (int index, MkBufferC buf)  {
      IntPtr buf_hdl = MkBufferC.getOBJ("MkBufferC",buf);
      MkErrorE errVal = Mk.MkBufferListIndexSet(mkrt, hdl, index, buf_hdl);
      MkErrorC.Check(hdl, errVal);
    }
 
    public void IndexSetBUF (int index, MkBufferC buf)  {
      IntPtr buf_hdl = MkBufferC.getOBJ("MkBufferC",buf);
      Mk.MkBufferListIndexSetBUF(mkrt, hdl, index, buf_hdl);
    }
 
    public void IndexSetSTR (int index, string str)  {
      IntPtr str_cstr = Marshal.StringToHGlobalAnsi(str);
      Mk.MkBufferListIndexSetSTR(mkrt, hdl, index, str_cstr);
      Marshal.FreeHGlobal(str_cstr);
    }
 
    // MkBufferListC_Index_CS_API
  }
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-Log,om_
 
    // skip class-overload: Log = MkBufferListLog → MkObjectLog
 
    public void LogS (string varname = "bfl", 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.MkBufferListLogS(mkrt, hdl, varname_cstr, fmtobj_hdl, callfunc_cstr);
      Marshal.FreeHGlobal(varname_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogSS (string varname = "bfl", 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.MkBufferListLogSS(mkrt, hdl, varname_cstr, fmtobj_hdl, callfunc_cstr);
      Marshal.FreeHGlobal(varname_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    public void LogSSS (string varname = "bfl", 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.MkBufferListLogSSS(mkrt, hdl, varname_cstr, fmtobj_hdl, callfunc_cstr);
      Marshal.FreeHGlobal(varname_cstr);
      Marshal.FreeHGlobal(callfunc_cstr);
    }
 
    // MkBufferListC_Log_CS_API
  }
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-Misc,sCc
 
    public static MkBufferListC FileGlob (string pattern_match)  {
      IntPtr pattern_match_cstr = Marshal.StringToHGlobalAnsi(pattern_match);
      IntPtr __retVal__L = Mk.MkBufferListFileGlob(IntPtr.Zero, pattern_match_cstr);
      Marshal.FreeHGlobal(pattern_match_cstr);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferListC.FileGlob");
      }
      return MkBufferListC.MkBufferListC_ObjCreate(__retVal__L);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Misc,oc_
 
    public MkBufferListC PositionMerge (MkBufferListC source, int position)  {
      IntPtr source_hdl = MkBufferListC.getOBJ("MkBufferListC",source);
      IntPtr __retVal__L = Mk.MkBufferListPositionMerge(mkrt, hdl, source_hdl, position);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    public MkBufferListC Reset ()  {
      IntPtr __retVal__L = Mk.MkBufferListReset(mkrt, hdl);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    public MkBufferListC Sort ()  {
      IntPtr __retVal__L = Mk.MkBufferListSort(mkrt, hdl);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    public MkBufferC ToBuffer ()  {
      IntPtr __retVal__L = Mk.MkBufferListToBuffer(mkrt, hdl);
      return MkBufferC.MkBufferC_ObjNew(__retVal__L);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-Misc,om_
 
    public int Cmp (MkBufferListC bfl2)  {
      IntPtr bfl2_hdl = MkBufferListC.getOBJ("MkBufferListC",bfl2);
      Int32 __retVal__L = Mk.MkBufferListCmp(mkrt, hdl, bfl2_hdl);
      return __retVal__L;
    }
 
    public void Copy (MkBufferListC src)  {
      IntPtr src_hdl = MkBufferListC.getOBJ("MkBufferListC",src);
      Mk.MkBufferListCopy(mkrt, hdl, src_hdl);
    }
 
    public void Move (MkBufferListC from)  {
      IntPtr from_hdl = MkBufferListC.getOBJ("MkBufferListC",from);
      Mk.MkBufferListMove(mkrt, hdl, from_hdl);
    }
 
    public void Reserve (int num)  {
      Mk.MkBufferListReserve(mkrt, hdl, num);
    }
 
    public int SearchC (string str, int len = -1, int startindex = 0)  {
      IntPtr str_cstr = Marshal.StringToHGlobalAnsi(str);
      Int32 __retVal__L = Mk.MkBufferListSearchC(mkrt, hdl, str_cstr, len, startindex);
      Marshal.FreeHGlobal(str_cstr);
      return __retVal__L;
    }
 
    public int Size ()  {
      Int32 __retVal__L = Mk.MkBufferListSize(mkrt, hdl);
      return __retVal__L;
    }
 
 
    // skip class-overload: ToString = MkBufferListToString → MkObjectToString
 
    // MkBufferListC_Misc_CS_API
  }
 
  public partial class MkBufferListC {
 
 
    // doc-key: MkBufferListC,MkBufferListC-TOR,oC_
 
    public MkBufferListC Merge ()  {
      IntPtr __retVal__L = Mk.MkBufferListMerge(mkrt, hdl);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferListC.Merge");
      }
      return MkBufferListC.MkBufferListC_ObjCreate(__retVal__L);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-TOR,oCx
 
    public MkBufferListC Dup ()  {
      IntPtr __retVal__L = Mk.MkBufferListDup(mkrt, hdl);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferListC.Dup");
      }
      return MkBufferListC.MkBufferListC_ObjCreate(__retVal__L);
    }
 
    // doc-key: MkBufferListC,MkBufferListC-TOR,sCc
 
    protected static IntPtr CTOR (int size = 0)  {
      IntPtr __retVal__L = Mk.MkBufferListCreate(IntPtr.Zero, size);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferListC.CTOR");
      }
      return (IntPtr)__retVal__L;
    }
 
    public MkBufferListC(int size = 0) : this(CTOR(size)) {}
 
    public static MkBufferListC Create (int size = 0)  {
      IntPtr __retVal__L = Mk.MkBufferListCreate(IntPtr.Zero, size);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferListC.Create");
      }
      return MkBufferListC.MkBufferListC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferListC CreateLA (MkBufferListC args)  {
      IntPtr args_hdl = MkBufferListC.getOBJ("MkBufferListC",args);
      IntPtr __retVal__L = Mk.MkBufferListCreateLA(IntPtr.Zero, args_hdl);
      if (__retVal__L == IntPtr.Zero) {
        throw new MkInitError("MkBufferListC.CreateLA");
      }
      return MkBufferListC.MkBufferListC_ObjCreate(__retVal__L);
    }
 
    public static MkBufferListC CreateLA (params string[] args)  {
      // OVERLOAD
      return CreateLA (new MkBufferListC(args));
    }
 
    // doc-key: MkBufferListC,MkBufferListC-TOR,sc_
 
    public static MkBufferListC CreateTLS (string tlsName, bool resetB = true)  {
      IntPtr tlsName_cstr = Marshal.StringToHGlobalAnsi(tlsName);
      IntPtr __retVal__L = Mk.MkBufferListCreateTLS(IntPtr.Zero, tlsName_cstr, resetB);
      Marshal.FreeHGlobal(tlsName_cstr);
      return MkBufferListC.MkBufferListC_ObjNew(__retVal__L);
    }
 
    // MkBufferListC_TOR_CS_API
  }
 
  // END-MkBufferListC - created by 'cs_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  
  public partial class MkBufferListC {
 
    public List<object> ToList () {
      int sz = Size();
      List<object> ret = new List<object>(sz);
      for (int i=0; i<sz; i++) {
        ret.Add(IndexGet(i).ToObject());
      }
      return ret;
    } 
 
  }
 
} // END - namespace "csmkkernel"