MkBufferListC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
#pragma once
 
/*****************************************************************************/
/*                                                                           */
/*                                context                                    */
/*                                                                           */
/*****************************************************************************/
 
namespace ccmkkernel {
 
/*
  inline MK_PTR MkBufferListC::MkBufferListC_selfCreateTLS(MK_OBJ obj) {
    return new MkBufferListC(obj);
  }
 
  inline MK_PTR MkBufferListC::MkBufferListC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
    MK_BFL inst = reinterpret_cast<MK_BFL>(obj);
    return MkOBJ_R(inst).obj_protect.isLocal ? MkBufferListC_selfCreateTLS(obj) : new MkBufferListC(obj);
  }
*/
 
  inline MkBufferListC::MkBufferListC (const MkBufferListC *copy) {
    if (copy == NULL) throw MkReferenceNullExceptionC("MkBufferListC");
    MkRtSetup_O(copy->hdl);
    MkObjectC::atomInit(MkObjDup(copy->hdl));
  }
 
  inline MkBufferListC::MkBufferListC (const MkBufferListC& copy) {
    MkRtSetup_O(copy.hdl);
    MkObjectC::atomInit(MkObjDup(copy.hdl));
  }
 
  inline MkBufferListC& MkBufferListC::operator= (const MkBufferListC& copy) {
    MkRtSetup_O(copy.hdl);
    MkObjCopy(hdl,copy.hdl);
    return *this;
  }
 
  inline MkBufferListC& MkBufferListC::operator= (const MkBufferListC* copy) {
    if (copy == NULL) throw MkReferenceNullExceptionC("MkBufferListC");
    MkRtSetup_O(copy->hdl);
    MkObjCopy(hdl,copy->hdl);
    return *this;
  }
 
  // --------------------------------------------------------------------------------------
 
  inline MkBufferListC::MkBufferListC (int argc, MK_STRN argv[]) {
    MkRtSetup_NULL;
    MkBufferListC_Init(MkBufferListCreateVC(argc,argv));
  }
 
  inline MkBufferListC::MkBufferListC (MK_STRN arg0, ...) {
    MkRtSetup_NULL;
    va_list ap;
    va_start(ap, arg0);
    MkBufferListC_Init(MkBufferListCreateVAL(arg0,ap));
    va_end (ap);
  }
 
  inline MkBufferListC::MkBufferListC (const std::vector<std::string>& vals) {
    MkRtSetup_NULL;
    auto bfl = MkBufferListCreate((MK_NUM)vals.size());
    for(const std::string& str : vals) {
      MkBufferListAppendStringR(bfl,MkStringCreate((MK_NUM)str.size(),str.c_str()));
    }
    MkBufferListC_Init(bfl);
  }
 
  inline MkBufferListC* MkBufferListC::AppendLA (const std::vector<std::string>& vals) {
    MK_UNUSED auto bfl = getBFL();
    MkRtSetup_X(bfl);
    for(const std::string& str : vals) {
      MkBufferListAppendStringR(bfl,MkStringCreate((MK_NUM)str.size(),str.c_str()));
    }
    return this;
  }
 
  inline MkBufferListC* MK_DECL MkBufferListC::ToList () const {
    return (MkBufferListC*) this;
  }
 
  //   BEGIN-MkBufferListC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
  // doc-key: MkBufferListC,MkBufferListC-Append,oc_
 
  inline MkBufferListC* MkBufferListC::AppendLA (MkBufferListC* args)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BAC args_hdl = MkBufferListC::getBFL(args);
    MK_BFL __retVal__L = MkBufferListAppendLA(bfl, args_hdl);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::AppendLA (const MkBufferListC& args)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_BAC args_hdl = MkBufferListC::getBFL(args);
    MK_BFL __retVal__L = MkBufferListAppendLA(bfl, args_hdl);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::AppendLP (MkBufferListC* addBufL, MK_NUM position)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL addBufL_hdl = MkBufferListC::getBFL(addBufL);
    MK_BFL __retVal__L = MkBufferListAppendLP(bfl, addBufL_hdl, position);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::AppendLP (const MkBufferListC& addBufL, MK_NUM position)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_BFL addBufL_hdl = MkBufferListC::getBFL(addBufL);
    MK_BFL __retVal__L = MkBufferListAppendLP(bfl, addBufL_hdl, position);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::AppendVA (MK_STRN arg0, ... )  {
    MK_UNUSED auto bfl = getBFL();
    va_list ap;
    va_start (ap, arg0);
    MK_BFL __retVal__L = MkBufferListAppendVAL(bfl, arg0, ap);
    va_end (ap);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::AppendVA (const std::string& arg0, ... )  {
    MK_UNUSED auto bfl = getBFL();
    const MK_STRN arg0_hdl = arg0.c_str();
    va_list ap;
    va_start (ap, arg0);
    MK_BFL __retVal__L = MkBufferListAppendVAL(bfl, arg0_hdl, ap);
    va_end (ap);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::AppendVAL (MK_STRN arg0, va_list var_list)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL __retVal__L = MkBufferListAppendVAL(bfl, arg0, var_list);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::AppendVAL (const std::string& arg0, va_list var_list)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_STRN arg0_hdl = arg0.c_str();
    MK_BFL __retVal__L = MkBufferListAppendVAL(bfl, arg0_hdl, var_list);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::AppendVC (MK_NUM argc, MK_STRN argv[] )  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL __retVal__L = MkBufferListAppendVC(bfl, argc,argv);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Append,om_
 
  inline void MkBufferListC::AppendBIN (MK_BNP val)  {
    MK_UNUSED auto bfl = getBFL();
    const MkBinaryR val_ref = MkBinaryCreate(val.first,val.second);
    MkBufferListAppendBIN(bfl, val_ref);
  }
 
  inline void MkBufferListC::AppendBOL (MK_BOL val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendBOL(bfl, (MK_BOL)(val?1:0));
  }
 
  inline void MkBufferListC::AppendBUF (MkBufferC* val)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BUF val_hdl = MkBufferC::getBUF(val);
    MkBufferListAppendBUF(bfl, val_hdl);
  }
 
  inline void MkBufferListC::AppendBUF (const MkBufferC& val)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_BUF val_hdl = MkBufferC::getBUF(val);
    MkBufferListAppendBUF(bfl, val_hdl);
  }
 
  inline void MkBufferListC::AppendDBL (MK_DBL val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendDBL(bfl, val);
  }
 
  inline void MkBufferListC::AppendFLT (MK_FLT val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendFLT(bfl, val);
  }
 
  inline void MkBufferListC::AppendG (MK_LONG val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendG(bfl, val);
  }
 
  inline void MkBufferListC::AppendI16 (MK_I16 val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendI16(bfl, val);
  }
 
  inline void MkBufferListC::AppendI32 (MK_I32 val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendI32(bfl, val);
  }
 
  inline void MkBufferListC::AppendI64 (MK_I64 val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendI64(bfl, val);
  }
 
  inline void MkBufferListC::AppendI8 (MK_I8 val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendI8(bfl, (MK_I8)(val));
  }
 
  inline void MkBufferListC::AppendSTR (MK_STRN val)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendSTR(bfl, val);
  }
 
  inline void MkBufferListC::AppendSTR (const std::string& val)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_STRN val_hdl = val.c_str();
    MkBufferListAppendSTR(bfl, val_hdl);
  }
 
  inline void MkBufferListC::AppendStringR (const std::string& val)  {
    MK_UNUSED auto bfl = getBFL();
    const MkStringR val_ref = MkStringCreate((MK_NUM)val.size(),val.c_str());
    MkBufferListAppendStringR(bfl, val_ref);
  }
 
  inline void MkBufferListC::AppendUP (MkBufferC* addBuf, MK_NUM position)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BUF addBuf_hdl = MkBufferC::getBUF(addBuf);
    MkBufferListAppendUP(bfl, addBuf_hdl, position);
  }
 
  inline void MkBufferListC::AppendUP (const MkBufferC& addBuf, MK_NUM position)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_BUF addBuf_hdl = MkBufferC::getBUF(addBuf);
    MkBufferListAppendUP(bfl, addBuf_hdl, position);
  }
 
  inline void MkBufferListC::AppendV (MK_FST printfmt, ... )  {
    MK_UNUSED auto bfl = getBFL();
    va_list ap;
    va_start (ap, printfmt);
    MkBufferListAppendVL(bfl, printfmt, ap);
    va_end (ap);
  }
 
  inline void MkBufferListC::AppendVL (MK_FST printfmt, va_list var_list)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListAppendVL(bfl, printfmt, var_list);
  }
 
  // MkBufferListC_Append_CC_API
 
 
  // doc-key: MkBufferListC,MkBufferListC-Check,oco
 
  inline MkBufferC* MkBufferListC::CheckOptionBUF (MK_STRN opt, MkBufferC* defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BUF val_out;
    MK_BUF defval_hdl = MkBufferC::getBUF__null_allow(defval);
    enum MkErrorE errVal = MkBufferListCheckOptionBUF(bfl, opt, defval_hdl, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL val_out);
  }
 
  inline MkBufferC* MkBufferListC::CheckOptionBUF (const std::string& opt, MkBufferC* defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BUF val_out;
    const MK_STRN opt_hdl = opt.c_str();
    MK_BUF defval_hdl = MkBufferC::getBUF__null_allow(defval);
    enum MkErrorE errVal = MkBufferListCheckOptionBUF(bfl, opt_hdl, defval_hdl, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL val_out);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Check,om_
 
  inline MK_BOOL MkBufferListC::CheckOption (MK_STRN opt, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BOOL __retVal__L = MkBufferListCheckOption(bfl, opt, onlyFirst);
    return __retVal__L;
  }
 
  inline MK_BOOL MkBufferListC::CheckOption (const std::string& opt, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_STRN opt_hdl = opt.c_str();
    MK_BOOL __retVal__L = MkBufferListCheckOption(bfl, opt_hdl, onlyFirst);
    return __retVal__L;
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Check,omo
 
  inline MK_BOOL MkBufferListC::CheckOptionBOL (MK_STRN opt, MK_BOOL defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BOOL val_out;
    enum MkErrorE errVal = MkBufferListCheckOptionBOL(bfl, opt, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_BOOL MkBufferListC::CheckOptionBOL (const std::string& opt, MK_BOOL defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BOOL val_out;
    const MK_STRN opt_hdl = opt.c_str();
    enum MkErrorE errVal = MkBufferListCheckOptionBOL(bfl, opt_hdl, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_DBL MkBufferListC::CheckOptionDBL (MK_STRN opt, MK_DBL defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_DBL val_out;
    enum MkErrorE errVal = MkBufferListCheckOptionDBL(bfl, opt, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_DBL MkBufferListC::CheckOptionDBL (const std::string& opt, MK_DBL defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_DBL val_out;
    const MK_STRN opt_hdl = opt.c_str();
    enum MkErrorE errVal = MkBufferListCheckOptionDBL(bfl, opt_hdl, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_FLT MkBufferListC::CheckOptionFLT (MK_STRN opt, MK_FLT defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_FLT val_out;
    enum MkErrorE errVal = MkBufferListCheckOptionFLT(bfl, opt, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_FLT MkBufferListC::CheckOptionFLT (const std::string& opt, MK_FLT defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_FLT val_out;
    const MK_STRN opt_hdl = opt.c_str();
    enum MkErrorE errVal = MkBufferListCheckOptionFLT(bfl, opt_hdl, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_I16 MkBufferListC::CheckOptionI16 (MK_STRN opt, MK_I16 defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_I16 val_out;
    enum MkErrorE errVal = MkBufferListCheckOptionI16(bfl, opt, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_I16 MkBufferListC::CheckOptionI16 (const std::string& opt, MK_I16 defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_I16 val_out;
    const MK_STRN opt_hdl = opt.c_str();
    enum MkErrorE errVal = MkBufferListCheckOptionI16(bfl, opt_hdl, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_I32 MkBufferListC::CheckOptionI32 (MK_STRN opt, MK_I32 defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_I32 val_out;
    enum MkErrorE errVal = MkBufferListCheckOptionI32(bfl, opt, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_I32 MkBufferListC::CheckOptionI32 (const std::string& opt, MK_I32 defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_I32 val_out;
    const MK_STRN opt_hdl = opt.c_str();
    enum MkErrorE errVal = MkBufferListCheckOptionI32(bfl, opt_hdl, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_I64 MkBufferListC::CheckOptionI64 (MK_STRN opt, MK_I64 defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_I64 val_out;
    enum MkErrorE errVal = MkBufferListCheckOptionI64(bfl, opt, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_I64 MkBufferListC::CheckOptionI64 (const std::string& opt, MK_I64 defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_I64 val_out;
    const MK_STRN opt_hdl = opt.c_str();
    enum MkErrorE errVal = MkBufferListCheckOptionI64(bfl, opt_hdl, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_I8 MkBufferListC::CheckOptionI8 (MK_STRN opt, MK_I8 defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_I8 val_out;
    enum MkErrorE errVal = MkBufferListCheckOptionI8(bfl, opt, (MK_I8)(defval), onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return (MK_I8)val_out;
  }
 
  inline MK_I8 MkBufferListC::CheckOptionI8 (const std::string& opt, MK_I8 defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_I8 val_out;
    const MK_STRN opt_hdl = opt.c_str();
    enum MkErrorE errVal = MkBufferListCheckOptionI8(bfl, opt_hdl, (MK_I8)(defval), onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return (MK_I8)val_out;
  }
 
  inline MK_STRN MkBufferListC::CheckOptionSTR (MK_STRN opt, MK_STRN defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_STRN val_out;
    enum MkErrorE errVal = MkBufferListCheckOptionSTR(bfl, opt, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  inline MK_STRN MkBufferListC::CheckOptionSTR (const std::string& opt, MK_STRN defval, MK_BOOL onlyFirst)  {
    MK_UNUSED auto bfl = getBFL();
    MK_STRN val_out;
    const MK_STRN opt_hdl = opt.c_str();
    enum MkErrorE errVal = MkBufferListCheckOptionSTR(bfl, opt_hdl, defval, onlyFirst, &val_out);
    MkErrorC_Check(bfl, errVal);
    return val_out;
  }
 
  // MkBufferListC_Check_CC_API
 
 
  // doc-key: MkBufferListC,MkBufferListC-Class-Export,sc_
 
  inline MkBufferListC* MkBufferListC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListHandleResolve(netHdl);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Class-Export,om_
 
  // skip class-overload: HandleGet = MkBufferListHandleGet → MkObjectHandleGet
 
  // MkBufferListC_Class_CC_API
 
 
  // doc-key: MkBufferListC,MkBufferListC-Class-Introspection,oc_
 
  inline MkBufferListC* MkBufferListC::Next ()  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL __retVal__L = MkBufferListNext(bfl);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::Prev ()  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL __retVal__L = MkBufferListPrev(bfl);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Class-Introspection,sc_
 
  inline MkBufferListC* MkBufferListC::Instances ()  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListInstances();
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferListC_Class_CC_API
 
 
  // doc-key: MkBufferListC,MkBufferListC-Class-Misc,sc_
 
  inline MkBufferListC* MkBufferListC::GetNull ()  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListGetNull();
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferListC_Class_CC_API
 
 
  // doc-key: MkBufferListC,MkBufferListC-Index,oc_
 
  inline MkBufferC* MkBufferListC::IndexGetBUF (MK_NUM index)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BUF __retVal__L = MkBufferListIndexGetBUF(bfl, index);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Index,oco
 
  inline MkBufferC* MkBufferListC::IndexExtract (MK_NUM index)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BUF val_out;
    enum MkErrorE errVal = MkBufferListIndexExtract(bfl, index, &val_out);
    MkErrorC_Check(bfl, errVal);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL val_out);
  }
 
  inline MkBufferC* MkBufferListC::IndexGet (MK_NUM index) const {
    MK_UNUSED auto bfl = getBFLN();
    MK_BUF val_out;
    enum MkErrorE errVal = MkBufferListIndexGet(bfl, index, &val_out);
    MkErrorC_Check(bfl, errVal);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL val_out);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Index,om_
 
  inline void MkBufferListC::IndexDelete (MK_NUM index, MK_NUM numitems, MK_BOOL doDelete)  {
    MK_UNUSED auto bfl = getBFL();
    enum MkErrorE errVal = MkBufferListIndexDelete(bfl, index, numitems, doDelete);
    MkErrorC_Check(bfl, errVal);
  }
 
  inline MK_STRN MkBufferListC::IndexGetSTR (MK_NUM index)  {
    MK_UNUSED auto bfl = getBFL();
    MK_STRN __retVal__L = MkBufferListIndexGetSTR(bfl, index);
    return __retVal__L;
  }
 
  inline void MkBufferListC::IndexSet (MK_NUM index, MkBufferC* buf)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BUF buf_hdl = MkBufferC::getBUF(buf);
    enum MkErrorE errVal = MkBufferListIndexSet(bfl, index, buf_hdl);
    MkErrorC_Check(bfl, errVal);
  }
 
  inline void MkBufferListC::IndexSet (MK_NUM index, const MkBufferC& buf)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_BUF buf_hdl = MkBufferC::getBUF(buf);
    enum MkErrorE errVal = MkBufferListIndexSet(bfl, index, buf_hdl);
    MkErrorC_Check(bfl, errVal);
  }
 
  inline void MkBufferListC::IndexSetBUF (MK_NUM index, MkBufferC* buf)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BUF buf_hdl = MkBufferC::getBUF(buf);
    MkBufferListIndexSetBUF(bfl, index, buf_hdl);
  }
 
  inline void MkBufferListC::IndexSetBUF (MK_NUM index, const MkBufferC& buf)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_BUF buf_hdl = MkBufferC::getBUF(buf);
    MkBufferListIndexSetBUF(bfl, index, buf_hdl);
  }
 
  inline void MkBufferListC::IndexSetSTR (MK_NUM index, MK_STRN str)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListIndexSetSTR(bfl, index, str);
  }
 
  inline void MkBufferListC::IndexSetSTR (MK_NUM index, const std::string& str)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_STRN str_hdl = str.c_str();
    MkBufferListIndexSetSTR(bfl, index, str_hdl);
  }
 
  // MkBufferListC_Index_CC_API
 
 
  // doc-key: MkBufferListC,MkBufferListC-Log,om_
 
  // skip class-overload: Log = MkBufferListLog → MkObjectLog
 
  // skip class-overload: Log = MkBufferListLog → MkObjectLog
 
  inline void MkBufferListC::LogS (MK_STRN varname, const MkObjectC* fmtobj, MK_STRN callfunc) const {
    MK_UNUSED auto bfl = getBFLN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkBufferListLogS(bfl, varname, fmtobj_hdl, callfunc);
  }
 
  inline void MkBufferListC::LogSS (MK_STRN varname, const MkObjectC* fmtobj, MK_STRN callfunc) const {
    MK_UNUSED auto bfl = getBFLN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkBufferListLogSS(bfl, varname, fmtobj_hdl, callfunc);
  }
 
  inline void MkBufferListC::LogSSS (MK_STRN varname, const MkObjectC* fmtobj, MK_STRN callfunc) const {
    MK_UNUSED auto bfl = getBFLN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkBufferListLogSSS(bfl, varname, fmtobj_hdl, callfunc);
  }
 
  // MkBufferListC_Log_CC_API
 
 
  // doc-key: MkBufferListC,MkBufferListC-Misc,sCc
 
  inline MkBufferListC* MkBufferListC::FileGlob (MK_STRN pattern_match)  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListFileGlob(pattern_match);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::FileGlob");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::FileGlob (const std::string& pattern_match)  {
    MkRtSetup_NULL;
    const MK_STRN pattern_match_hdl = pattern_match.c_str();
    MK_BFL __retVal__L = MkBufferListFileGlob(pattern_match_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::FileGlob");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Misc,oc_
 
  inline MkBufferListC* MkBufferListC::PositionMerge (MkBufferListC* source, MK_NUM position)  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL source_hdl = MkBufferListC::getBFL(source);
    MK_BFL __retVal__L = MkBufferListPositionMerge(bfl, source_hdl, position);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::PositionMerge (const MkBufferListC& source, MK_NUM position)  {
    MK_UNUSED auto bfl = getBFL();
    const MK_BFL source_hdl = MkBufferListC::getBFL(source);
    MK_BFL __retVal__L = MkBufferListPositionMerge(bfl, source_hdl, position);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::Reset ()  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL __retVal__L = MkBufferListReset(bfl);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::Sort ()  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL __retVal__L = MkBufferListSort(bfl);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferListC::ToBuffer () const {
    MK_UNUSED auto bfl = getBFLN();
    MK_BUF __retVal__L = MkBufferListToBuffer(bfl);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-Misc,om_
 
  inline MK_I32 MkBufferListC::Cmp (const MkBufferListC* bfl2) const {
    MK_UNUSED auto bfl = getBFLN();
    MK_BFLN bfl2_hdl = MkBufferListC::getBFLN(bfl2);
    MK_I32 __retVal__L = MkBufferListCmp(bfl, bfl2_hdl);
    return __retVal__L;
  }
 
  inline MK_I32 MkBufferListC::Cmp (const MkBufferListC& bfl2) const {
    MK_UNUSED auto bfl = getBFLN();
    const MK_BFLN bfl2_hdl = MkBufferListC::getBFLN(bfl2);
    MK_I32 __retVal__L = MkBufferListCmp(bfl, bfl2_hdl);
    return __retVal__L;
  }
 
  inline void MkBufferListC::Copy (const MkBufferListC* src) const {
    MK_UNUSED auto bfl = getBFL();
    MK_BFLN src_hdl = MkBufferListC::getBFLN(src);
    MkBufferListCopy(bfl, src_hdl);
  }
 
  inline void MkBufferListC::Copy (const MkBufferListC& src) const {
    MK_UNUSED auto bfl = getBFL();
    const MK_BFLN src_hdl = MkBufferListC::getBFLN(src);
    MkBufferListCopy(bfl, src_hdl);
  }
 
  inline void MkBufferListC::Move (MkBufferListC* from)  {
    MK_UNUSED auto to = getBFL();
    MK_BFL from_hdl = MkBufferListC::getBFL(from);
    MkBufferListMove(to, from_hdl);
  }
 
  inline void MkBufferListC::Move (const MkBufferListC& from)  {
    MK_UNUSED auto to = getBFL();
    const MK_BFL from_hdl = MkBufferListC::getBFL(from);
    MkBufferListMove(to, from_hdl);
  }
 
  inline void MkBufferListC::Reserve (MK_NUM num)  {
    MK_UNUSED auto bfl = getBFL();
    MkBufferListReserve(bfl, num);
  }
 
  inline MK_NUM MkBufferListC::SearchC (MK_STRN str, MK_NUM len, MK_NUM startindex) const {
    MK_UNUSED auto bfl = getBFLN();
    MK_NUM __retVal__L = MkBufferListSearchC(bfl, str, len, startindex);
    return __retVal__L;
  }
 
  inline MK_NUM MkBufferListC::SearchC (const std::string& str, MK_NUM len, MK_NUM startindex) const {
    MK_UNUSED auto bfl = getBFLN();
    const MK_STRN str_hdl = str.c_str();
    MK_NUM __retVal__L = MkBufferListSearchC(bfl, str_hdl, len, startindex);
    return __retVal__L;
  }
 
  inline MK_NUM MkBufferListC::Size () const {
    MK_UNUSED auto bfl = getBFLN();
    MK_NUM __retVal__L = MkBufferListSizeI(bfl);
    return __retVal__L;
  }
 
 
  // skip class-overload: ToString = MkBufferListToString → MkObjectToString
 
  // MkBufferListC_Misc_CC_API
 
 
  // doc-key: MkBufferListC,MkBufferListC-TOR,oC_
 
  inline MkBufferListC* MkBufferListC::Merge ()  {
    MK_UNUSED auto bfl = getBFL();
    MK_BFL __retVal__L = MkBufferListMerge(bfl);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::Merge");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-TOR,oCx
 
  inline MkBufferListC* MkBufferListC::Dup () const {
    MK_UNUSED auto bfl = getBFLN();
    MK_BFL __retVal__L = MkBufferListDup(bfl);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::Dup");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-TOR,sCc
 
  inline MK_OBJ MkBufferListC::CTOR (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListCreate(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::CTOR");
    }
    return (MK_OBJ)__retVal__L;
  }
 
  inline MkBufferListC* MkBufferListC::Create (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListCreate(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::Create");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::CreateLA (MkBufferListC* args)  {
    MkRtSetup_NULL;
    MK_BAC args_hdl = MkBufferListC::getBFL(args);
    MK_BFL __retVal__L = MkBufferListCreateLA(args_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::CreateLA");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::CreateLA (const MkBufferListC& args)  {
    MkRtSetup_NULL;
    const MK_BAC args_hdl = MkBufferListC::getBFL(args);
    MK_BFL __retVal__L = MkBufferListCreateLA(args_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::CreateLA");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::CreateVA (MK_STRN arg0, ... )  {
    MkRtSetup_NULL;
    va_list ap;
    va_start (ap, arg0);
    MK_BFL __retVal__L = MkBufferListCreateVAL(arg0, ap);
    va_end (ap);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::CreateVA");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::CreateVA (const std::string& arg0, ... )  {
    MkRtSetup_NULL;
    const MK_STRN arg0_hdl = arg0.c_str();
    va_list ap;
    va_start (ap, arg0);
    MK_BFL __retVal__L = MkBufferListCreateVAL(arg0_hdl, ap);
    va_end (ap);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::CreateVA");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::CreateVAL (MK_STRN arg0, va_list var_list)  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListCreateVAL(arg0, var_list);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::CreateVAL");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::CreateVAL (const std::string& arg0, va_list var_list)  {
    MkRtSetup_NULL;
    const MK_STRN arg0_hdl = arg0.c_str();
    MK_BFL __retVal__L = MkBufferListCreateVAL(arg0_hdl, var_list);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::CreateVAL");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::CreateVC (MK_NUM argc, MK_STRN argv[] )  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListCreateVC(argc,argv);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferListC::CreateVC");
    }
    return MkBufferListC::MkBufferListC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferListC,MkBufferListC-TOR,sc_
 
  inline MkBufferListC* MkBufferListC::CreateTLS (MK_STRN tlsName, MK_BOOL resetB)  {
    MkRtSetup_NULL;
    MK_BFL __retVal__L = MkBufferListCreateTLS(tlsName, resetB);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferListC::CreateTLS (const std::string& tlsName, MK_BOOL resetB)  {
    MkRtSetup_NULL;
    const MK_STRN tlsName_hdl = tlsName.c_str();
    MK_BFL __retVal__L = MkBufferListCreateTLS(tlsName_hdl, resetB);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferListC_TOR_CC_API
 
  //   END-MkBufferListC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
} // END - namespace "ccmkkernel"