MkBufferC_py.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME              "MkBufferC_py.c"
 
#include "LibMkKernel_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(MkBufferCR))
#define OT_CLASS_NAME               "MkBufferC"
 
#define OT_LNG2META(O)              MkBuf(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(MkBufferC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MkBufferC)
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(MkBufferC)
#define OT_SETUP_hdl_constr         MK_RT_UNUSED AllRtSetup_NULL; \
                                    MK_BUF hdl = (MK_BUF) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MkBufferC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MkBufferC##_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 MkBufferCTT
#define MkBufferCTT MK(MkKernelThreadState).MkBufferCTT
/* MkBufferC_MK_NULL defined in LibMkKernel_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(MkBufferC_CTOR) (MK_RT_ARGS OT_CLS_T type, MK_BUF hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,MkBufferC_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(MkBufferC_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(MkBufferC_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(MkBufferC_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 (MkBufferCTT == NULL) MkBufferCTT = MkBufferSTT; \
  \
  /* protect against double call */ \
  if (MkBufferCTT->selfCreate == NS(MkBufferC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MkBufferCTT->selfCreate    = NS(MkBufferC_selfCreate); \
  MkBufferCTT->selfDelete    = NS(MkBufferC_selfDelete); \
  MkBufferCTT->selfUnlink    = NS(MkBufferC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MkBufferCR).tp_base = MkBufferC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MkBufferC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MkBufferC_MK_NULL = Py_NewRef(MK(AtomCreate) (MK_RT_CALL OT_CLASS, NULL /*obj*/));
 
/* LABEL-END */
 
#define META_CONTEXT_S        MK_ERROR_DEFAULT
 
 
// BEGIN-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferC,MkBuffer,sCc,func
#define Create_doc "MkBufferC MkBufferC.Create(?size:int32=0?)"
#define Create1024_doc "MkBufferC MkBufferC.Create1024(?size:int32=0?)"
#define Create256_doc "MkBufferC MkBufferC.Create256(?size:int32=0?)"
#define Create64_doc "MkBufferC MkBufferC.Create64(?size:int32=0?)"
#define CreateBIN_doc "MkBufferC MkBufferC.CreateBIN(val:binary)"
#define CreateBOL_doc "MkBufferC MkBufferC.CreateBOL(val:bool)"
#define CreateBUF_doc "MkBufferC MkBufferC.CreateBUF(val:MkBufferC)"
#define CreateDBL_doc "MkBufferC MkBufferC.CreateDBL(val:double)"
#define CreateFLT_doc "MkBufferC MkBufferC.CreateFLT(val:float)"
#define CreateI16_doc "MkBufferC MkBufferC.CreateI16(val:int16)"
#define CreateI32_doc "MkBufferC MkBufferC.CreateI32(val:int32)"
#define CreateI64_doc "MkBufferC MkBufferC.CreateI64(val:int64)"
#define CreateI8_doc "MkBufferC MkBufferC.CreateI8(val:int8)"
#define CreateSTR_doc "MkBufferC MkBufferC.CreateSTR(val:string)"
#define new_doc "MkBufferC MkBufferC.new(?size:int32=0?)"
 
// doc-key: MkBufferC,MkBuffer,sc_,func
#define CreateTLS_doc "MkBufferC MkBufferC.CreateTLS(tlsName:string, ?resetB:bool=true?)"
#define GetNull_doc "MkBufferC MkBufferC.GetNull()"
#define HandleResolve_doc "MkBufferC MkBufferC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "MkBufferC MkBufferC.Instances()"
 
// doc-key: MkBufferC,MkBuffer,oC_,func
#define Merge_doc "MkBufferC buf.Merge()"
 
// doc-key: MkBufferC,MkBuffer,oCx,func
#define Dup_doc "MkBufferC buf.Dup() (const)"
 
// doc-key: MkBufferC,MkBuffer,oc_,func
#define AppendC_doc "MkBufferC buf.AppendC(val:string)"
#define AppendStringR_doc "MkBufferC buf.AppendStringR(val:string)"
#define Copy_doc "MkBufferC buf.Copy(srce:MkBufferC) (const)"
#define Next_doc "MkBufferC buf.Next()"
#define Prev_doc "MkBufferC buf.Prev()"
#define Reset_doc "MkBufferC buf.Reset()"
#define SetBIN_doc "MkBufferC buf.SetBIN(val:binary)"
#define SetBOL_doc "MkBufferC buf.SetBOL(val:bool)"
#define SetBUF_doc "MkBufferC buf.SetBUF(val:MkBufferC)"
#define SetBinaryR_doc "MkBufferC buf.SetBinaryR(val:binary)"
#define SetDBL_doc "MkBufferC buf.SetDBL(val:double)"
#define SetFLT_doc "MkBufferC buf.SetFLT(val:float)"
#define SetI16_doc "MkBufferC buf.SetI16(val:int16)"
#define SetI32_doc "MkBufferC buf.SetI32(val:int32)"
#define SetI64_doc "MkBufferC buf.SetI64(val:int64)"
#define SetI8_doc "MkBufferC buf.SetI8(val:int8)"
#define SetSTR_doc "MkBufferC buf.SetSTR(val:string)"
#define SetStringR_doc "MkBufferC buf.SetStringR(val:string)"
#define SizeAdd_doc "MkBufferC buf.SizeAdd(size:int32)"
#define SizeNew_doc "MkBufferC buf.SizeNew(size:int32)"
#define Temp_doc "MkBufferC buf.Temp() (const)"
 
// doc-key: MkBufferC,MkBuffer,oci,func
#define GetBFL_doc "MkBufferListC buf.GetBFL(?val_inout:MkBufferListC=None?) (const)"
 
// doc-key: MkBufferC,MkBuffer,oco,func
#define GetBUF_doc "MkBufferC buf.GetBUF()"
 
// doc-key: MkBufferC,MkBuffer,om_,func
#define CastTo_doc "buf.CastTo(typ:MkTypeE)"
#define Cmp_doc "int32 buf1.Cmp(buf2:MkBufferC) (const)"
#define GetType1_doc "string[1] buf.GetType1() (const)"
#define GetType2_doc "MkTypeE buf.GetType2() (const)"
#define GetType3_doc "string buf.GetType3() (const)"
// skip class-overload: HandleGet → MkObjectHandleGet
#define IsLocal_doc "bool buf.IsLocal() (const)"
// skip class-overload: Log → MkObjectLog
#define LogS_doc "buf.LogS(?varname:string=\"buf\"?, ?fmtobj:MkObjectC=None?, ?callfunc:string=\"MK_NULL\"?) (const)"
#define Pop_doc "int32 buf.Pop(val:string)"
#define Push_doc "int32 buf.Push(val:string)"
#define ResetFull_doc "buf.ResetFull()"
// skip class-overload: ToString → MkObjectToString
 
// doc-key: MkBufferC,MkBuffer,omo,func
#define GetBIN_doc "binary buf.GetBIN() (const)"
#define GetBOL_doc "bool buf.GetBOL() (const)"
#define GetDBL_doc "double buf.GetDBL() (const)"
#define GetFLT_doc "float buf.GetFLT() (const)"
#define GetI16_doc "int16 buf.GetI16() (const)"
#define GetI32_doc "int32 buf.GetI32() (const)"
#define GetI64_doc "int64 buf.GetI64() (const)"
#define GetI8_doc "int8 buf.GetI8() (const)"
#define GetSTR_doc "string buf.GetSTR() (const)"
#define GetStringR_doc "string buf.GetStringR() (const)"
#define ToObject_doc "obj buf.ToObject()"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
 
OT_ProcRet NS(MkBufferC_ToObject) (MkBufferC_ARGS);
#include "tmpl/MkBufferC_ToObject_lng.h"
 
// ---------------------------------------------------------------------------------------
 
// BEGIN-MkBufferC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkBufferC,MkBufferC-Access,oc_
 
static OT_ProcRet NS(MkBufferC_AppendC) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendC_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferAppendC (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_AppendStringR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(AppendStringR_doc);
  MkStringR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkStringR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferAppendStringR (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Access,om_
 
static OT_ProcRet NS(MkBufferC_Pop) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Pop_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferPop (hdl, val));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Push) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Push_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferPush (hdl, val));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Access,omo
 
OT_ProcRet NS(MkBufferC_ToObject) (MkBufferC_ARGS) ; // skip template-required
 
// MkBufferC_Access_PY_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Export,sc_
 
static OT_ProcRet NS(MkBufferC_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_BUF retVal = MkBufferHandleResolve (netHdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Class-Export,om_
 
// skip on class-overload: MkBufferHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferC_HandleGet) (MkBufferC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferC_Class_PY_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Introspection,oc_
 
static OT_ProcRet NS(MkBufferC_Next) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferNext (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Prev) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferPrev (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Class-Introspection,sc_
 
static OT_ProcRet NS(MkBufferC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferInstances ();
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_Class_PY_API
 
 
// doc-key: MkBufferC,MkBufferC-Class-Misc,sc_
 
static OT_ProcRet NS(MkBufferC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferGetNull ();
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_Class_PY_API
 
 
// doc-key: MkBufferC,MkBufferC-Get,oci
 
OT_ProcRet NS(MkBufferC_GetBFL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,GetBFL_doc);
  MkBufferListCreateTLS_T(val_inout,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BFL (val_inout,MK_NULL_YES))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferGetBFL (hdl, &val_inout));
  OT_retObj_SET_BFL(val_inout);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Get,oco
 
static OT_ProcRet NS(MkBufferC_GetBUF) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetBUF_doc);
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferGetBUF (hdl, &val_out));
  OT_retObj_SET_BUF(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Get,omo
 
static OT_ProcRet NS(MkBufferC_GetBIN) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetBIN_doc);
  OT_CHECK_NOARGS;
  MkBinaryR val_out;
  MkErrorC_Check(hdl,MkBufferGetBIN (hdl, &val_out));
  MkBinaryR retVal = val_out;
  OT_retObj_SET(OT_GET__ME_REF_MkBinaryR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetBOL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetBOL_doc);
  OT_CHECK_NOARGS;
  MK_BOL val_out;
  MkErrorC_Check(hdl,MkBufferGetBOL (hdl, &val_out));
  OT_retObj_SET_BOL(val_out == 1);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetDBL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetDBL_doc);
  OT_CHECK_NOARGS;
  MK_DBL val_out;
  MkErrorC_Check(hdl,MkBufferGetDBL (hdl, &val_out));
  OT_retObj_SET_DBL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetFLT) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetFLT_doc);
  OT_CHECK_NOARGS;
  MK_FLT val_out;
  MkErrorC_Check(hdl,MkBufferGetFLT (hdl, &val_out));
  OT_retObj_SET_FLT(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetI16) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetI16_doc);
  OT_CHECK_NOARGS;
  MK_I16 val_out;
  MkErrorC_Check(hdl,MkBufferGetI16 (hdl, &val_out));
  OT_retObj_SET_I16(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetI32) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetI32_doc);
  OT_CHECK_NOARGS;
  MK_I32 val_out;
  MkErrorC_Check(hdl,MkBufferGetI32 (hdl, &val_out));
  OT_retObj_SET_I32(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetI64) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetI64_doc);
  OT_CHECK_NOARGS;
  MK_I64 val_out;
  MkErrorC_Check(hdl,MkBufferGetI64 (hdl, &val_out));
  OT_retObj_SET_I64(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetI8) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetI8_doc);
  OT_CHECK_NOARGS;
  MK_I8 val_out;
  MkErrorC_Check(hdl,MkBufferGetI8 (hdl, &val_out));
  OT_retObj_SET_I8(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetSTR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetSTR_doc);
  OT_CHECK_NOARGS;
  MK_STRN val_out;
  MkErrorC_Check(hdl,MkBufferGetSTR (hdl, &val_out));
  OT_retObj_SET_STR(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetStringR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetStringR_doc);
  OT_CHECK_NOARGS;
  MkStringR val_out;
  MkErrorC_Check(hdl,MkBufferGetStringR (hdl, &val_out));
  MkStringR retVal = val_out;
  OT_retObj_SET(OT_GET__ME_REF_MkStringR(retVal));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_Get_PY_API
 
 
// doc-key: MkBufferC,MkBufferC-Info,om_
 
static OT_ProcRet NS(MkBufferC_GetType1) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetType1_doc);
  OT_CHECK_NOARGS;
  char ret_str[2] = {MkBufferGetType1 (hdl), '\0'};
  OT_retObj_SET_STR(ret_str);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetType2) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetType2_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(TypeE,MkBufferGetType2 (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_GetType3) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(GetType3_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_STR(MkBufferGetType3 (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_IsLocal) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(IsLocal_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkBufferIsLocal (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// skip on class-overload: MkBufferLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferC_Log) (MkBufferC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(MkBufferC_LogS) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,3,LogS_doc);
  MK_STRN varname = "buf";
  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;}
  MkBufferLogS (hdl, varname, fmtobj, callfunc);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_FRAME_CLEANUP;
  OT_retObj_RETURN;
}
 
// MkBufferC_Info_PY_API
 
 
// doc-key: MkBufferC,MkBufferC-Misc,oc_
 
static OT_ProcRet NS(MkBufferC_Copy) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Copy_doc);
  MK_BUFN srce = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (srce,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCopy (hdl, srce);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Reset) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Reset_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferReset (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SizeAdd) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SizeAdd_doc);
  MK_NUM size = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSizeAdd (hdl, size);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SizeNew) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SizeNew_doc);
  MK_NUM size = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSizeNew (hdl, size);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
OT_ProcRet NS(MkBufferC_Temp) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Temp_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferTemp (hdl);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-Misc,om_
 
static OT_ProcRet NS(MkBufferC_CastTo) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(CastTo_doc);
  enum MkTypeE typ = 0;
  OT_CHECK_REQUIRED(OT_CHECK_ENUM (MkTypeE,typ))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferCastTo (hdl, typ));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Cmp) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Cmp_doc);
  MK_BUFN buf2 = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (buf2,MK_NULL_NO))
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferCmp (hdl, buf2));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_ResetFull) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ResetFull_doc);
  OT_CHECK_NOARGS;
  MkBufferResetFull (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// skip on class-overload: MkBufferToString → MkObjectToString
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferC_ToString) (MkBufferC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferC_Misc_PY_API
 
 
// doc-key: MkBufferC,MkBufferC-Set,oc_
 
static OT_ProcRet NS(MkBufferC_SetBIN) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetBIN_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetBIN (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetBOL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetBOL_doc);
  MK_BOL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NB1 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetBOL (hdl, (MK_BOL)(val?1:0));
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetBUF) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetBUF_doc);
  MK_BUFN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetBUF (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetBinaryR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetBinaryR_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetBinaryR (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetDBL) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetDBL_doc);
  MK_DBL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF8 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetDBL (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetFLT) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetFLT_doc);
  MK_FLT val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF4 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetFLT (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetI16) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetI16_doc);
  MK_I16 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetI16 (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetI32) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetI32_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetI32 (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetI64) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetI64_doc);
  MK_I64 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI8 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetI64 (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetI8) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetI8_doc);
  MK_I8 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI1 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetI8 (hdl, (MK_I8)(val));
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetSTR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetSTR_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetSTR (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_SetStringR) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(SetStringR_doc);
  MkStringR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkStringR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferSetStringR (hdl, val);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_Set_PY_API
 
 
// doc-key: MkBufferC,MkBufferC-TOR,oC_
 
static OT_ProcRet NS(MkBufferC_Merge) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Merge_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferMerge (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,oCx
 
static OT_ProcRet NS(MkBufferC_Dup) (MkBufferC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Dup_doc);
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferDup (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,sCc
 
static OT_ProcRet NS(MkBufferC_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_BUF retVal = MkBufferCreate (NULL, size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Create1024) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create1024_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreate1024 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Create256) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create256_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreate256 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_Create64) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create64_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreate64 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateBIN) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateBIN_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateBIN (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateBOL) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateBOL_doc);
  MK_BOL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NB1 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateBOL ((MK_BOL)(val?1:0));
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateBUF) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateBUF_doc);
  MK_BUFN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateBUF (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateDBL) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateDBL_doc);
  MK_DBL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF8 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateDBL (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateFLT) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateFLT_doc);
  MK_FLT val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF4 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateFLT (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateI16) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateI16_doc);
  MK_I16 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI2 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateI16 (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateI32) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateI32_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateI32 (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateI64) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateI64_doc);
  MK_I64 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI8 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateI64 (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateI8) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateI8_doc);
  MK_I8 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI1 (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateI8 ((MK_I8)(val));
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_CreateSTR) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_ONEARG(CreateSTR_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  OT_CHECK_NOARGS;
  MK_BUF retVal = MkBufferCreateSTR (val);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferC_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_BUF retVal = MkBufferCreate (NULL, size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferC,MkBufferC-TOR,sc_
 
static OT_ProcRet NS(MkBufferC_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_BUF retVal = MkBufferCreateTLS (tlsName, resetB);
  OT_retObj_SET_BUF(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferC_TOR_PY_API
 
// END-MkBufferC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// vim: Marker(t)
 
static PyMethodDef MkBufferC_Methods[] = {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkBufferC,MkBuffer,sCc
  { "Create"        , (PyCFunction) NS(MkBufferC_Create)        , METH_VARARGS|METH_CLASS , Create_doc },
  { "Create1024"    , (PyCFunction) NS(MkBufferC_Create1024)    , METH_VARARGS|METH_CLASS , Create1024_doc },
  { "Create256"     , (PyCFunction) NS(MkBufferC_Create256)     , METH_VARARGS|METH_CLASS , Create256_doc },
  { "Create64"      , (PyCFunction) NS(MkBufferC_Create64)      , METH_VARARGS|METH_CLASS , Create64_doc },
  { "CreateBIN"     , (PyCFunction) NS(MkBufferC_CreateBIN)     , METH_O|METH_CLASS       , CreateBIN_doc },
  { "CreateBOL"     , (PyCFunction) NS(MkBufferC_CreateBOL)     , METH_O|METH_CLASS       , CreateBOL_doc },
  { "CreateBUF"     , (PyCFunction) NS(MkBufferC_CreateBUF)     , METH_O|METH_CLASS       , CreateBUF_doc },
  { "CreateDBL"     , (PyCFunction) NS(MkBufferC_CreateDBL)     , METH_O|METH_CLASS       , CreateDBL_doc },
  { "CreateFLT"     , (PyCFunction) NS(MkBufferC_CreateFLT)     , METH_O|METH_CLASS       , CreateFLT_doc },
  { "CreateI16"     , (PyCFunction) NS(MkBufferC_CreateI16)     , METH_O|METH_CLASS       , CreateI16_doc },
  { "CreateI32"     , (PyCFunction) NS(MkBufferC_CreateI32)     , METH_O|METH_CLASS       , CreateI32_doc },
  { "CreateI64"     , (PyCFunction) NS(MkBufferC_CreateI64)     , METH_O|METH_CLASS       , CreateI64_doc },
  { "CreateI8"      , (PyCFunction) NS(MkBufferC_CreateI8)      , METH_O|METH_CLASS       , CreateI8_doc },
  { "CreateSTR"     , (PyCFunction) NS(MkBufferC_CreateSTR)     , METH_O|METH_CLASS       , CreateSTR_doc },
 
  // doc-key: MkBufferC,MkBuffer,sc_
  { "CreateTLS"     , (PyCFunction) NS(MkBufferC_CreateTLS)     , METH_VARARGS|METH_CLASS , CreateTLS_doc },
  { "GetNull"       , (PyCFunction) NS(MkBufferC_GetNull)       , METH_NOARGS|METH_CLASS  , GetNull_doc },
  { "HandleResolve" , (PyCFunction) NS(MkBufferC_HandleResolve) , METH_O|METH_CLASS       , HandleResolve_doc },
  { "Instances"     , (PyCFunction) NS(MkBufferC_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: MkBufferC,MkBuffer,oC_
  { "Merge"         , (PyCFunction) NS(MkBufferC_Merge)         , METH_NOARGS             , Merge_doc },
 
  // doc-key: MkBufferC,MkBuffer,oCx
  { "Dup"           , (PyCFunction) NS(MkBufferC_Dup)           , METH_NOARGS             , Dup_doc },
 
  // doc-key: MkBufferC,MkBuffer,oc_
  { "AppendC"       , (PyCFunction) NS(MkBufferC_AppendC)       , METH_O                  , AppendC_doc },
  { "AppendStringR" , (PyCFunction) NS(MkBufferC_AppendStringR) , METH_O                  , AppendStringR_doc },
  { "Copy"          , (PyCFunction) NS(MkBufferC_Copy)          , METH_O                  , Copy_doc },
  { "Next"          , (PyCFunction) NS(MkBufferC_Next)          , METH_NOARGS             , Next_doc },
  { "Prev"          , (PyCFunction) NS(MkBufferC_Prev)          , METH_NOARGS             , Prev_doc },
  { "Reset"         , (PyCFunction) NS(MkBufferC_Reset)         , METH_NOARGS             , Reset_doc },
  { "SetBIN"        , (PyCFunction) NS(MkBufferC_SetBIN)        , METH_O                  , SetBIN_doc },
  { "SetBOL"        , (PyCFunction) NS(MkBufferC_SetBOL)        , METH_O                  , SetBOL_doc },
  { "SetBUF"        , (PyCFunction) NS(MkBufferC_SetBUF)        , METH_O                  , SetBUF_doc },
  { "SetBinaryR"    , (PyCFunction) NS(MkBufferC_SetBinaryR)    , METH_O                  , SetBinaryR_doc },
  { "SetDBL"        , (PyCFunction) NS(MkBufferC_SetDBL)        , METH_O                  , SetDBL_doc },
  { "SetFLT"        , (PyCFunction) NS(MkBufferC_SetFLT)        , METH_O                  , SetFLT_doc },
  { "SetI16"        , (PyCFunction) NS(MkBufferC_SetI16)        , METH_O                  , SetI16_doc },
  { "SetI32"        , (PyCFunction) NS(MkBufferC_SetI32)        , METH_O                  , SetI32_doc },
  { "SetI64"        , (PyCFunction) NS(MkBufferC_SetI64)        , METH_O                  , SetI64_doc },
  { "SetI8"         , (PyCFunction) NS(MkBufferC_SetI8)         , METH_O                  , SetI8_doc },
  { "SetSTR"        , (PyCFunction) NS(MkBufferC_SetSTR)        , METH_O                  , SetSTR_doc },
  { "SetStringR"    , (PyCFunction) NS(MkBufferC_SetStringR)    , METH_O                  , SetStringR_doc },
  { "SizeAdd"       , (PyCFunction) NS(MkBufferC_SizeAdd)       , METH_O                  , SizeAdd_doc },
  { "SizeNew"       , (PyCFunction) NS(MkBufferC_SizeNew)       , METH_O                  , SizeNew_doc },
  { "Temp"          , (PyCFunction) NS(MkBufferC_Temp)          , METH_NOARGS             , Temp_doc },
 
  // doc-key: MkBufferC,MkBuffer,oci
  { "GetBFL"        , (PyCFunction) NS(MkBufferC_GetBFL)        , METH_VARARGS            , GetBFL_doc },
 
  // doc-key: MkBufferC,MkBuffer,oco
  { "GetBUF"        , (PyCFunction) NS(MkBufferC_GetBUF)        , METH_NOARGS             , GetBUF_doc },
 
  // doc-key: MkBufferC,MkBuffer,om_
  { "CastTo"        , (PyCFunction) NS(MkBufferC_CastTo)        , METH_O                  , CastTo_doc },
  { "Cmp"           , (PyCFunction) NS(MkBufferC_Cmp)           , METH_O                  , Cmp_doc },
  { "GetType1"      , (PyCFunction) NS(MkBufferC_GetType1)      , METH_NOARGS             , GetType1_doc },
  { "GetType2"      , (PyCFunction) NS(MkBufferC_GetType2)      , METH_NOARGS             , GetType2_doc },
  { "GetType3"      , (PyCFunction) NS(MkBufferC_GetType3)      , METH_NOARGS             , GetType3_doc },
  // skip class-overload: MkBufferHandleGet → HandleGet, NS(MkBufferC_HandleGet)
  { "IsLocal"       , (PyCFunction) NS(MkBufferC_IsLocal)       , METH_NOARGS             , IsLocal_doc },
  // skip class-overload: MkBufferLog → Log, NS(MkBufferC_Log)
  { "LogS"          , (PyCFunction) NS(MkBufferC_LogS)          , METH_VARARGS            , LogS_doc },
  { "Pop"           , (PyCFunction) NS(MkBufferC_Pop)           , METH_O                  , Pop_doc },
  { "Push"          , (PyCFunction) NS(MkBufferC_Push)          , METH_O                  , Push_doc },
  { "ResetFull"     , (PyCFunction) NS(MkBufferC_ResetFull)     , METH_NOARGS             , ResetFull_doc },
  // skip class-overload: MkBufferToString → ToString, NS(MkBufferC_ToString)
 
  // doc-key: MkBufferC,MkBuffer,omo
  { "GetBIN"        , (PyCFunction) NS(MkBufferC_GetBIN)        , METH_NOARGS             , GetBIN_doc },
  { "GetBOL"        , (PyCFunction) NS(MkBufferC_GetBOL)        , METH_NOARGS             , GetBOL_doc },
  { "GetDBL"        , (PyCFunction) NS(MkBufferC_GetDBL)        , METH_NOARGS             , GetDBL_doc },
  { "GetFLT"        , (PyCFunction) NS(MkBufferC_GetFLT)        , METH_NOARGS             , GetFLT_doc },
  { "GetI16"        , (PyCFunction) NS(MkBufferC_GetI16)        , METH_NOARGS             , GetI16_doc },
  { "GetI32"        , (PyCFunction) NS(MkBufferC_GetI32)        , METH_NOARGS             , GetI32_doc },
  { "GetI64"        , (PyCFunction) NS(MkBufferC_GetI64)        , METH_NOARGS             , GetI64_doc },
  { "GetI8"         , (PyCFunction) NS(MkBufferC_GetI8)         , METH_NOARGS             , GetI8_doc },
  { "GetSTR"        , (PyCFunction) NS(MkBufferC_GetSTR)        , METH_NOARGS             , GetSTR_doc },
  { "GetStringR"    , (PyCFunction) NS(MkBufferC_GetStringR)    , METH_NOARGS             , GetStringR_doc },
  { "ToObject"      , (PyCFunction) NS(MkBufferC_ToObject)      , METH_NOARGS             , ToObject_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 */
};
 
 
OT_CLASS_TYPE_REF NS(MkBufferCR) = {
  PyVarObject_HEAD_INIT(NULL, 0)
  .tp_name        = "pymkkernel.MkBufferC",
  .tp_doc         = "PyMkKernel MkBufferC Type",
  .tp_basicsize   = sizeof(MkBufferC_Obj),
  .tp_itemsize    = 0,
  .tp_new         = NS(MkBufferC_new),
  .tp_flags       = Py_TPFLAGS_DEFAULT,
  .tp_methods     = MkBufferC_Methods,
  .tp_base        = NULL
};
 
int NS(pMkBufferC_Init) ( MK_RT_ARGS PyObject* m)
{
  ClassInit
 
  MkBuffer64C_TT->selfCreate    =  NS(MkBufferC_selfCreate)  ;
  MkBuffer64C_TT->selfDelete    =  NS(MkBufferC_selfDelete)  ;
  MkBuffer64C_TT->selfUnlink    =  NS(MkBufferC_selfUnlink)  ;
 
  MkBuffer256C_TT->selfCreate   =  NS(MkBufferC_selfCreate)  ;
  MkBuffer256C_TT->selfDelete   =  NS(MkBufferC_selfDelete)  ;
  MkBuffer256C_TT->selfUnlink   =  NS(MkBufferC_selfUnlink)  ;
 
  MkBuffer1024C_TT->selfCreate  =  NS(MkBufferC_selfCreate)  ;
  MkBuffer1024C_TT->selfDelete  =  NS(MkBufferC_selfDelete)  ;
  MkBuffer1024C_TT->selfUnlink  =  NS(MkBufferC_selfUnlink)  ;
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap