MkBufferListC_py.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME              "MkBufferListC_py.c"
 
#include "LibMkKernel_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(MkBufferListCR))
#define OT_CLASS_NAME               "MkBufferListC"
 
#define OT_LNG2META(O)              MkBfl(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(MkBufferListC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MkBufferListC)
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(MkBufferListC)
#define OT_SETUP_hdl_constr         MK_RT_UNUSED AllRtSetup_NULL; \
                                    MK_BFL hdl = (MK_BFL) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MkBufferListC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MkBufferListC##_TT;
 
#define OT_SETUP_hdl_static_constr  OT_SETUP_hdl_static
 
#if !defined(SetupRtFromObj_X)
  #define SetupRtFromObj_X(hdl)     AllRtSetup_X(hdl)
  #define SetupRtFromObj_XN(hdl)    AllRtSetup_XN(hdl)
#endif
 
// MO class
#undef MkBufferListCTT
#define MkBufferListCTT MK(MkKernelThreadState).MkBufferListCTT
/* MkBufferListC_MK_NULL defined in LibMkKernel_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(MkBufferListC_CTOR) (MK_RT_ARGS OT_CLS_T type, MK_BFL hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,MkBufferListC_X2obj(hdl));
}
 
// helper: mk_dbg_color_ln(MK_COLOR_YELLOW,"hdl<%p>, self<%p>", obj, self);
 
// META: ObjNew feature: selfCreate will be called from "ObjNew->MkSelfNew" if MkObj need a SELF pointer
static MK_PTR NS(MkBufferListC_selfCreate) (MK_RT_ARGS MK_OBJ const obj, MK_PTR const env) {
  return MK(AtomCreate) (MK_RT_CALL OT_CLASS,obj);
}
// META: called if MkObj must be destroyed and if the SELF is still alive → goal: destroy the SELF
static void NS(MkBufferListC_selfDelete) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MK(AtomDeleteHard) (MK_RT_CALL OT_SELF);
}
// META: called to destroy link from SELF to META
static void NS(MkBufferListC_selfUnlink) (MK_RT_ARGS MK_PTR self, MK_PTR const env) {
  MkObjectC_Obj *selfO = (MkObjectC_Obj*) self;
  selfO->hdl = NULL;
}
 
// initialize the PY and MO class specific object
#define   ClassInit \
  /* if not already done, initialize NEW META type */ \
  if (MkBufferListCTT == NULL) MkBufferListCTT = MkBufferListSTT; \
  \
  /* protect against double call */ \
  if (MkBufferListCTT->selfCreate == NS(MkBufferListC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MkBufferListCTT->selfCreate    = NS(MkBufferListC_selfCreate); \
  MkBufferListCTT->selfDelete    = NS(MkBufferListC_selfDelete); \
  MkBufferListCTT->selfUnlink    = NS(MkBufferListC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MkBufferListCR).tp_base = MkBufferListC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MkBufferListC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MkBufferListC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
 
/* LABEL-END */
 
#define META_CONTEXT_S        hdl->error
 
 
// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferListC,MkBufferList,sCc,func
#define Create_doc "MkBufferListC MkBufferListC.Create(?size:int32=0?)"
#define CreateLA_doc "MkBufferListC MkBufferListC.CreateLA(args:MkBufferListC...)"
#define FileGlob_doc "MkBufferListC MkBufferListC.FileGlob(pattern_match:string)"
#define new_doc "MkBufferListC MkBufferListC.new(?size:int32=0?)"
 
// doc-key: MkBufferListC,MkBufferList,sc_,func
#define CreateTLS_doc "MkBufferListC MkBufferListC.CreateTLS(tlsName:string, ?resetB:bool=true?)"
#define GetNull_doc "MkBufferListC MkBufferListC.GetNull()"
#define HandleResolve_doc "MkBufferListC MkBufferListC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "MkBufferListC MkBufferListC.Instances()"
 
// doc-key: MkBufferListC,MkBufferList,oC_,func
#define Merge_doc "MkBufferListC bfl.Merge()"
 
// doc-key: MkBufferListC,MkBufferList,oCx,func
#define Dup_doc "MkBufferListC bfl.Dup() (const)"
 
// doc-key: MkBufferListC,MkBufferList,oc_,func
#define AppendLA_doc "MkBufferListC bfl.AppendLA(args:MkBufferListC...)"
#define AppendLP_doc "MkBufferListC bfl.AppendLP(addBufL:MkBufferListC, ?position:int32=-1?)"
#define IndexGetBUF_doc "MkBufferC bfl.IndexGetBUF(index:int32)"
#define Next_doc "MkBufferListC bfl.Next()"
#define PositionMerge_doc "MkBufferListC bfl.PositionMerge(source:MkBufferListC, position:int32)"
#define Prev_doc "MkBufferListC bfl.Prev()"
#define Reset_doc "MkBufferListC bfl.Reset()"
#define Sort_doc "MkBufferListC bfl.Sort()"
#define ToBuffer_doc "MkBufferC bfl.ToBuffer() (const)"
 
// doc-key: MkBufferListC,MkBufferList,oco,func
#define CheckOptionBUF_doc "MkBufferC bfl.CheckOptionBUF(opt:string, ?defval:MkBufferC=None?, ?onlyFirst:bool=true?)"
#define IndexExtract_doc "MkBufferC bfl.IndexExtract(?index:int32=0?)"
#define IndexGet_doc "MkBufferC bfl.IndexGet(index:int32) (const)"
 
// doc-key: MkBufferListC,MkBufferList,om_,func
#define AppendBIN_doc "bfl.AppendBIN(val:binary)"
#define AppendBOL_doc "bfl.AppendBOL(val:bool)"
#define AppendBUF_doc "bfl.AppendBUF(val:MkBufferC)"
#define AppendDBL_doc "bfl.AppendDBL(val:double)"
#define AppendFLT_doc "bfl.AppendFLT(val:float)"
#define AppendG_doc "bfl.AppendG(val:long)"
#define AppendI16_doc "bfl.AppendI16(val:int16)"
#define AppendI32_doc "bfl.AppendI32(val:int32)"
#define AppendI64_doc "bfl.AppendI64(val:int64)"
#define AppendI8_doc "bfl.AppendI8(val:int8)"
#define AppendSTR_doc "bfl.AppendSTR(val:string)"
#define AppendStringR_doc "bfl.AppendStringR(val:string)"
#define AppendUP_doc "bfl.AppendUP(addBuf:MkBufferC, ?position:int32=-1?)"
#define CheckOption_doc "bool bfl.CheckOption(opt:string, ?onlyFirst:bool=false?)"
#define Cmp_doc "int32 bfl.Cmp(bfl2:MkBufferListC) (const)"
#define Copy_doc "bfl.Copy(src:MkBufferListC) (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define IndexDelete_doc "bfl.IndexDelete(index:int32, ?numitems:int32=1?, ?doDelete:bool=true?)"
#define IndexGetSTR_doc "string bfl.IndexGetSTR(index:int32)"
#define IndexSet_doc "bfl.IndexSet(index:int32, buf:MkBufferC)"
#define IndexSetBUF_doc "bfl.IndexSetBUF(index:int32, buf:MkBufferC)"
#define IndexSetSTR_doc "bfl.IndexSetSTR(index:int32, str:string)"
// skip class-overload: Log → MkObjectLog
#define LogS_doc "bfl.LogS(?varname:string=\"bfl\"?, ?fmtobj:MkObjectC=None?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define LogSS_doc "bfl.LogSS(?varname:string=\"bfl\"?, ?fmtobj:MkObjectC=None?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define LogSSS_doc "bfl.LogSSS(?varname:string=\"bfl\"?, ?fmtobj:MkObjectC=None?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define Move_doc "to.Move(from:MkBufferListC)"
#define Reserve_doc "bfl.Reserve(num:int32)"
#define SearchC_doc "int32 bfl.SearchC(str:string, ?len:int32=-1?, ?startindex:int32=0?) (const)"
#define Size_doc "int32 bfl.Size() (const)"
#define ToList_doc "[list...] bfl.ToList() (const)"
// skip class-overload: ToString → MkObjectToString
 
// doc-key: MkBufferListC,MkBufferList,omo,func
#define CheckOptionBOL_doc "bool bfl.CheckOptionBOL(opt:string, ?defval:bool=false?, ?onlyFirst:bool=true?)"
#define CheckOptionDBL_doc "double bfl.CheckOptionDBL(opt:string, ?defval:double=0?, ?onlyFirst:bool=true?)"
#define CheckOptionFLT_doc "float bfl.CheckOptionFLT(opt:string, ?defval:float=0?, ?onlyFirst:bool=true?)"
#define CheckOptionI16_doc "int16 bfl.CheckOptionI16(opt:string, ?defval:int16=0?, ?onlyFirst:bool=true?)"
#define CheckOptionI32_doc "int32 bfl.CheckOptionI32(opt:string, ?defval:int32=0?, ?onlyFirst:bool=true?)"
#define CheckOptionI64_doc "int64 bfl.CheckOptionI64(opt:string, ?defval:int64=0?, ?onlyFirst:bool=true?)"
#define CheckOptionI8_doc "int8 bfl.CheckOptionI8(opt:string, ?defval:int8=0?, ?onlyFirst:bool=true?)"
#define CheckOptionSTR_doc "string bfl.CheckOptionSTR(opt:string, ?defval:string=\"\"?, ?onlyFirst:bool=true?)"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
 
OT_ProcRet NS(MkBufferListC_ToList) (MkBufferListC_ARGS);
#include "tmpl/MkBufferListC_ToList_lng.h"
 
// vim: Marker(s)
// BEGIN-MkBufferListC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkBufferListC,MkBufferListC-Append,oc_
 
static OT_ProcRet NS(MkBufferListC_AppendLA) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,99,AppendLA_doc);
  MkBufferListCreateTLS_T(args,10);
  OT_CHECK_REQUIRED(OT_CHECK_BAC (args))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListAppendLA (hdl, args);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendLP) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,AppendLP_doc);
  MkBufferListCreateTLS_T(addBufL,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFL (addBufL,MK_NULL_NO))
  MK_NUM position = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (position))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListAppendLP (hdl, addBufL, position);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Append,om_
 
static OT_ProcRet NS(MkBufferListC_AppendBIN) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendBIN_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MkBufferListAppendBIN (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendBOL) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendBOL_doc);
  MK_BOL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NB1 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendBOL (hdl, (MK_BOL)(val?1:0));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendBUF) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendBUF_doc);
  MK_BUF val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUF (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkBufferListAppendBUF (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendDBL) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendDBL_doc);
  MK_DBL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF8 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendDBL (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendFLT) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendFLT_doc);
  MK_FLT val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF4 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendFLT (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendG) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendG_doc);
  MK_LONG val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIL (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendG (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendI16) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendI16_doc);
  MK_I16 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendI16 (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendI32) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendI32_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendI32 (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendI64) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendI64_doc);
  MK_I64 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI8 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendI64 (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendI8) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendI8_doc);
  MK_I8 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI1 (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendI8 (hdl, (MK_I8)(val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendSTR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendSTR_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MkBufferListAppendSTR (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendStringR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendStringR_doc);
  MkStringR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkStringR(val))
  OT_CHECK_NOARGS;
  MkBufferListAppendStringR (hdl, val);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_AppendUP) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,AppendUP_doc);
  MK_BUF addBuf = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUF (addBuf,MK_NULL_NO))
  MK_NUM position = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (position))
  OT_CHECK_NOARGS;
  MkBufferListAppendUP (hdl, addBuf, position);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferListC_Append_PY_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Check,oco
 
static OT_ProcRet NS(MkBufferListC_CheckOptionBUF) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionBUF_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_BUF defval = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_BUF (defval,MK_NULL_YES))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionBUF (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_BUF(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Check,om_
 
static OT_ProcRet NS(MkBufferListC_CheckOption) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,CheckOption_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_BOOL onlyFirst = false;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkBufferListCheckOption (hdl, opt, onlyFirst));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Check,omo
 
static OT_ProcRet NS(MkBufferListC_CheckOptionBOL) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionBOL_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_BOOL defval = false;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_BOOL val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionBOL (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_BOL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionDBL) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionDBL_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_DBL defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NF8 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_DBL val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionDBL (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_DBL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionFLT) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionFLT_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_FLT defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NF4 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_FLT val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionFLT (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_FLT(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionI16) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionI16_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_I16 defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI2 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_I16 val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionI16 (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_I16(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionI32) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionI32_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_I32 defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_I32 val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionI32 (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_I32(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionI64) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionI64_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_I64 defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI8 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_I64 val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionI64 (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_I64(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionI8) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionI8_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_I8 defval = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI1 (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_I8 val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionI8 (hdl, opt, (MK_I8)(defval), onlyFirst, &val_out));
  OT_retObj_SET_I8(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CheckOptionSTR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,CheckOptionSTR_doc);
  MK_STRN opt = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (opt))
  MK_STRN defval = "";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (defval))
  MK_BOOL onlyFirst = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (onlyFirst))
  OT_CHECK_NOARGS;
  MK_STRN val_out;
  MkErrorC_Check(hdl,MkBufferListCheckOptionSTR (hdl, opt, defval, onlyFirst, &val_out));
  OT_retObj_SET_STR(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferListC_Check_PY_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Export,sc_
 
static OT_ProcRet NS(MkBufferListC_HandleResolve) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_ONEARG(HandleResolve_doc);
  MK_HDL netHdl = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIH (netHdl))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListHandleResolve (netHdl);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Class-Export,om_
 
// skip on class-overload: MkBufferListHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferListC_HandleGet) (MkBufferListC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferListC_Class_PY_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Introspection,oc_
 
static OT_ProcRet NS(MkBufferListC_Next) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListNext (hdl);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Prev) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListPrev (hdl);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Class-Introspection,sc_
 
static OT_ProcRet NS(MkBufferListC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListInstances ();
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferListC_Class_PY_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Class-Misc,sc_
 
static OT_ProcRet NS(MkBufferListC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListGetNull ();
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferListC_Class_PY_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Index,oc_
 
static OT_ProcRet NS(MkBufferListC_IndexGetBUF) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(IndexGetBUF_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferListIndexGetBUF (hdl, index);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Index,oco
 
static OT_ProcRet NS(MkBufferListC_IndexExtract) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,IndexExtract_doc);
  MK_NUM index = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (index))
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferListIndexExtract (hdl, index, &val_out));
  OT_retObj_SET_BUF(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexGet) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(IndexGet_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferListIndexGet (hdl, index, &val_out));
  OT_retObj_SET_BUF(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Index,om_
 
static OT_ProcRet NS(MkBufferListC_IndexDelete) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,IndexDelete_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  MK_NUM numitems = 1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (numitems))
  MK_BOOL doDelete = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (doDelete))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferListIndexDelete (hdl, index, numitems, doDelete));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexGetSTR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(IndexGetSTR_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkBufferListIndexGetSTR (hdl, index));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexSet) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,IndexSet_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  MK_BUF buf = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUF (buf,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferListIndexSet (hdl, index, buf));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexSetBUF) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,IndexSetBUF_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  MK_BUF buf = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUF (buf,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkBufferListIndexSetBUF (hdl, index, buf);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_IndexSetSTR) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,IndexSetSTR_doc);
  MK_NUM index = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (index))
  MK_STRN str = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (str))
  OT_CHECK_NOARGS;
  MkBufferListIndexSetSTR (hdl, index, str);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferListC_Index_PY_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Log,om_
 
// skip on class-overload: MkBufferListLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferListC_Log) (MkBufferListC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(MkBufferListC_LogS) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,LogS_doc);
  MK_STRN varname = "bfl";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (varname))
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkBufferListLogS (hdl, varname, fmtobj, callfunc);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_LogSS) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,LogSS_doc);
  MK_STRN varname = "bfl";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (varname))
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkBufferListLogSS (hdl, varname, fmtobj, callfunc);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_LogSSS) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,LogSSS_doc);
  MK_STRN varname = "bfl";
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (varname))
  MK_OBJN fmtobj = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_OBJN (fmtobj,MK_NULL_YES))
  MK_STRN callfunc = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_STRN (callfunc))
  OT_CHECK_NOARGS;
  if (MkSysStringIsNULL(callfunc)) {callfunc = OT_GET_CALL_PROC;}
  MkBufferListLogSSS (hdl, varname, fmtobj, callfunc);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkBufferListC_Log_PY_API
 
 
// doc-key: MkBufferListC,MkBufferListC-Misc,sCc
 
static OT_ProcRet NS(MkBufferListC_FileGlob) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(FileGlob_doc);
  MK_STRN pattern_match = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (pattern_match))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListFileGlob (pattern_match);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
    goto error;
  }
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Misc,oc_
 
static OT_ProcRet NS(MkBufferListC_PositionMerge) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(2,2,PositionMerge_doc);
  MkBufferListCreateTLS_T(source,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFL (source,MK_NULL_NO))
  MK_NUM position = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (position))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListPositionMerge (hdl, source, position);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Reset) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Reset_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListReset (hdl);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Sort) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Sort_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListSort (hdl);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_ToBuffer) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ToBuffer_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferListToBuffer (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-Misc,om_
 
static OT_ProcRet NS(MkBufferListC_Cmp) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Cmp_doc);
  MkBufferListCreateTLS_T(bfl2,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (bfl2,MK_NULL_NO))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferListCmp (hdl, bfl2));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Copy) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Copy_doc);
  MkBufferListCreateTLS_T(src,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (src,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkBufferListCopy (hdl, src);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Move) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Move_doc);
  MkBufferListCreateTLS_T(from,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFL (from,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkBufferListMove (hdl, from);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Reserve) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Reserve_doc);
  MK_NUM num = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (num))
  OT_CHECK_NOARGS;
  MkBufferListReserve (hdl, num);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_SearchC) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,3,SearchC_doc);
  MK_STRN str = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (str))
  MK_NUM len = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (len))
  MK_NUM startindex = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (startindex))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferListSearchC (hdl, str, len, startindex));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_Size) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Size_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferListSizeI (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
OT_ProcRet NS(MkBufferListC_ToList) (MkBufferListC_ARGS) ; // skip template-required
 
// skip on class-overload: MkBufferListToString → MkObjectToString
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferListC_ToString) (MkBufferListC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferListC_Misc_PY_API
 
 
// doc-key: MkBufferListC,MkBufferListC-TOR,oC_
 
static OT_ProcRet NS(MkBufferListC_Merge) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Merge_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListMerge (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
    goto error;
  }
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,oCx
 
static OT_ProcRet NS(MkBufferListC_Dup) (MkBufferListC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Dup_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListDup (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
    goto error;
  }
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,sCc
 
static OT_ProcRet NS(MkBufferListC_Create) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListCreate (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_CreateLA) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,99,CreateLA_doc);
  MkBufferListCreateTLS_T(args,10);
  OT_CHECK_REQUIRED(OT_CHECK_BAC (args))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListCreateLA (args);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
    goto error;
  }
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferListC_new) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(0,1,new_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  MK_BFL retVal = MkBufferListCreate (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferListC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferListC,MkBufferListC-TOR,sc_
 
static OT_ProcRet NS(MkBufferListC_CreateTLS) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_VARARGS(1,2,CreateTLS_doc);
  MK_STRN tlsName = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (tlsName))
  MK_BOOL resetB = true;
  OT_CHECK_OPTIONAL(OT_CHECK_bool (resetB))
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferListCreateTLS (tlsName, resetB);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferListC_TOR_PY_API
 
// END-MkBufferListC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
static PyMethodDef NS(MkBufferListC_Methods)[] = {
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkBufferListC,MkBufferList,sCc
  { "Create"         , (PyCFunction) NS(MkBufferListC_Create)         , METH_VARARGS|METH_CLASS , Create_doc },
  { "CreateLA"       , (PyCFunction) NS(MkBufferListC_CreateLA)       , METH_VARARGS|METH_CLASS , CreateLA_doc },
  { "FileGlob"       , (PyCFunction) NS(MkBufferListC_FileGlob)       , METH_O|METH_CLASS       , FileGlob_doc },
 
  // doc-key: MkBufferListC,MkBufferList,sc_
  { "CreateTLS"      , (PyCFunction) NS(MkBufferListC_CreateTLS)      , METH_VARARGS|METH_CLASS , CreateTLS_doc },
  { "GetNull"        , (PyCFunction) NS(MkBufferListC_GetNull)        , METH_NOARGS|METH_CLASS  , GetNull_doc },
  { "HandleResolve"  , (PyCFunction) NS(MkBufferListC_HandleResolve)  , METH_O|METH_CLASS       , HandleResolve_doc },
  { "Instances"      , (PyCFunction) NS(MkBufferListC_Instances)      , METH_NOARGS|METH_CLASS  , Instances_doc },
 
  // END-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // BEGIN-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkBufferListC,MkBufferList,oC_
  { "Merge"          , (PyCFunction) NS(MkBufferListC_Merge)          , METH_NOARGS             , Merge_doc },
 
  // doc-key: MkBufferListC,MkBufferList,oCx
  { "Dup"            , (PyCFunction) NS(MkBufferListC_Dup)            , METH_NOARGS             , Dup_doc },
 
  // doc-key: MkBufferListC,MkBufferList,oc_
  { "AppendLA"       , (PyCFunction) NS(MkBufferListC_AppendLA)       , METH_VARARGS            , AppendLA_doc },
  { "AppendLP"       , (PyCFunction) NS(MkBufferListC_AppendLP)       , METH_VARARGS            , AppendLP_doc },
  { "IndexGetBUF"    , (PyCFunction) NS(MkBufferListC_IndexGetBUF)    , METH_O                  , IndexGetBUF_doc },
  { "Next"           , (PyCFunction) NS(MkBufferListC_Next)           , METH_NOARGS             , Next_doc },
  { "PositionMerge"  , (PyCFunction) NS(MkBufferListC_PositionMerge)  , METH_VARARGS            , PositionMerge_doc },
  { "Prev"           , (PyCFunction) NS(MkBufferListC_Prev)           , METH_NOARGS             , Prev_doc },
  { "Reset"          , (PyCFunction) NS(MkBufferListC_Reset)          , METH_NOARGS             , Reset_doc },
  { "Sort"           , (PyCFunction) NS(MkBufferListC_Sort)           , METH_NOARGS             , Sort_doc },
  { "ToBuffer"       , (PyCFunction) NS(MkBufferListC_ToBuffer)       , METH_NOARGS             , ToBuffer_doc },
 
  // doc-key: MkBufferListC,MkBufferList,oco
  { "CheckOptionBUF" , (PyCFunction) NS(MkBufferListC_CheckOptionBUF) , METH_VARARGS            , CheckOptionBUF_doc },
  { "IndexExtract"   , (PyCFunction) NS(MkBufferListC_IndexExtract)   , METH_VARARGS            , IndexExtract_doc },
  { "IndexGet"       , (PyCFunction) NS(MkBufferListC_IndexGet)       , METH_O                  , IndexGet_doc },
 
  // doc-key: MkBufferListC,MkBufferList,om_
  { "AppendBIN"      , (PyCFunction) NS(MkBufferListC_AppendBIN)      , METH_O                  , AppendBIN_doc },
  { "AppendBOL"      , (PyCFunction) NS(MkBufferListC_AppendBOL)      , METH_O                  , AppendBOL_doc },
  { "AppendBUF"      , (PyCFunction) NS(MkBufferListC_AppendBUF)      , METH_O                  , AppendBUF_doc },
  { "AppendDBL"      , (PyCFunction) NS(MkBufferListC_AppendDBL)      , METH_O                  , AppendDBL_doc },
  { "AppendFLT"      , (PyCFunction) NS(MkBufferListC_AppendFLT)      , METH_O                  , AppendFLT_doc },
  { "AppendG"        , (PyCFunction) NS(MkBufferListC_AppendG)        , METH_O                  , AppendG_doc },
  { "AppendI16"      , (PyCFunction) NS(MkBufferListC_AppendI16)      , METH_O                  , AppendI16_doc },
  { "AppendI32"      , (PyCFunction) NS(MkBufferListC_AppendI32)      , METH_O                  , AppendI32_doc },
  { "AppendI64"      , (PyCFunction) NS(MkBufferListC_AppendI64)      , METH_O                  , AppendI64_doc },
  { "AppendI8"       , (PyCFunction) NS(MkBufferListC_AppendI8)       , METH_O                  , AppendI8_doc },
  { "AppendSTR"      , (PyCFunction) NS(MkBufferListC_AppendSTR)      , METH_O                  , AppendSTR_doc },
  { "AppendStringR"  , (PyCFunction) NS(MkBufferListC_AppendStringR)  , METH_O                  , AppendStringR_doc },
  { "AppendUP"       , (PyCFunction) NS(MkBufferListC_AppendUP)       , METH_VARARGS            , AppendUP_doc },
  { "CheckOption"    , (PyCFunction) NS(MkBufferListC_CheckOption)    , METH_VARARGS            , CheckOption_doc },
  { "Cmp"            , (PyCFunction) NS(MkBufferListC_Cmp)            , METH_O                  , Cmp_doc },
  { "Copy"           , (PyCFunction) NS(MkBufferListC_Copy)           , METH_O                  , Copy_doc },
  // skip class-overload: MkBufferListHandleGet → HandleGet, NS(MkBufferListC_HandleGet)
  { "IndexDelete"    , (PyCFunction) NS(MkBufferListC_IndexDelete)    , METH_VARARGS            , IndexDelete_doc },
  { "IndexGetSTR"    , (PyCFunction) NS(MkBufferListC_IndexGetSTR)    , METH_O                  , IndexGetSTR_doc },
  { "IndexSet"       , (PyCFunction) NS(MkBufferListC_IndexSet)       , METH_VARARGS            , IndexSet_doc },
  { "IndexSetBUF"    , (PyCFunction) NS(MkBufferListC_IndexSetBUF)    , METH_VARARGS            , IndexSetBUF_doc },
  { "IndexSetSTR"    , (PyCFunction) NS(MkBufferListC_IndexSetSTR)    , METH_VARARGS            , IndexSetSTR_doc },
  // skip class-overload: MkBufferListLog → Log, NS(MkBufferListC_Log)
  { "LogS"           , (PyCFunction) NS(MkBufferListC_LogS)           , METH_VARARGS            , LogS_doc },
  { "LogSS"          , (PyCFunction) NS(MkBufferListC_LogSS)          , METH_VARARGS            , LogSS_doc },
  { "LogSSS"         , (PyCFunction) NS(MkBufferListC_LogSSS)         , METH_VARARGS            , LogSSS_doc },
  { "Move"           , (PyCFunction) NS(MkBufferListC_Move)           , METH_O                  , Move_doc },
  { "Reserve"        , (PyCFunction) NS(MkBufferListC_Reserve)        , METH_O                  , Reserve_doc },
  { "SearchC"        , (PyCFunction) NS(MkBufferListC_SearchC)        , METH_VARARGS            , SearchC_doc },
  { "Size"           , (PyCFunction) NS(MkBufferListC_Size)           , METH_NOARGS             , Size_doc },
  { "ToList"         , (PyCFunction) NS(MkBufferListC_ToList)         , METH_NOARGS             , ToList_doc },
  // skip class-overload: MkBufferListToString → ToString, NS(MkBufferListC_ToString)
 
  // doc-key: MkBufferListC,MkBufferList,omo
  { "CheckOptionBOL" , (PyCFunction) NS(MkBufferListC_CheckOptionBOL) , METH_VARARGS            , CheckOptionBOL_doc },
  { "CheckOptionDBL" , (PyCFunction) NS(MkBufferListC_CheckOptionDBL) , METH_VARARGS            , CheckOptionDBL_doc },
  { "CheckOptionFLT" , (PyCFunction) NS(MkBufferListC_CheckOptionFLT) , METH_VARARGS            , CheckOptionFLT_doc },
  { "CheckOptionI16" , (PyCFunction) NS(MkBufferListC_CheckOptionI16) , METH_VARARGS            , CheckOptionI16_doc },
  { "CheckOptionI32" , (PyCFunction) NS(MkBufferListC_CheckOptionI32) , METH_VARARGS            , CheckOptionI32_doc },
  { "CheckOptionI64" , (PyCFunction) NS(MkBufferListC_CheckOptionI64) , METH_VARARGS            , CheckOptionI64_doc },
  { "CheckOptionI8"  , (PyCFunction) NS(MkBufferListC_CheckOptionI8)  , METH_VARARGS            , CheckOptionI8_doc },
  { "CheckOptionSTR" , (PyCFunction) NS(MkBufferListC_CheckOptionSTR) , METH_VARARGS            , CheckOptionSTR_doc },
 
  // END-OBJ - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
    {NULL, NULL, 0, NULL}        /* Sentinel */
};
 
static PyObject* NS(sMkBufferListC_Str) (MkBufferListC_Obj *self) {
  MkRtSetup_X(self->hdl);
  return STRN2VAL(MkSysPrintF("MkBufferListC%s", self->hdl ? MkBufferListToString(self->hdl) : NULL));
}
 
#define MkBufferListC_DOC       "libmqmsgque MkBufferListC object"
 
OT_CLASS_TYPE_REF NS(MkBufferListCR) = {
  PyVarObject_HEAD_INIT(NULL, 0)
  .tp_name        = "pymkkernel.MkBufferListC",
  .tp_doc         = "PyMkKernel MkBufferListC Type",
  .tp_basicsize   = sizeof(MkBufferListC_Obj),
  .tp_itemsize    = 0,
  .tp_new         = NS(MkBufferListC_new),
  .tp_methods     = NS(MkBufferListC_Methods),
  .tp_flags       = Py_TPFLAGS_DEFAULT,
  .tp_base        = NULL,
  .tp_str         = (reprfunc)    NS(sMkBufferListC_Str)
};
 
 
int NS(pMkBufferListC_Init) ( MK_RT_ARGS PyObject* m)
{
 
  ClassInit
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap