MkBufferStreamC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
/*****************************************************************************/
/*                                                                           */
/*                                context                                    */
/*                                                                           */
/*****************************************************************************/
 
namespace ccmkkernel {
 
  inline MK_PTR MkBufferStreamC::MkBufferStreamC_selfCreateTLS(MK_OBJ obj) {
    return new MkBufferStreamC(obj);
  }
 
  inline MK_PTR MkBufferStreamC::MkBufferStreamC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
    MK_BUS inst = reinterpret_cast<MK_BUS>(obj);
    return MkOBJ_R(inst).obj_protect.isLocal ? MkBufferStreamC_selfCreateTLS(obj) : new MkBufferStreamC(obj);
  }
 
  inline MkBufferStreamC::MkBufferStreamC (const MkBufferStreamC *copy) {
    if (copy == NULL) throw MkReferenceNullExceptionC("MkBufferStreamC");
    MkRtSetup_O(copy->hdl);
    MkObjectC::atomInit(MkObjDup(copy->hdl));
  }
 
  inline MkBufferStreamC::MkBufferStreamC (const MkBufferStreamC& copy) {
    MkRtSetup_O(copy.hdl);
    MkObjectC::atomInit(MkObjDup(copy.hdl));
  }
 
  inline MkBufferStreamC& MkBufferStreamC::operator= (const MkBufferStreamC& copy) {
    MkRtSetup_O(copy.hdl);
    MkObjCopy(hdl,copy.hdl);
    return *this;
  }
 
  inline MkBufferStreamC& MkBufferStreamC::operator= (const MkBufferStreamC* copy) {
    MkRtSetup_O(copy->hdl);
    MkObjCopy(hdl,copy->hdl);
    return *this;
  }
 
  //   BEGIN-MkBufferStreamC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Export,sc_
 
  inline MkBufferStreamC* MkBufferStreamC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamHandleResolve(netHdl);
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Export,om_
 
  // skip class-overload: HandleGet = MkBufferStreamHandleGet → MkObjectHandleGet
 
  // MkBufferStreamC_Class_CC_API
 
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Introspection,oc_
 
  inline MkBufferStreamC* MkBufferStreamC::Next ()  {
    MK_UNUSED auto bus = getBUS();
    MK_BUS __retVal__L = MkBufferStreamNext(bus);
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferStreamC* MkBufferStreamC::Prev ()  {
    MK_UNUSED auto bus = getBUS();
    MK_BUS __retVal__L = MkBufferStreamPrev(bus);
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Introspection,sc_
 
  inline MkBufferStreamC* MkBufferStreamC::Instances ()  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamInstances();
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferStreamC_Class_CC_API
 
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Class-Misc,sc_
 
  inline MkBufferStreamC* MkBufferStreamC::GetNull ()  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamGetNull();
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferStreamC_Class_CC_API
 
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Misc,oc_
 
  inline MkBufferStreamC* MkBufferStreamC::Copy (const MkBufferStreamC* src) const {
    MK_UNUSED auto bus = getBUS();
    MK_BUSN src_hdl = MkBufferStreamC::getBUSN(src);
    MK_BUS __retVal__L = MkBufferStreamCopy(bus, src_hdl);
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferStreamC* MkBufferStreamC::Copy (const MkBufferStreamC& src) const {
    MK_UNUSED auto bus = getBUS();
    const MK_BUSN src_hdl = MkBufferStreamC::getBUSN(src);
    MK_BUS __retVal__L = MkBufferStreamCopy(bus, src_hdl);
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferStreamC* MkBufferStreamC::Reset ()  {
    MK_UNUSED auto bus = getBUS();
    MK_BUS __retVal__L = MkBufferStreamReset(bus);
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* MkBufferStreamC::ToBFL () const {
    MK_UNUSED auto bus = getBUSN();
    MK_BFL __retVal__L = MkBufferStreamToBFL(bus);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Misc,om_
 
  // skip class-overload: Log = MkBufferStreamLog → MkObjectLog
 
  // skip class-overload: Log = MkBufferStreamLog → MkObjectLog
 
  inline void MkBufferStreamC::PosToStart ()  {
    MK_UNUSED auto bus = getBUS();
    MkBufferStreamPosToStart(bus);
  }
 
  inline void MkBufferStreamC::ResetFull ()  {
    MK_UNUSED auto bus = getBUS();
    MkBufferStreamResetFull(bus);
  }
 
  // skip class-overload: ToString = MkBufferStreamToString → MkObjectToString
 
  // MkBufferStreamC_Misc_CC_API
 
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Read,oci
 
  inline MkBufferListC* MkBufferStreamC::ReadALL (MkBufferListC* val_inout)  {
    MK_UNUSED auto bus = getBUS();
    MK_BFL val_inout_hdl = MkBufferListC::getBFL__null_allow(val_inout);
    enum MkErrorE errVal = MkBufferStreamReadALL(bus, &val_inout_hdl);
    MkErrorC_Check(bus, errVal);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL val_inout_hdl);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Read,oco
 
  inline MkBufferListC* MkBufferStreamC::ReadBFL ()  {
    MK_UNUSED auto bus = getBUS();
    MK_BFL val_out;
    enum MkErrorE errVal = MkBufferStreamReadBFL(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL val_out);
  }
 
  inline MkBufferC* MkBufferStreamC::ReadBUF ()  {
    MK_UNUSED auto bus = getBUS();
    MK_BUF val_out;
    enum MkErrorE errVal = MkBufferStreamReadBUF(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL val_out);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Read,om_
 
  inline MkTypeE MkBufferStreamC::ReadGetNextType () const {
    MK_UNUSED auto bus = getBUSN();
    enum MkTypeE __retVal__L = MkBufferStreamReadGetNextType(bus);
    return __retVal__L;
  }
 
  inline MK_NUM MkBufferStreamC::ReadGetNumItems () const {
    MK_UNUSED auto bus = getBUSN();
    MK_NUM __retVal__L = MkBufferStreamReadGetNumItems(bus);
    return __retVal__L;
  }
 
  inline MK_BOOL MkBufferStreamC::ReadItemExists () const {
    MK_UNUSED auto bus = getBUSN();
    MK_BOOL __retVal__L = MkBufferStreamReadItemExists(bus);
    return __retVal__L;
  }
 
  inline void MkBufferStreamC::ReadL_END ()  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamReadL_END(bus);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::ReadL_START (MkBufferC* buf)  {
    MK_UNUSED auto bus = getBUS();
    MK_BUF buf_hdl = MkBufferC::getBUF__null_allow(buf);
    enum MkErrorE errVal = MkBufferStreamReadL_START(bus, buf_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::ReadL_START (const MkBufferC& buf)  {
    MK_UNUSED auto bus = getBUS();
    const MK_BUF buf_hdl = MkBufferC::getBUF(buf);
    enum MkErrorE errVal = MkBufferStreamReadL_START(bus, buf_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::ReadUndo ()  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamReadUndo(bus);
    MkErrorC_Check(bus, errVal);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Read,omo
 
  inline MK_BNP MkBufferStreamC::ReadBIN ()  {
    MK_UNUSED auto bus = getBUS();
    MkBinaryR val_out_ref;
    enum MkErrorE errVal = MkBufferStreamReadBIN(bus, &val_out_ref);
    ErrorCheck(errVal);
    MK_BNP val_out = std::make_pair(val_out_ref.size,val_out_ref.data);
    return val_out;
  }
 
  inline MK_BOL MkBufferStreamC::ReadBOL ()  {
    MK_UNUSED auto bus = getBUS();
    MK_BOL val_out;
    enum MkErrorE errVal = MkBufferStreamReadBOL(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return val_out != 0;
  }
 
  inline MK_DBL MkBufferStreamC::ReadDBL ()  {
    MK_UNUSED auto bus = getBUS();
    MK_DBL val_out;
    enum MkErrorE errVal = MkBufferStreamReadDBL(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return val_out;
  }
 
  inline MK_FLT MkBufferStreamC::ReadFLT ()  {
    MK_UNUSED auto bus = getBUS();
    MK_FLT val_out;
    enum MkErrorE errVal = MkBufferStreamReadFLT(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return val_out;
  }
 
  inline MK_I32 MkBufferStreamC::ReadI32 ()  {
    MK_UNUSED auto bus = getBUS();
    MK_I32 val_out;
    enum MkErrorE errVal = MkBufferStreamReadI32(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return val_out;
  }
 
  inline MK_I64 MkBufferStreamC::ReadI64 ()  {
    MK_UNUSED auto bus = getBUS();
    MK_I64 val_out;
    enum MkErrorE errVal = MkBufferStreamReadI64(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return val_out;
  }
 
  inline MK_I8 MkBufferStreamC::ReadI8 ()  {
    MK_UNUSED auto bus = getBUS();
    MK_I8 val_out;
    enum MkErrorE errVal = MkBufferStreamReadI8(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return (MK_I8)val_out;
  }
 
  inline MK_LONG MkBufferStreamC::ReadLONG ()  {
    MK_UNUSED auto bus = getBUS();
    MK_LONG val_out;
    enum MkErrorE errVal = MkBufferStreamReadLONG(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return val_out;
  }
 
  inline MK_STRN MkBufferStreamC::ReadSTR ()  {
    MK_UNUSED auto bus = getBUS();
    MK_STRN val_out;
    enum MkErrorE errVal = MkBufferStreamReadSTR(bus, &val_out);
    MkErrorC_Check(bus, errVal);
    return val_out;
  }
 
  // MkBufferStreamC_Read_CC_API
 
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-TOR,oC_
 
  inline MkBufferStreamC* MkBufferStreamC::Merge ()  {
    MK_UNUSED auto bus = getBUS();
    MK_BUS __retVal__L = MkBufferStreamMerge(bus);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferStreamC::Merge");
    }
    return MkBufferStreamC::MkBufferStreamC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-TOR,oCx
 
  inline MkBufferStreamC* MkBufferStreamC::Dup () const {
    MK_UNUSED auto src = getBUSN();
    MK_BUS __retVal__L = MkBufferStreamDup(src);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferStreamC::Dup");
    }
    return MkBufferStreamC::MkBufferStreamC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-TOR,sCc
 
  inline MK_OBJ MkBufferStreamC::CTOR (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamCreate(NULL, size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferStreamC::CTOR");
    }
    return (MK_OBJ)__retVal__L;
  }
 
  inline MkBufferStreamC* MkBufferStreamC::Create (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamCreate(NULL, size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferStreamC::Create");
    }
    return MkBufferStreamC::MkBufferStreamC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferStreamC* MkBufferStreamC::Create1024 (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamCreate1024(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferStreamC::Create1024");
    }
    return MkBufferStreamC::MkBufferStreamC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferStreamC* MkBufferStreamC::Create16384 (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamCreate16384(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferStreamC::Create16384");
    }
    return MkBufferStreamC::MkBufferStreamC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferStreamC* MkBufferStreamC::Create256 (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamCreate256(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferStreamC::Create256");
    }
    return MkBufferStreamC::MkBufferStreamC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferStreamC* MkBufferStreamC::Create64 (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamCreate64(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferStreamC::Create64");
    }
    return MkBufferStreamC::MkBufferStreamC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-TOR,sc_
 
  inline MkBufferStreamC* MkBufferStreamC::CreateTLS (MK_STRN tlsName, MK_BOOL resetB)  {
    MkRtSetup_NULL;
    MK_BUS __retVal__L = MkBufferStreamCreateTLS(tlsName, resetB);
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferStreamC* MkBufferStreamC::CreateTLS (const std::string& tlsName, MK_BOOL resetB)  {
    MkRtSetup_NULL;
    const MK_STRN tlsName_hdl = tlsName.c_str();
    MK_BUS __retVal__L = MkBufferStreamCreateTLS(tlsName_hdl, resetB);
    return MkBufferStreamC::MkBufferStreamC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferStreamC_TOR_CC_API
 
 
  // doc-key: MkBufferStreamC,MkBufferStreamC-Write,om_
 
  inline void MkBufferStreamC::WriteBFL (const MkBufferListC* bfl)  {
    MK_UNUSED auto bus = getBUS();
    MK_BFLN bfl_hdl = MkBufferListC::getBFLN(bfl);
    enum MkErrorE errVal = MkBufferStreamWriteBFL(bus, bfl_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteBFL (const MkBufferListC& bfl)  {
    MK_UNUSED auto bus = getBUS();
    const MK_BFLN bfl_hdl = MkBufferListC::getBFLN(bfl);
    enum MkErrorE errVal = MkBufferStreamWriteBFL(bus, bfl_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteBIN (MK_BNP val)  {
    MK_UNUSED auto bus = getBUS();
    const MkBinaryR val_ref = MkBinaryCreate(val.first,val.second);
    enum MkErrorE errVal = MkBufferStreamWriteBIN(bus, val_ref);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteBOL (MK_BOL val)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteBOL(bus, (MK_BOL)(val?1:0));
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteBUF (const MkBufferC* val)  {
    MK_UNUSED auto bus = getBUS();
    MK_BUFN val_hdl = MkBufferC::getBUFN(val);
    enum MkErrorE errVal = MkBufferStreamWriteBUF(bus, val_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteBUF (const MkBufferC& val)  {
    MK_UNUSED auto bus = getBUS();
    const MK_BUFN val_hdl = MkBufferC::getBUFN(val);
    enum MkErrorE errVal = MkBufferStreamWriteBUF(bus, val_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteBUS_FLAT (const MkBufferStreamC* add)  {
    MK_UNUSED auto bus = getBUS();
    MK_BUSN add_hdl = MkBufferStreamC::getBUSN(add);
    enum MkErrorE errVal = MkBufferStreamWriteBUS_FLAT(bus, add_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteBUS_FLAT (const MkBufferStreamC& add)  {
    MK_UNUSED auto bus = getBUS();
    const MK_BUSN add_hdl = MkBufferStreamC::getBUSN(add);
    enum MkErrorE errVal = MkBufferStreamWriteBUS_FLAT(bus, add_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteDBL (MK_DBL val)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteDBL(bus, val);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteFLT (MK_FLT val)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteFLT(bus, val);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteHDL (MK_I32 val)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteHDL(bus, val);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteI32 (MK_I32 val)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteI32(bus, val);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteI64 (MK_I64 val)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteI64(bus, val);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteI8 (MK_I8 val)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteI8(bus, (MK_I8)(val));
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteLONG (MK_LONG val)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteLONG(bus, val);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteL_END ()  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteL_END(bus);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteL_FLAT (MkBufferListC* bfl)  {
    MK_UNUSED auto bus = getBUS();
    MK_BFL bfl_hdl = MkBufferListC::getBFL(bfl);
    enum MkErrorE errVal = MkBufferStreamWriteL_FLAT(bus, bfl_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteL_FLAT (const MkBufferListC& bfl)  {
    MK_UNUSED auto bus = getBUS();
    const MK_BFL bfl_hdl = MkBufferListC::getBFL(bfl);
    enum MkErrorE errVal = MkBufferStreamWriteL_FLAT(bus, bfl_hdl);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteL_START ()  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteL_START(bus);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteSTR (MK_STRN val, MK_NUM len)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteSTR(bus, val, len);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteSTR (const std::string& val, MK_NUM len)  {
    MK_UNUSED auto bus = getBUS();
    const MK_STRN val_hdl = val.c_str();
    enum MkErrorE errVal = MkBufferStreamWriteSTR(bus, val_hdl, len);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteV (MK_STRN fmt, ... )  {
    MK_UNUSED auto bus = getBUS();
    va_list ap;
    va_start (ap, fmt);
    enum MkErrorE errVal = MkBufferStreamWriteVL(bus, fmt, ap);
    va_end (ap);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteV (const std::string& fmt, ... )  {
    MK_UNUSED auto bus = getBUS();
    const MK_STRN fmt_hdl = fmt.c_str();
    va_list ap;
    va_start (ap, fmt);
    enum MkErrorE errVal = MkBufferStreamWriteVL(bus, fmt_hdl, ap);
    va_end (ap);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteVL (MK_STRN fmt, va_list ap)  {
    MK_UNUSED auto bus = getBUS();
    enum MkErrorE errVal = MkBufferStreamWriteVL(bus, fmt, ap);
    MkErrorC_Check(bus, errVal);
  }
 
  inline void MkBufferStreamC::WriteVL (const std::string& fmt, va_list ap)  {
    MK_UNUSED auto bus = getBUS();
    const MK_STRN fmt_hdl = fmt.c_str();
    enum MkErrorE errVal = MkBufferStreamWriteVL(bus, fmt_hdl, ap);
    MkErrorC_Check(bus, errVal);
  }
 
  // MkBufferStreamC_Write_CC_API
 
  //   END-MkBufferStreamC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
} // END - namespace "ccmkkernel"