MkBufferC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
namespace ccmkkernel {
 
/*
  inline MK_PTR MkBufferC::MkBufferC_selfCreateTLS(MK_OBJ obj) {
    return new MkBufferC(obj);
  }
 
  inline MK_PTR MkBufferC::MkBufferC_selfCreate (MK_RT_ARGS MK_OBJ obj, MK_PTR const env) {
    MK_BUF buf = reinterpret_cast<MK_BUF>(obj);
    return MkOBJ_R(buf).obj_protect.isLocal ? MkBufferC_selfCreateTLS(obj) : new MkBufferC(obj);
  }
*/
 
  inline MkBufferC::MkBufferC (const MkBufferC *copy) {
    if (copy == NULL) throw MkReferenceNullExceptionC("MkBufferC");
    MkRtSetup_O(copy->hdl);
    MkObjectC::atomInit(MkObjDup(copy->hdl));
  }
 
  inline MkBufferC::MkBufferC (const MkBufferC& copy) {
    MkRtSetup_O(copy.hdl);
    MkObjectC::atomInit(MkObjDup(copy.hdl));
  }
 
  inline MkBufferC& MkBufferC::operator= (const MkBufferC& copy) {
    MkRtSetup_O(copy.hdl);
    MkObjCopy(hdl,copy.hdl);
    return *this;
  }
 
  inline MkBufferC& MkBufferC::operator= (const MkBufferC* copy) {
    if (copy == NULL) throw MkReferenceNullExceptionC("MkBufferC");
    MkRtSetup_O(copy->hdl);
    MkObjCopy(hdl,copy->hdl);
    return *this;
  }
 
  // -------------------------------------------------------------------------------
 
  inline MkBufferC* MkBufferC::ToObject () {
    return this;
  }
 
  //   BEGIN-MkBufferC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
 
  // doc-key: MkBufferC,MkBufferC-Access,oc_
 
  inline MkBufferC* MkBufferC::AppendC (MK_STRN val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferAppendC(buf, val);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::AppendC (const std::string& val)  {
    MK_UNUSED auto buf = getBUF();
    const MK_STRN val_hdl = val.c_str();
    MK_BUF __retVal__L = MkBufferAppendC(buf, val_hdl);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::AppendStringR (const std::string& val)  {
    MK_UNUSED auto buf = getBUF();
    const MkStringR val_ref = MkStringCreate((MK_NUM)val.size(),val.c_str());
    MK_BUF __retVal__L = MkBufferAppendStringR(buf, val_ref);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferC,MkBufferC-Access,om_
 
  inline MK_I32 MkBufferC::AppendV (MK_FST printfmt, ... )  {
    MK_UNUSED auto buf = getBUF();
    va_list ap;
    va_start (ap, printfmt);
    MK_I32 __retVal__L = MkBufferAppendVL(buf, printfmt, ap);
    va_end (ap);
    return __retVal__L;
  }
 
  inline MK_I32 MkBufferC::AppendVL (MK_FST printfmt, va_list var_list)  {
    MK_UNUSED auto buf = getBUF();
    MK_I32 __retVal__L = MkBufferAppendVL(buf, printfmt, var_list);
    return __retVal__L;
  }
 
  inline MK_NUM MkBufferC::Pop (MK_STRN val)  {
    MK_UNUSED auto buf = getBUF();
    MK_NUM __retVal__L = MkBufferPop(buf, val);
    return __retVal__L;
  }
 
  inline MK_NUM MkBufferC::Pop (const std::string& val)  {
    MK_UNUSED auto buf = getBUF();
    const MK_STRN val_hdl = val.c_str();
    MK_NUM __retVal__L = MkBufferPop(buf, val_hdl);
    return __retVal__L;
  }
 
  inline MK_NUM MkBufferC::Push (MK_STRN val)  {
    MK_UNUSED auto buf = getBUF();
    MK_NUM __retVal__L = MkBufferPush(buf, val);
    return __retVal__L;
  }
 
  inline MK_NUM MkBufferC::Push (const std::string& val)  {
    MK_UNUSED auto buf = getBUF();
    const MK_STRN val_hdl = val.c_str();
    MK_NUM __retVal__L = MkBufferPush(buf, val_hdl);
    return __retVal__L;
  }
 
  // doc-key: MkBufferC,MkBufferC-Access,omo
 
 
  // MkBufferC_Access_CC_API
 
 
  // doc-key: MkBufferC,MkBufferC-Class-Export,sc_
 
  inline MkBufferC* MkBufferC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferHandleResolve(netHdl);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferC,MkBufferC-Class-Export,om_
 
  // skip class-overload: HandleGet = MkBufferHandleGet → MkObjectHandleGet
 
  // MkBufferC_Class_CC_API
 
 
  // doc-key: MkBufferC,MkBufferC-Class-Introspection,oc_
 
  inline MkBufferC* MkBufferC::Next ()  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferNext(buf);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::Prev ()  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferPrev(buf);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferC,MkBufferC-Class-Introspection,sc_
 
  inline MkBufferC* MkBufferC::Instances ()  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferInstances();
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferC_Class_CC_API
 
 
  // doc-key: MkBufferC,MkBufferC-Class-Misc,sc_
 
  inline MkBufferC* MkBufferC::GetNull ()  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferGetNull();
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferC_Class_CC_API
 
 
  // doc-key: MkBufferC,MkBufferC-Get,oci
 
  inline MkBufferListC* MkBufferC::GetBFL (MkBufferListC* val_inout) const {
    MK_UNUSED auto buf = getBUFN();
    MK_BFL val_inout_hdl = MkBufferListC::getBFL__null_allow(val_inout);
    enum MkErrorE errVal = MkBufferGetBFL(buf, &val_inout_hdl);
    MkErrorC_Check(buf, errVal);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL val_inout_hdl);
  }
 
  // doc-key: MkBufferC,MkBufferC-Get,oco
 
  inline MkBufferC* MkBufferC::GetBUF ()  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF val_out;
    enum MkErrorE errVal = MkBufferGetBUF(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL val_out);
  }
 
  // doc-key: MkBufferC,MkBufferC-Get,omo
 
  inline MK_BNP MkBufferC::GetBIN () const {
    MK_UNUSED auto buf = getBUFN();
    MkBinaryR val_out_ref;
    enum MkErrorE errVal = MkBufferGetBIN(buf, &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 MkBufferC::GetBOL () const {
    MK_UNUSED auto buf = getBUFN();
    MK_BOL val_out;
    enum MkErrorE errVal = MkBufferGetBOL(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return val_out != 0;
  }
 
  inline MK_DBL MkBufferC::GetDBL () const {
    MK_UNUSED auto buf = getBUFN();
    MK_DBL val_out;
    enum MkErrorE errVal = MkBufferGetDBL(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return val_out;
  }
 
  inline MK_FLT MkBufferC::GetFLT () const {
    MK_UNUSED auto buf = getBUFN();
    MK_FLT val_out;
    enum MkErrorE errVal = MkBufferGetFLT(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return val_out;
  }
 
  inline MK_I16 MkBufferC::GetI16 () const {
    MK_UNUSED auto buf = getBUFN();
    MK_I16 val_out;
    enum MkErrorE errVal = MkBufferGetI16(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return val_out;
  }
 
  inline MK_I32 MkBufferC::GetI32 () const {
    MK_UNUSED auto buf = getBUFN();
    MK_I32 val_out;
    enum MkErrorE errVal = MkBufferGetI32(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return val_out;
  }
 
  inline MK_I64 MkBufferC::GetI64 () const {
    MK_UNUSED auto buf = getBUFN();
    MK_I64 val_out;
    enum MkErrorE errVal = MkBufferGetI64(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return val_out;
  }
 
  inline MK_I8 MkBufferC::GetI8 () const {
    MK_UNUSED auto buf = getBUFN();
    MK_I8 val_out;
    enum MkErrorE errVal = MkBufferGetI8(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return (MK_I8)val_out;
  }
 
  inline MK_STRN MkBufferC::GetSTR () const {
    MK_UNUSED auto buf = getBUFN();
    MK_STRN val_out;
    enum MkErrorE errVal = MkBufferGetSTR(buf, &val_out);
    MkErrorC_Check(buf, errVal);
    return val_out;
  }
 
  inline std::string MkBufferC::GetStringR () const {
    MK_UNUSED auto buf = getBUFN();
    MkStringR val_out_ref;
    enum MkErrorE errVal = MkBufferGetStringR(buf, &val_out_ref);
    ErrorCheck(errVal);
    const std::string& val_out = std::string(val_out_ref.ptr,val_out_ref.len);
    return val_out;
  }
 
  // MkBufferC_Get_CC_API
 
 
  // doc-key: MkBufferC,MkBufferC-Info,om_
 
  inline MK_STRB MkBufferC::GetType1 () const {
    MK_UNUSED auto buf = getBUFN();
    MK_STRB __retVal__L = MkBufferGetType1(buf);
    return __retVal__L;
  }
 
  inline MkTypeE MkBufferC::GetType2 () const {
    MK_UNUSED auto buf = getBUFN();
    enum MkTypeE __retVal__L = MkBufferGetType2(buf);
    return __retVal__L;
  }
 
  inline MK_STRN MkBufferC::GetType3 () const {
    MK_UNUSED auto buf = getBUFN();
    MK_STRN __retVal__L = MkBufferGetType3(buf);
    return __retVal__L;
  }
 
  inline MK_BOOL MkBufferC::IsLocal () const {
    MK_UNUSED auto buf = getBUFN();
    MK_BOOL __retVal__L = MkBufferIsLocal(buf);
    return __retVal__L;
  }
 
  // skip class-overload: Log = MkBufferLog → MkObjectLog
 
  // skip class-overload: Log = MkBufferLog → MkObjectLog
 
  inline void MkBufferC::LogS (MK_STRN varname, const MkObjectC* fmtobj, MK_STRN callfunc) const {
    MK_UNUSED auto buf = getBUFN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    MkBufferLogS(buf, varname, fmtobj_hdl, callfunc);
  }
 
  // MkBufferC_Info_CC_API
 
 
  // doc-key: MkBufferC,MkBufferC-Misc,oc_
 
  inline MkBufferC* MkBufferC::Copy (const MkBufferC* srce) const {
    MK_UNUSED auto buf = getBUF();
    MK_BUFN srce_hdl = MkBufferC::getBUFN(srce);
    MK_BUF __retVal__L = MkBufferCopy(buf, srce_hdl);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::Copy (const MkBufferC& srce) const {
    MK_UNUSED auto buf = getBUF();
    const MK_BUFN srce_hdl = MkBufferC::getBUFN(srce);
    MK_BUF __retVal__L = MkBufferCopy(buf, srce_hdl);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::Reset ()  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferReset(buf);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SizeAdd (MK_NUM size)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSizeAdd(buf, size);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SizeNew (MK_NUM size)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSizeNew(buf, size);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::Temp () const {
    MK_UNUSED auto buf = getBUFN();
    MK_BUF __retVal__L = MkBufferTemp(buf);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferC,MkBufferC-Misc,om_
 
  inline void MkBufferC::CastTo (MkTypeE typ)  {
    MK_UNUSED auto buf = getBUF();
    enum MkErrorE errVal = MkBufferCastTo(buf, typ);
    MkErrorC_Check(buf, errVal);
  }
 
  inline MK_I32 MkBufferC::Cmp (const MkBufferC* buf2) const {
    MK_UNUSED auto buf1 = getBUFN();
    MK_BUFN buf2_hdl = MkBufferC::getBUFN(buf2);
    MK_I32 __retVal__L = MkBufferCmp(buf1, buf2_hdl);
    return __retVal__L;
  }
 
  inline MK_I32 MkBufferC::Cmp (const MkBufferC& buf2) const {
    MK_UNUSED auto buf1 = getBUFN();
    const MK_BUFN buf2_hdl = MkBufferC::getBUFN(buf2);
    MK_I32 __retVal__L = MkBufferCmp(buf1, buf2_hdl);
    return __retVal__L;
  }
 
  inline void MkBufferC::ResetFull ()  {
    MK_UNUSED auto buf = getBUF();
    MkBufferResetFull(buf);
  }
 
  // skip class-overload: ToString = MkBufferToString → MkObjectToString
 
  // MkBufferC_Misc_CC_API
 
 
  // doc-key: MkBufferC,MkBufferC-Set,oc_
 
  inline MkBufferC* MkBufferC::SetBIN (MK_BNP val)  {
    MK_UNUSED auto buf = getBUF();
    const MkBinaryR val_ref = MkBinaryCreate(val.first,val.second);
    MK_BUF __retVal__L = MkBufferSetBIN(buf, val_ref);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetBOL (MK_BOL val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetBOL(buf, (MK_BOL)(val?1:0));
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetBUF (const MkBufferC* val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUFN val_hdl = MkBufferC::getBUFN(val);
    MK_BUF __retVal__L = MkBufferSetBUF(buf, val_hdl);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetBUF (const MkBufferC& val)  {
    MK_UNUSED auto buf = getBUF();
    const MK_BUFN val_hdl = MkBufferC::getBUFN(val);
    MK_BUF __retVal__L = MkBufferSetBUF(buf, val_hdl);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetBinaryR (MK_BNP val)  {
    MK_UNUSED auto buf = getBUF();
    const MkBinaryR val_ref = MkBinaryCreate(val.first,val.second);
    MK_BUF __retVal__L = MkBufferSetBinaryR(buf, val_ref);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetDBL (MK_DBL val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetDBL(buf, val);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetFLT (MK_FLT val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetFLT(buf, val);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetI16 (MK_I16 val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetI16(buf, val);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetI32 (MK_I32 val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetI32(buf, val);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetI64 (MK_I64 val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetI64(buf, val);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetI8 (MK_I8 val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetI8(buf, (MK_I8)(val));
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetSTR (MK_STRN val)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetSTR(buf, val);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetSTR (const std::string& val)  {
    MK_UNUSED auto buf = getBUF();
    const MK_STRN val_hdl = val.c_str();
    MK_BUF __retVal__L = MkBufferSetSTR(buf, val_hdl);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetStringR (const std::string& val)  {
    MK_UNUSED auto buf = getBUF();
    const MkStringR val_ref = MkStringCreate((MK_NUM)val.size(),val.c_str());
    MK_BUF __retVal__L = MkBufferSetStringR(buf, val_ref);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetV (MK_FST val, ... )  {
    MK_UNUSED auto buf = getBUF();
    va_list ap;
    va_start (ap, val);
    MK_BUF __retVal__L = MkBufferSetVL(buf, val, ap);
    va_end (ap);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::SetVL (MK_FST val, va_list var_list)  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferSetVL(buf, val, var_list);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferC_Set_CC_API
 
 
  // doc-key: MkBufferC,MkBufferC-TOR,oC_
 
  inline MkBufferC* MkBufferC::Merge ()  {
    MK_UNUSED auto buf = getBUF();
    MK_BUF __retVal__L = MkBufferMerge(buf);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::Merge");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferC,MkBufferC-TOR,oCx
 
  inline MkBufferC* MkBufferC::Dup () const {
    MK_UNUSED auto buf = getBUFN();
    MK_BUF __retVal__L = MkBufferDup(buf);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::Dup");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferC,MkBufferC-TOR,sCc
 
  inline MK_OBJ MkBufferC::CTOR (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreate(NULL, size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CTOR");
    }
    return (MK_OBJ)__retVal__L;
  }
 
  inline MkBufferC* MkBufferC::Create (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreate(NULL, size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::Create");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::Create1024 (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreate1024(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::Create1024");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::Create256 (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreate256(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::Create256");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::Create64 (MK_NUM size)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreate64(size);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::Create64");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateBIN (MK_BNP val)  {
    MkRtSetup_NULL;
    const MkBinaryR val_ref = MkBinaryCreate(val.first,val.second);
    MK_BUF __retVal__L = MkBufferCreateBIN(val_ref);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateBIN");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateBOL (MK_BOL val)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateBOL((MK_BOL)(val?1:0));
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateBOL");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateBUF (const MkBufferC* val)  {
    MkRtSetup_NULL;
    MK_BUFN val_hdl = MkBufferC::getBUFN(val);
    MK_BUF __retVal__L = MkBufferCreateBUF(val_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateBUF");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateBUF (const MkBufferC& val)  {
    MkRtSetup_NULL;
    const MK_BUFN val_hdl = MkBufferC::getBUFN(val);
    MK_BUF __retVal__L = MkBufferCreateBUF(val_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateBUF");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateDBL (MK_DBL val)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateDBL(val);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateDBL");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateFLT (MK_FLT val)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateFLT(val);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateFLT");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateI16 (MK_I16 val)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateI16(val);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateI16");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateI32 (MK_I32 val)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateI32(val);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateI32");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateI64 (MK_I64 val)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateI64(val);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateI64");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateI8 (MK_I8 val)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateI8((MK_I8)(val));
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateI8");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateSTR (MK_STRN val)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateSTR(val);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateSTR");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateSTR (const std::string& val)  {
    MkRtSetup_NULL;
    const MK_STRN val_hdl = val.c_str();
    MK_BUF __retVal__L = MkBufferCreateSTR(val_hdl);
    if (__retVal__L == NULL) {
      throw MkInitError("MkBufferC::CreateSTR");
    }
    return MkBufferC::MkBufferC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: MkBufferC,MkBufferC-TOR,sc_
 
  inline MkBufferC* MkBufferC::CreateTLS (MK_STRN tlsName, MK_BOOL resetB)  {
    MkRtSetup_NULL;
    MK_BUF __retVal__L = MkBufferCreateTLS(tlsName, resetB);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferC* MkBufferC::CreateTLS (const std::string& tlsName, MK_BOOL resetB)  {
    MkRtSetup_NULL;
    const MK_STRN tlsName_hdl = tlsName.c_str();
    MK_BUF __retVal__L = MkBufferCreateTLS(tlsName_hdl, resetB);
    return MkBufferC::MkBufferC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // MkBufferC_TOR_CC_API
 
  //   END-MkBufferC - created by 'cc_MqC.tcl -i NHI1_HOME/theKernel/c/gen/c_mkkernel.meta' - DO NOT change
 
} // END - namespace "ccmkkernel"