MkBufferStreamC_atl.c

Go to the documentation of this file.

 
/* LABEL-START */
 
#define   META_FILE_NAME      "MkBufferStreamC_atl.c"
 
#include  "LibMkKernel_private_atl.h"
 
#define   OT_CLASS            amkrt->AtlMkBufferStreamC
#define   OT_NULL             amkrt->AtlMkBufferStreamC_MK_NULL
#define   OT_CLASS_NAME       "MkBufferStreamC"
 
#define   SELF2HDL(O)         MkBus(VAL2MNG(O))
 
// LNG: class
// -> moved to LibMkKernel_atl.h → OT_MK_RT_S → AtlMkKernelCTT;
 
// META: ObjNew feature: called to return a new or an already existing ATL-SELF-Object
// -> moved to LibMkKernel_atl.h → MkKernelC_ObjNew
 
// 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) {
  SETUP_amkrt(env);
  return AtomMake(obj,OT_CLASS,NULL,NULL,env);
}
 
// 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 selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amkrt(env);
  MK(AtomDeleteHard) (OT_MK_CALL selfO);
}
 
// META: called to destroy link from SELF to META
static void NS(MkBufferStreamC_selfUnlink) (MK_RT_ARGS MK_PTR selfP, MK_PTR const env) {
  OT_SELF_T selfO = selfP;
  SETUP_amkrt(env);
  return MK(AtomUnlink) (OT_MK_CALL selfO);
}
 
#define OT_SETUP_hdl                  SetupHdlFromMetaData_2(MK_BUS)
#define OT_SETUP_hdl__null_allow      SetupHdlFromMetaData__null_allow_2(MK_BUS)
#define OT_SETUP_hdl_destr            SetupHdlFromMetaData__null_allow_2(MK_BUS)
#define OT_SETUP_hdl_constr           SetupHdlConstr(MkBufferStreamC)
#define OT_SETUP_hdl_static_constr    OT_SETUP_hdl_static
#define OT_SETUP_hdl_static           SetupHdlStatic(MkBufferStreamC)
 
#define OT_retObj_CONSTR(x)           OT_retObj_SET(AtomInit(OT_SELF,MkBufferStreamC_X2obj(x),amkrt))
 
// initialize the ATL and META 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); \
 \
  /* create the ATL-class */ \
  OT_CLASS = AltClassDef(MkBufferStreamCTT,&amkrt->AtlMkBufferStreamC_NS); \
    if (OT_CLASS == NULL) goto error; \
    OT_REF_INCR(OT_CLASS); \
 \
  /* create the ATL static Methods */ \
  check_LNG(AtlUnknownSetup (NS(sOtClassDef),amkrt)) goto error; \
 \
  /* create the ATL instance Methods */ \
  check_LNG(AtlUnknownSetup (NS(sInstanceDef),amkrt)) goto error; \
 \
  /* after class was modified, recompile the class */ \
  RL_init(2, recompile, RL_T(0,RecompileN)); RL_O(1,OT_CLASS) ; \
    int retI = RL_EvalEx(0); \
      if (retI != TCL_OK) return retI; \
 \
  /* define the "NULL" object */ \
  OT_NULL = AtomCreateNULL(OT_CLASS, "::MkBufferStreamC::MK_NULL", (MK_PTR)amkrt); \
    if (OT_NULL == NULL) goto error; \
    OT_REF_INCR(OT_NULL);
/* LABEL-END */
 
// BEGIN-DOC - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
// doc-key: MkBufferStreamC,MkBufferStream,sCc,func
#define CTOR_doc "MkBufferStreamC [MkBufferStreamC::CTOR ?size:int32=0?]"
#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?]"
 
// 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 [MkBufferStreamC::Merge $bus]"
 
// doc-key: MkBufferStreamC,MkBufferStream,oCx,func
#define Dup_doc "MkBufferStreamC [MkBufferStreamC::Dup $src] (const)"
 
// doc-key: MkBufferStreamC,MkBufferStream,oc_,func
#define Copy_doc "MkBufferStreamC [MkBufferStreamC::Copy $bus src:MkBufferStreamC] (const)"
#define Next_doc "MkBufferStreamC [MkBufferStreamC::Next $bus]"
#define Prev_doc "MkBufferStreamC [MkBufferStreamC::Prev $bus]"
#define Reset_doc "MkBufferStreamC [MkBufferStreamC::Reset $bus]"
#define ToBFL_doc "MkBufferListC [MkBufferStreamC::ToBFL $bus] (const)"
 
// doc-key: MkBufferStreamC,MkBufferStream,oci,func
#define ReadALL_doc "MkBufferListC [MkBufferStreamC::ReadALL $bus ?val_inout:MkBufferListC=NULL?]"
 
// doc-key: MkBufferStreamC,MkBufferStream,oco,func
#define ReadBFL_doc "MkBufferListC [MkBufferStreamC::ReadBFL $bus]"
#define ReadBUF_doc "MkBufferC [MkBufferStreamC::ReadBUF $bus]"
 
// doc-key: MkBufferStreamC,MkBufferStream,om_,func
// skip class-overload: HandleGet → MkObjectHandleGet
// skip class-overload: Log → MkObjectLog
#define PosToStart_doc "MkBufferStreamC::PosToStart $bus"
#define ReadGetNextType_doc "MkTypeE [MkBufferStreamC::ReadGetNextType $bus] (const)"
#define ReadGetNumItems_doc "int32 [MkBufferStreamC::ReadGetNumItems $bus] (const)"
#define ReadItemExists_doc "bool [MkBufferStreamC::ReadItemExists $bus] (const)"
#define ReadL_END_doc "MkBufferStreamC::ReadL_END $bus"
#define ReadL_START_doc "MkBufferStreamC::ReadL_START $bus ?buf:MkBufferC=NULL?"
#define ReadUndo_doc "MkBufferStreamC::ReadUndo $bus"
#define ResetFull_doc "MkBufferStreamC::ResetFull $bus"
// skip class-overload: ToString → MkObjectToString
#define WriteBFL_doc "MkBufferStreamC::WriteBFL $bus bfl:MkBufferListC"
#define WriteBIN_doc "MkBufferStreamC::WriteBIN $bus val:binary"
#define WriteBOL_doc "MkBufferStreamC::WriteBOL $bus val:bool"
#define WriteBUF_doc "MkBufferStreamC::WriteBUF $bus val:MkBufferC"
#define WriteBUS_FLAT_doc "MkBufferStreamC::WriteBUS_FLAT $bus add:MkBufferStreamC"
#define WriteDBL_doc "MkBufferStreamC::WriteDBL $bus val:double"
#define WriteFLT_doc "MkBufferStreamC::WriteFLT $bus val:float"
#define WriteHDL_doc "MkBufferStreamC::WriteHDL $bus val:int32"
#define WriteI32_doc "MkBufferStreamC::WriteI32 $bus val:int32"
#define WriteI64_doc "MkBufferStreamC::WriteI64 $bus val:int64"
#define WriteI8_doc "MkBufferStreamC::WriteI8 $bus val:int8"
#define WriteLONG_doc "MkBufferStreamC::WriteLONG $bus val:long"
#define WriteL_END_doc "MkBufferStreamC::WriteL_END $bus"
#define WriteL_FLAT_doc "MkBufferStreamC::WriteL_FLAT $bus bfl:MkBufferListC"
#define WriteL_START_doc "MkBufferStreamC::WriteL_START $bus"
#define WriteSTR_doc "MkBufferStreamC::WriteSTR $bus val:string ?len:int32=-1?"
 
// doc-key: MkBufferStreamC,MkBufferStream,omo,func
#define ReadBIN_doc "binary [MkBufferStreamC::ReadBIN $bus]"
#define ReadBOL_doc "bool [MkBufferStreamC::ReadBOL $bus]"
#define ReadDBL_doc "double [MkBufferStreamC::ReadDBL $bus]"
#define ReadFLT_doc "float [MkBufferStreamC::ReadFLT $bus]"
#define ReadI32_doc "int32 [MkBufferStreamC::ReadI32 $bus]"
#define ReadI64_doc "int64 [MkBufferStreamC::ReadI64 $bus]"
#define ReadI8_doc "int8 [MkBufferStreamC::ReadI8 $bus]"
#define ReadLONG_doc "long [MkBufferStreamC::ReadLONG $bus]"
#define ReadSTR_doc "string [MkBufferStreamC::ReadSTR $bus]"
 
// END-DOC - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
/*****************************************************************************/
/*                                                                           */
/*                        O B J E C T                                        */
/*                                                                           */
/*****************************************************************************/
 
// BEGIN-MkBufferStreamC - created by 'atl_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_ATL_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_ATL_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_ATL_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_ATL_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_ATL_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_CTOR) (CONSTR_ARGS) {
  OT_SETUP_hdl_constr;
  OT_SETUP_CONSTRUCTOR_ARGS(0,1,CTOR_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;
}
 
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;
}
 
// 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_ATL_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_ATL_API
 
// END-MkBufferStreamC - created by 'atl_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
static const OtObjProcDefS NS(sOtClassDef)[] = {
 
  // BEGIN-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkBufferStreamC,MkBufferStream,sCc
  { "::MkBufferStreamC::Create"          , NS(MkBufferStreamC_Create)          },
  { "::MkBufferStreamC::Create1024"      , NS(MkBufferStreamC_Create1024)      },
  { "::MkBufferStreamC::Create16384"     , NS(MkBufferStreamC_Create16384)     },
  { "::MkBufferStreamC::Create256"       , NS(MkBufferStreamC_Create256)       },
  { "::MkBufferStreamC::Create64"        , NS(MkBufferStreamC_Create64)        },
 
  // doc-key: MkBufferStreamC,MkBufferStream,sc_
  { "::MkBufferStreamC::CreateTLS"       , NS(MkBufferStreamC_CreateTLS)       },
  { "::MkBufferStreamC::GetNull"         , NS(MkBufferStreamC_GetNull)         },
  { "::MkBufferStreamC::HandleResolve"   , NS(MkBufferStreamC_HandleResolve)   },
  { "::MkBufferStreamC::Instances"       , NS(MkBufferStreamC_Instances)       },
 
  // END-CLASS - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
// ---------------------------------------------------------------------------------------
 
static const OtObjProcDefS NS(sInstanceDef)[] = {
 
  // BEGIN-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
  // doc-key: MkBufferStreamC,MkBufferStream,oC_
  { "::MkBufferStreamC::MkBufferStreamC" , NS(MkBufferStreamC_CTOR)            },
  { "::MkBufferStreamC::Merge"           , NS(MkBufferStreamC_Merge)           },
 
  // doc-key: MkBufferStreamC,MkBufferStream,oCx
  { "::MkBufferStreamC::Dup"             , NS(MkBufferStreamC_Dup)             },
 
  // doc-key: MkBufferStreamC,MkBufferStream,oc_
  { "::MkBufferStreamC::Copy"            , NS(MkBufferStreamC_Copy)            },
  { "::MkBufferStreamC::Next"            , NS(MkBufferStreamC_Next)            },
  { "::MkBufferStreamC::Prev"            , NS(MkBufferStreamC_Prev)            },
  { "::MkBufferStreamC::Reset"           , NS(MkBufferStreamC_Reset)           },
  { "::MkBufferStreamC::ToBFL"           , NS(MkBufferStreamC_ToBFL)           },
 
  // doc-key: MkBufferStreamC,MkBufferStream,oci
  { "::MkBufferStreamC::ReadALL"         , NS(MkBufferStreamC_ReadALL)         },
 
  // doc-key: MkBufferStreamC,MkBufferStream,oco
  { "::MkBufferStreamC::ReadBFL"         , NS(MkBufferStreamC_ReadBFL)         },
  { "::MkBufferStreamC::ReadBUF"         , NS(MkBufferStreamC_ReadBUF)         },
 
  // doc-key: MkBufferStreamC,MkBufferStream,om_
  // skip class-overload: HandleGet → MkObjectHandleGet
  // skip class-overload: Log → MkObjectLog
  { "::MkBufferStreamC::PosToStart"      , NS(MkBufferStreamC_PosToStart)      },
  { "::MkBufferStreamC::ReadGetNextType" , NS(MkBufferStreamC_ReadGetNextType) },
  { "::MkBufferStreamC::ReadGetNumItems" , NS(MkBufferStreamC_ReadGetNumItems) },
  { "::MkBufferStreamC::ReadItemExists"  , NS(MkBufferStreamC_ReadItemExists)  },
  { "::MkBufferStreamC::ReadL_END"       , NS(MkBufferStreamC_ReadL_END)       },
  { "::MkBufferStreamC::ReadL_START"     , NS(MkBufferStreamC_ReadL_START)     },
  { "::MkBufferStreamC::ReadUndo"        , NS(MkBufferStreamC_ReadUndo)        },
  { "::MkBufferStreamC::ResetFull"       , NS(MkBufferStreamC_ResetFull)       },
  // skip class-overload: ToString → MkObjectToString
  { "::MkBufferStreamC::WriteBFL"        , NS(MkBufferStreamC_WriteBFL)        },
  { "::MkBufferStreamC::WriteBIN"        , NS(MkBufferStreamC_WriteBIN)        },
  { "::MkBufferStreamC::WriteBOL"        , NS(MkBufferStreamC_WriteBOL)        },
  { "::MkBufferStreamC::WriteBUF"        , NS(MkBufferStreamC_WriteBUF)        },
  { "::MkBufferStreamC::WriteBUS_FLAT"   , NS(MkBufferStreamC_WriteBUS_FLAT)   },
  { "::MkBufferStreamC::WriteDBL"        , NS(MkBufferStreamC_WriteDBL)        },
  { "::MkBufferStreamC::WriteFLT"        , NS(MkBufferStreamC_WriteFLT)        },
  { "::MkBufferStreamC::WriteHDL"        , NS(MkBufferStreamC_WriteHDL)        },
  { "::MkBufferStreamC::WriteI32"        , NS(MkBufferStreamC_WriteI32)        },
  { "::MkBufferStreamC::WriteI64"        , NS(MkBufferStreamC_WriteI64)        },
  { "::MkBufferStreamC::WriteI8"         , NS(MkBufferStreamC_WriteI8)         },
  { "::MkBufferStreamC::WriteLONG"       , NS(MkBufferStreamC_WriteLONG)       },
  { "::MkBufferStreamC::WriteL_END"      , NS(MkBufferStreamC_WriteL_END)      },
  { "::MkBufferStreamC::WriteL_FLAT"     , NS(MkBufferStreamC_WriteL_FLAT)     },
  { "::MkBufferStreamC::WriteL_START"    , NS(MkBufferStreamC_WriteL_START)    },
  { "::MkBufferStreamC::WriteSTR"        , NS(MkBufferStreamC_WriteSTR)        },
 
  // doc-key: MkBufferStreamC,MkBufferStream,omo
  { "::MkBufferStreamC::ReadBIN"         , NS(MkBufferStreamC_ReadBIN)         },
  { "::MkBufferStreamC::ReadBOL"         , NS(MkBufferStreamC_ReadBOL)         },
  { "::MkBufferStreamC::ReadDBL"         , NS(MkBufferStreamC_ReadDBL)         },
  { "::MkBufferStreamC::ReadFLT"         , NS(MkBufferStreamC_ReadFLT)         },
  { "::MkBufferStreamC::ReadI32"         , NS(MkBufferStreamC_ReadI32)         },
  { "::MkBufferStreamC::ReadI64"         , NS(MkBufferStreamC_ReadI64)         },
  { "::MkBufferStreamC::ReadI8"          , NS(MkBufferStreamC_ReadI8)          },
  { "::MkBufferStreamC::ReadLONG"        , NS(MkBufferStreamC_ReadLONG)        },
  { "::MkBufferStreamC::ReadSTR"         , NS(MkBufferStreamC_ReadSTR)         },
 
  // END-OBJ - created by 'atl_MqS.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
  { NULL }
};
 
 
int NS(pMkBufferStreamC_Init) ( OT_MK_ARGS OT_NS_T ns )
{
  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 TCL_OK;
error:
  return TCL_ERROR;
}