MkBufferStreamC_py.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define META_FILE_NAME              "MkBufferStreamC_py.c"
 
#include "LibMkKernel_private_py.h"
 
// PY class
#define OT_CLASS                    (&NS(MkBufferStreamCR))
#define OT_CLASS_NAME               "MkBufferStreamC"
 
#define OT_LNG2META(O)              MkBus(VAL2MNG(O))
 
#define OT_retObj_CONSTR(mng)       OT_retObj_SET(NS(MkBufferStreamC_CTOR)(MK_RT_CALL (PyTypeObject*)class,mng))
 
#define OT_SETUP_hdl                OT_SETUP_hdl_tmpl(MkBufferStreamC)
#define OT_SETUP_hdl__null_allow    OT_SETUP_hdl_tmpl__null_allow(MkBufferStreamC)
#define OT_SETUP_hdl_constr         MK_RT_UNUSED AllRtSetup_NULL; \
                                    MK_BUS hdl = (MK_BUS) OT_CLASS;
#define OT_SETUP_hdl_destr          OT_SETUP_hdl_tmpl__null_allow(MkBufferStreamC)
#define OT_SETUP_hdl_static         MK_RT_UNUSED AllRtSetup_NULL; \
                                    __attribute__((unused)) MK_TYP hdl = MkBufferStreamC##_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 MkBufferStreamCTT
#define MkBufferStreamCTT MK(MkKernelThreadState).MkBufferStreamCTT
/* MkBufferStreamC_MK_NULL defined in LibMkKernel_py.h */
 
__attribute__((unused)) mk_inline
OT_OBJ_T NS(MkBufferStreamC_CTOR) (MK_RT_ARGS OT_CLS_T type, MK_BUS hdl) {
  return MK(AtomCreate)(MK_RT_CALL type,MkBufferStreamC_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(MkBufferStreamC_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(MkBufferStreamC_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(MkBufferStreamC_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 (MkBufferStreamCTT == NULL) MkBufferStreamCTT = MkBufferStreamSTT; \
  \
  /* protect against double call */ \
  if (MkBufferStreamCTT->selfCreate == NS(MkBufferStreamC_selfCreate)) return MK_OK; \
  \
  /* add "selfCreate" and "selfDelete" feature to the META-Class */ \
  MkBufferStreamCTT->selfCreate    = NS(MkBufferStreamC_selfCreate); \
  MkBufferStreamCTT->selfDelete    = NS(MkBufferStreamC_selfDelete); \
  MkBufferStreamCTT->selfUnlink    = NS(MkBufferStreamC_selfUnlink); \
  \
  if (!PyType_HasFeature(OT_CLASS,Py_TPFLAGS_READY)) { \
    NS(MkBufferStreamCR).tp_base = MkBufferStreamC_base; \
    OtErrorCheckLng (PyType_Ready(OT_CLASS)); \
  } \
  OtErrorCheckLng(PyModule_AddObjectRef(m, "MkBufferStreamC", (PyObject *)OT_CLASS)); \
  \
  /* define the "NULL" object */ \
  MkBufferStreamC_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: MkBufferStreamC,MkBufferStream,sCc,func
#define Create_doc "MkBufferStreamC MkBufferStreamC.Create(?size:int32=0?)"
#define Create1024_doc "MkBufferStreamC MkBufferStreamC.Create1024(?size:int32=0?)"
#define Create16384_doc "MkBufferStreamC MkBufferStreamC.Create16384(?size:int32=0?)"
#define Create256_doc "MkBufferStreamC MkBufferStreamC.Create256(?size:int32=0?)"
#define Create64_doc "MkBufferStreamC MkBufferStreamC.Create64(?size:int32=0?)"
#define new_doc "MkBufferStreamC MkBufferStreamC.new(?size:int32=0?)"
 
// doc-key: MkBufferStreamC,MkBufferStream,sc_,func
#define CreateTLS_doc "MkBufferStreamC MkBufferStreamC.CreateTLS(tlsName:string, ?resetB:bool=true?)"
#define GetNull_doc "MkBufferStreamC MkBufferStreamC.GetNull()"
#define HandleResolve_doc "MkBufferStreamC MkBufferStreamC.HandleResolve(netHdl:MK_HDL)"
#define Instances_doc "MkBufferStreamC MkBufferStreamC.Instances()"
 
// doc-key: MkBufferStreamC,MkBufferStream,oC_,func
#define Merge_doc "MkBufferStreamC bus.Merge()"
 
// doc-key: MkBufferStreamC,MkBufferStream,oCx,func
#define Dup_doc "MkBufferStreamC src.Dup() (const)"
 
// doc-key: MkBufferStreamC,MkBufferStream,oc_,func
#define Copy_doc "MkBufferStreamC bus.Copy(src:MkBufferStreamC) (const)"
#define Next_doc "MkBufferStreamC bus.Next()"
#define Prev_doc "MkBufferStreamC bus.Prev()"
#define Reset_doc "MkBufferStreamC bus.Reset()"
#define ToBFL_doc "MkBufferListC bus.ToBFL() (const)"
 
// doc-key: MkBufferStreamC,MkBufferStream,oci,func
#define ReadALL_doc "MkBufferListC bus.ReadALL(?val_inout:MkBufferListC=None?)"
 
// doc-key: MkBufferStreamC,MkBufferStream,oco,func
#define ReadBFL_doc "MkBufferListC bus.ReadBFL()"
#define ReadBUF_doc "MkBufferC bus.ReadBUF()"
 
// doc-key: MkBufferStreamC,MkBufferStream,om_,func
// skip class-overload: HandleGet → MkObjectHandleGet
// skip class-overload: Log → MkObjectLog
#define PosToStart_doc "bus.PosToStart()"
#define ReadGetNextType_doc "MkTypeE bus.ReadGetNextType() (const)"
#define ReadGetNumItems_doc "int32 bus.ReadGetNumItems() (const)"
#define ReadItemExists_doc "bool bus.ReadItemExists() (const)"
#define ReadL_END_doc "bus.ReadL_END()"
#define ReadL_START_doc "bus.ReadL_START(?buf:MkBufferC=None?)"
#define ReadUndo_doc "bus.ReadUndo()"
#define ResetFull_doc "bus.ResetFull()"
// skip class-overload: ToString → MkObjectToString
#define WriteBFL_doc "bus.WriteBFL(bfl:MkBufferListC)"
#define WriteBIN_doc "bus.WriteBIN(val:binary)"
#define WriteBOL_doc "bus.WriteBOL(val:bool)"
#define WriteBUF_doc "bus.WriteBUF(val:MkBufferC)"
#define WriteBUS_FLAT_doc "bus.WriteBUS_FLAT(add:MkBufferStreamC)"
#define WriteDBL_doc "bus.WriteDBL(val:double)"
#define WriteFLT_doc "bus.WriteFLT(val:float)"
#define WriteHDL_doc "bus.WriteHDL(val:int32)"
#define WriteI32_doc "bus.WriteI32(val:int32)"
#define WriteI64_doc "bus.WriteI64(val:int64)"
#define WriteI8_doc "bus.WriteI8(val:int8)"
#define WriteLONG_doc "bus.WriteLONG(val:long)"
#define WriteL_END_doc "bus.WriteL_END()"
#define WriteL_FLAT_doc "bus.WriteL_FLAT(bfl:MkBufferListC)"
#define WriteL_START_doc "bus.WriteL_START()"
#define WriteSTR_doc "bus.WriteSTR(val:string, ?len:int32=-1?)"
 
// doc-key: MkBufferStreamC,MkBufferStream,omo,func
#define ReadBIN_doc "binary bus.ReadBIN()"
#define ReadBOL_doc "bool bus.ReadBOL()"
#define ReadDBL_doc "double bus.ReadDBL()"
#define ReadFLT_doc "float bus.ReadFLT()"
#define ReadI32_doc "int32 bus.ReadI32()"
#define ReadI64_doc "int64 bus.ReadI64()"
#define ReadI8_doc "int8 bus.ReadI8()"
#define ReadLONG_doc "long bus.ReadLONG()"
#define ReadSTR_doc "string bus.ReadSTR()"
 
// END-DOC - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// ---------------------------------------------------------------------------------------
 
 
// ---------------------------------------------------------------------------------------
 
// BEGIN-MkBufferStreamC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Export,sc_
 
static OT_ProcRet NS(MkBufferStreamC_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_BUS retVal = MkBufferStreamHandleResolve (netHdl);
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Export,om_
 
// skip on class-overload: MkBufferStreamHandleGet → MkObjectHandleGet
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferStreamC_HandleGet) (MkBufferStreamC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferStreamC_Class_PY_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Introspection,oc_
 
static OT_ProcRet NS(MkBufferStreamC_Next) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Next_doc);
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamNext (hdl);
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_Prev) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Prev_doc);
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamPrev (hdl);
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Introspection,sc_
 
static OT_ProcRet NS(MkBufferStreamC_Instances) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(Instances_doc);
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamInstances ();
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferStreamC_Class_PY_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Class-Misc,sc_
 
static OT_ProcRet NS(MkBufferStreamC_GetNull) (OtClass_ARGS) {
  OT_SETUP_hdl_static;
  OT_SETUP_NOARG(GetNull_doc);
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamGetNull ();
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferStreamC_Class_PY_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Misc,oc_
 
static OT_ProcRet NS(MkBufferStreamC_Copy) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(Copy_doc);
  MK_BUSN src = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUSN (src,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamCopy (hdl, src);
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_Reset) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Reset_doc);
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamReset (hdl);
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ToBFL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ToBFL_doc);
  OT_CHECK_NOARGS;
  MK_BFL retVal = MkBufferStreamToBFL (hdl);
  OT_retObj_SET_BFL(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Misc,om_
 
// skip on class-overload: MkBufferStreamLog → MkObjectLog
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferStreamC_Log) (MkBufferStreamC_ARGS) {OT_ERROR_LNG_RETURN;}
 
static OT_ProcRet NS(MkBufferStreamC_PosToStart) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(PosToStart_doc);
  OT_CHECK_NOARGS;
  MkBufferStreamPosToStart (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ResetFull) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ResetFull_doc);
  OT_CHECK_NOARGS;
  MkBufferStreamResetFull (hdl);
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// skip on class-overload: MkBufferStreamToString → MkObjectToString
MK_DEPRECATED MK_UNUSED
static OT_ProcRet NS(MkBufferStreamC_ToString) (MkBufferStreamC_ARGS) {OT_ERROR_LNG_RETURN;}
 
// MkBufferStreamC_Misc_PY_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Read,oci
 
static OT_ProcRet NS(MkBufferStreamC_ReadALL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,ReadALL_doc);
  MkBufferListCreateTLS_T(val_inout,10);
  OT_CHECK_OPTIONAL(OT_CHECK_BFL (val_inout,MK_NULL_YES))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamReadALL (hdl, &val_inout));
  OT_retObj_SET_BFL(val_inout);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Read,oco
 
static OT_ProcRet NS(MkBufferStreamC_ReadBFL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBFL_doc);
  OT_CHECK_NOARGS;
  MK_BFL val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadBFL (hdl, &val_out));
  OT_retObj_SET_BFL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadBUF) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBUF_doc);
  OT_CHECK_NOARGS;
  MK_BUF val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadBUF (hdl, &val_out));
  OT_retObj_SET_BUF(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Read,om_
 
static OT_ProcRet NS(MkBufferStreamC_ReadGetNextType) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadGetNextType_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET(OT_NEW_Mk_enum_OBJ(TypeE,MkBufferStreamReadGetNextType (hdl)));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadGetNumItems) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadGetNumItems_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_I32(MkBufferStreamReadGetNumItems (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadItemExists) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadItemExists_doc);
  OT_CHECK_NOARGS;
  OT_retObj_SET_BOL(MkBufferStreamReadItemExists (hdl));
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadL_END) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadL_END_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamReadL_END (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadL_START) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(0,1,ReadL_START_doc);
  MK_BUF buf = NULL;
  OT_CHECK_OPTIONAL(OT_CHECK_BUF (buf,MK_NULL_YES))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamReadL_START (hdl, buf));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadUndo) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadUndo_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamReadUndo (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Read,omo
 
static OT_ProcRet NS(MkBufferStreamC_ReadBIN) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBIN_doc);
  OT_CHECK_NOARGS;
  MkBinaryR val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadBIN (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(MkBufferStreamC_ReadBOL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadBOL_doc);
  OT_CHECK_NOARGS;
  MK_BOL val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadBOL (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(MkBufferStreamC_ReadDBL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadDBL_doc);
  OT_CHECK_NOARGS;
  MK_DBL val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadDBL (hdl, &val_out));
  OT_retObj_SET_DBL(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadFLT) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadFLT_doc);
  OT_CHECK_NOARGS;
  MK_FLT val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadFLT (hdl, &val_out));
  OT_retObj_SET_FLT(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadI32) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadI32_doc);
  OT_CHECK_NOARGS;
  MK_I32 val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadI32 (hdl, &val_out));
  OT_retObj_SET_I32(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadI64) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadI64_doc);
  OT_CHECK_NOARGS;
  MK_I64 val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadI64 (hdl, &val_out));
  OT_retObj_SET_I64(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadI8) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadI8_doc);
  OT_CHECK_NOARGS;
  MK_I8 val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadI8 (hdl, &val_out));
  OT_retObj_SET_I8(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadLONG) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadLONG_doc);
  OT_CHECK_NOARGS;
  MK_LONG val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadLONG (hdl, &val_out));
  OT_retObj_SET_LONG(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_ReadSTR) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(ReadSTR_doc);
  OT_CHECK_NOARGS;
  MK_STRN val_out;
  MkErrorC_Check(hdl,MkBufferStreamReadSTR (hdl, &val_out));
  OT_retObj_SET_STR(val_out);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferStreamC_Read_PY_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-TOR,oC_
 
static OT_ProcRet NS(MkBufferStreamC_Merge) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Merge_doc);
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamMerge (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferStreamC);
    goto error;
  }
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-TOR,oCx
 
static OT_ProcRet NS(MkBufferStreamC_Dup) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(Dup_doc);
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamDup (hdl);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferStreamC);
    goto error;
  }
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-TOR,sCc
 
static OT_ProcRet NS(MkBufferStreamC_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_BUS retVal = MkBufferStreamCreate (NULL, size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferStreamC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_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_BUS retVal = MkBufferStreamCreate1024 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferStreamC);
    goto error;
  }
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_Create16384) (OtClass_ARGS) {
  OT_SETUP_hdl_static_constr;
  OT_SETUP_VARARGS(0,1,Create16384_doc);
  MK_NUM size = 0;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (size))
  OT_CHECK_NOARGS;
  MK_BUS retVal = MkBufferStreamCreate16384 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferStreamC);
    goto error;
  }
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_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_BUS retVal = MkBufferStreamCreate256 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferStreamC);
    goto error;
  }
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_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_BUS retVal = MkBufferStreamCreate64 (size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferStreamC);
    goto error;
  }
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_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_BUS retVal = MkBufferStreamCreate (NULL, size);
  if (retVal == NULL) {
    OT_ERROR_CONSTRUCTOR(MkBufferStreamC);
    goto error;
  }
  OT_CONSTRUCTOR_POST(retVal)
  OT_retObj_CONSTR(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// doc-key: MkBufferStreamC,MkBufferStreamC-TOR,sc_
 
static OT_ProcRet NS(MkBufferStreamC_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_BUS retVal = MkBufferStreamCreateTLS (tlsName, resetB);
  OT_retObj_SET_BUS(retVal);
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferStreamC_TOR_PY_API
 
 
// doc-key: MkBufferStreamC,MkBufferStreamC-Write,om_
 
static OT_ProcRet NS(MkBufferStreamC_WriteBFL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteBFL_doc);
  MkBufferListCreateTLS_T(bfl,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFLN (bfl,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteBFL (hdl, bfl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteBIN) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteBIN_doc);
  MkBinaryR val = {0};
  OT_CHECK_REQUIRED(OT_CHECK__ME_REF_MkBinaryR(val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteBIN (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteBOL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteBOL_doc);
  MK_BOL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NB1 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteBOL (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(MkBufferStreamC_WriteBUF) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteBUF_doc);
  MK_BUFN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUFN (val,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteBUF (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteBUS_FLAT) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteBUS_FLAT_doc);
  MK_BUSN add = 0;
  OT_CHECK_REQUIRED(OT_CHECK_BUSN (add,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteBUS_FLAT (hdl, add));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteDBL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteDBL_doc);
  MK_DBL val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF8 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteDBL (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteFLT) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteFLT_doc);
  MK_FLT val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NF4 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteFLT (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteHDL) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteHDL_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteHDL (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteI32) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteI32_doc);
  MK_I32 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI4 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteI32 (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteI64) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteI64_doc);
  MK_I64 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI8 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteI64 (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteI8) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteI8_doc);
  MK_I8 val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NI1 (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteI8 (hdl, (MK_I8)(val)));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteLONG) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteLONG_doc);
  MK_LONG val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_NIL (val))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteLONG (hdl, val));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteL_END) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(WriteL_END_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteL_END (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteL_FLAT) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_ONEARG(WriteL_FLAT_doc);
  MkBufferListCreateTLS_T(bfl,10);
  OT_CHECK_REQUIRED(OT_CHECK_BFL (bfl,MK_NULL_NO))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteL_FLAT (hdl, bfl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteL_START) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_NOARG(WriteL_START_doc);
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteL_START (hdl));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
static OT_ProcRet NS(MkBufferStreamC_WriteSTR) (MkBufferStreamC_ARGS) {
  OT_SETUP_hdl;
  OT_SETUP_VARARGS(1,2,WriteSTR_doc);
  MK_STRN val = 0;
  OT_CHECK_REQUIRED(OT_CHECK_STRN (val))
  MK_NUM len = -1;
  OT_CHECK_OPTIONAL(OT_CHECK_NI4 (len))
  OT_CHECK_NOARGS;
  MkErrorC_Check(hdl,MkBufferStreamWriteSTR (hdl, val, len));
  OT_retObj_SET_None;
  goto end;
  error:
  OT_retObj_SET_Error;
  end:
  OT_retObj_RETURN;
}
 
// MkBufferStreamC_Write_PY_API
 
// END-MkBufferStreamC - created by 'py_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
static PyMethodDef MkBufferStreamC_Methods[] = {
 
  // BEGIN-CLASS - created by 'py_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkBufferStreamC,MkBufferStream,sCc
  { "Create"          , (PyCFunction) NS(MkBufferStreamC_Create)          , METH_VARARGS|METH_CLASS , Create_doc },
  { "Create1024"      , (PyCFunction) NS(MkBufferStreamC_Create1024)      , METH_VARARGS|METH_CLASS , Create1024_doc },
  { "Create16384"     , (PyCFunction) NS(MkBufferStreamC_Create16384)     , METH_VARARGS|METH_CLASS , Create16384_doc },
  { "Create256"       , (PyCFunction) NS(MkBufferStreamC_Create256)       , METH_VARARGS|METH_CLASS , Create256_doc },
  { "Create64"        , (PyCFunction) NS(MkBufferStreamC_Create64)        , METH_VARARGS|METH_CLASS , Create64_doc },
 
  // doc-key: MkBufferStreamC,MkBufferStream,sc_
  { "CreateTLS"       , (PyCFunction) NS(MkBufferStreamC_CreateTLS)       , METH_VARARGS|METH_CLASS , CreateTLS_doc },
  { "GetNull"         , (PyCFunction) NS(MkBufferStreamC_GetNull)         , METH_NOARGS|METH_CLASS  , GetNull_doc },
  { "HandleResolve"   , (PyCFunction) NS(MkBufferStreamC_HandleResolve)   , METH_O|METH_CLASS       , HandleResolve_doc },
  { "Instances"       , (PyCFunction) NS(MkBufferStreamC_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: MkBufferStreamC,MkBufferStream,oC_
  { "Merge"           , (PyCFunction) NS(MkBufferStreamC_Merge)           , METH_NOARGS             , Merge_doc },
 
  // doc-key: MkBufferStreamC,MkBufferStream,oCx
  { "Dup"             , (PyCFunction) NS(MkBufferStreamC_Dup)             , METH_NOARGS             , Dup_doc },
 
  // doc-key: MkBufferStreamC,MkBufferStream,oc_
  { "Copy"            , (PyCFunction) NS(MkBufferStreamC_Copy)            , METH_O                  , Copy_doc },
  { "Next"            , (PyCFunction) NS(MkBufferStreamC_Next)            , METH_NOARGS             , Next_doc },
  { "Prev"            , (PyCFunction) NS(MkBufferStreamC_Prev)            , METH_NOARGS             , Prev_doc },
  { "Reset"           , (PyCFunction) NS(MkBufferStreamC_Reset)           , METH_NOARGS             , Reset_doc },
  { "ToBFL"           , (PyCFunction) NS(MkBufferStreamC_ToBFL)           , METH_NOARGS             , ToBFL_doc },
 
  // doc-key: MkBufferStreamC,MkBufferStream,oci
  { "ReadALL"         , (PyCFunction) NS(MkBufferStreamC_ReadALL)         , METH_VARARGS            , ReadALL_doc },
 
  // doc-key: MkBufferStreamC,MkBufferStream,oco
  { "ReadBFL"         , (PyCFunction) NS(MkBufferStreamC_ReadBFL)         , METH_NOARGS             , ReadBFL_doc },
  { "ReadBUF"         , (PyCFunction) NS(MkBufferStreamC_ReadBUF)         , METH_NOARGS             , ReadBUF_doc },
 
  // doc-key: MkBufferStreamC,MkBufferStream,om_
  // skip class-overload: MkBufferStreamHandleGet → HandleGet, NS(MkBufferStreamC_HandleGet)
  // skip class-overload: MkBufferStreamLog → Log, NS(MkBufferStreamC_Log)
  { "PosToStart"      , (PyCFunction) NS(MkBufferStreamC_PosToStart)      , METH_NOARGS             , PosToStart_doc },
  { "ReadGetNextType" , (PyCFunction) NS(MkBufferStreamC_ReadGetNextType) , METH_NOARGS             , ReadGetNextType_doc },
  { "ReadGetNumItems" , (PyCFunction) NS(MkBufferStreamC_ReadGetNumItems) , METH_NOARGS             , ReadGetNumItems_doc },
  { "ReadItemExists"  , (PyCFunction) NS(MkBufferStreamC_ReadItemExists)  , METH_NOARGS             , ReadItemExists_doc },
  { "ReadL_END"       , (PyCFunction) NS(MkBufferStreamC_ReadL_END)       , METH_NOARGS             , ReadL_END_doc },
  { "ReadL_START"     , (PyCFunction) NS(MkBufferStreamC_ReadL_START)     , METH_VARARGS            , ReadL_START_doc },
  { "ReadUndo"        , (PyCFunction) NS(MkBufferStreamC_ReadUndo)        , METH_NOARGS             , ReadUndo_doc },
  { "ResetFull"       , (PyCFunction) NS(MkBufferStreamC_ResetFull)       , METH_NOARGS             , ResetFull_doc },
  // skip class-overload: MkBufferStreamToString → ToString, NS(MkBufferStreamC_ToString)
  { "WriteBFL"        , (PyCFunction) NS(MkBufferStreamC_WriteBFL)        , METH_O                  , WriteBFL_doc },
  { "WriteBIN"        , (PyCFunction) NS(MkBufferStreamC_WriteBIN)        , METH_O                  , WriteBIN_doc },
  { "WriteBOL"        , (PyCFunction) NS(MkBufferStreamC_WriteBOL)        , METH_O                  , WriteBOL_doc },
  { "WriteBUF"        , (PyCFunction) NS(MkBufferStreamC_WriteBUF)        , METH_O                  , WriteBUF_doc },
  { "WriteBUS_FLAT"   , (PyCFunction) NS(MkBufferStreamC_WriteBUS_FLAT)   , METH_O                  , WriteBUS_FLAT_doc },
  { "WriteDBL"        , (PyCFunction) NS(MkBufferStreamC_WriteDBL)        , METH_O                  , WriteDBL_doc },
  { "WriteFLT"        , (PyCFunction) NS(MkBufferStreamC_WriteFLT)        , METH_O                  , WriteFLT_doc },
  { "WriteHDL"        , (PyCFunction) NS(MkBufferStreamC_WriteHDL)        , METH_O                  , WriteHDL_doc },
  { "WriteI32"        , (PyCFunction) NS(MkBufferStreamC_WriteI32)        , METH_O                  , WriteI32_doc },
  { "WriteI64"        , (PyCFunction) NS(MkBufferStreamC_WriteI64)        , METH_O                  , WriteI64_doc },
  { "WriteI8"         , (PyCFunction) NS(MkBufferStreamC_WriteI8)         , METH_O                  , WriteI8_doc },
  { "WriteLONG"       , (PyCFunction) NS(MkBufferStreamC_WriteLONG)       , METH_O                  , WriteLONG_doc },
  { "WriteL_END"      , (PyCFunction) NS(MkBufferStreamC_WriteL_END)      , METH_NOARGS             , WriteL_END_doc },
  { "WriteL_FLAT"     , (PyCFunction) NS(MkBufferStreamC_WriteL_FLAT)     , METH_O                  , WriteL_FLAT_doc },
  { "WriteL_START"    , (PyCFunction) NS(MkBufferStreamC_WriteL_START)    , METH_NOARGS             , WriteL_START_doc },
  { "WriteSTR"        , (PyCFunction) NS(MkBufferStreamC_WriteSTR)        , METH_VARARGS            , WriteSTR_doc },
 
  // doc-key: MkBufferStreamC,MkBufferStream,omo
  { "ReadBIN"         , (PyCFunction) NS(MkBufferStreamC_ReadBIN)         , METH_NOARGS             , ReadBIN_doc },
  { "ReadBOL"         , (PyCFunction) NS(MkBufferStreamC_ReadBOL)         , METH_NOARGS             , ReadBOL_doc },
  { "ReadDBL"         , (PyCFunction) NS(MkBufferStreamC_ReadDBL)         , METH_NOARGS             , ReadDBL_doc },
  { "ReadFLT"         , (PyCFunction) NS(MkBufferStreamC_ReadFLT)         , METH_NOARGS             , ReadFLT_doc },
  { "ReadI32"         , (PyCFunction) NS(MkBufferStreamC_ReadI32)         , METH_NOARGS             , ReadI32_doc },
  { "ReadI64"         , (PyCFunction) NS(MkBufferStreamC_ReadI64)         , METH_NOARGS             , ReadI64_doc },
  { "ReadI8"          , (PyCFunction) NS(MkBufferStreamC_ReadI8)          , METH_NOARGS             , ReadI8_doc },
  { "ReadLONG"        , (PyCFunction) NS(MkBufferStreamC_ReadLONG)        , METH_NOARGS             , ReadLONG_doc },
  { "ReadSTR"         , (PyCFunction) NS(MkBufferStreamC_ReadSTR)         , METH_NOARGS             , ReadSTR_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(MkBufferStreamCR) = {
  PyVarObject_HEAD_INIT(NULL, 0)
  .tp_name        = "pymkkernel.MkBufferStreamC",
  .tp_doc         = "PyMkKernel MkBufferStreamC Type",
  .tp_basicsize   = sizeof(MkBufferStreamC_Obj),
  .tp_itemsize    = 0,
  .tp_new         = NS(MkBufferStreamC_new),
  .tp_flags       = Py_TPFLAGS_DEFAULT,
  .tp_methods     = MkBufferStreamC_Methods,
  .tp_base        = NULL
};
 
 
int NS(pMkBufferStreamC_Init) ( MK_RT_ARGS PyObject* m)
{
  ClassInit
 
  MkBufferStream16384C_TT->selfCreate   =  NS(MkBufferStreamC_selfCreate)  ;
  MkBufferStream16384C_TT->selfDelete   =  NS(MkBufferStreamC_selfDelete)  ;
  MkBufferStream16384C_TT->selfUnlink   =  NS(MkBufferStreamC_selfUnlink)  ;
  MkBufferStream256C_TT->selfCreate     =  NS(MkBufferStreamC_selfCreate)  ;
  MkBufferStream256C_TT->selfDelete     =  NS(MkBufferStreamC_selfDelete)  ;
  MkBufferStream256C_TT->selfUnlink     =  NS(MkBufferStreamC_selfUnlink)  ;
  MkBufferStream64C_TT->selfCreate      =  NS(MkBufferStreamC_selfCreate)  ;
  MkBufferStream64C_TT->selfDelete      =  NS(MkBufferStreamC_selfDelete)  ;
  MkBufferStream64C_TT->selfUnlink      =  NS(MkBufferStreamC_selfUnlink)  ;
  MkBufferStream1024C_TT->selfCreate    =  NS(MkBufferStreamC_selfCreate)  ;
  MkBufferStream1024C_TT->selfDelete    =  NS(MkBufferStreamC_selfDelete)  ;
  MkBufferStream1024C_TT->selfUnlink    =  NS(MkBufferStreamC_selfUnlink)  ;
 
  return 0;
error:
  return -1;
}
 
// vim: nowrap