LcSettingC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
/*****************************************************************************/
/*                                                                           */
/*                                context                                    */
/*                                                                           */
/*****************************************************************************/
 
namespace cclcconfig {
 
/*
  inline MK_PTR LcSettingC::LcSettingC_selfCreateTLS(MK_OBJ obj) {
    return new LcSettingC(obj);
  }
 
  inline MK_PTR LcSettingC::LcSettingC_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 ? LcSettingC_selfCreateTLS(obj) : new LcSettingC(obj);
  }
*/
 
  //   BEGIN-LcSettingC - created by 'cc_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
  // doc-key: LcSettingC,LcSettingC-Class-Export,sc_
 
  inline LcSettingC* LcSettingC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    LC_CFS __retVal__L = LcSettingHandleResolve(netHdl);
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcSettingC,LcSettingC-Class-Export,om_
 
  // skip class-overload: HandleGet = LcSettingHandleGet → MkObjectHandleGet
 
  // LcSettingC_Class_CC_API
 
 
  // doc-key: LcSettingC,LcSettingC-Class-Introspection,oc_
 
  inline LcSettingC* LcSettingC::Next ()  {
    MK_UNUSED auto cfs = getCFS();
    LC_CFS __retVal__L = LcSettingNext(cfs);
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::Prev ()  {
    MK_UNUSED auto cfs = getCFS();
    LC_CFS __retVal__L = LcSettingPrev(cfs);
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcSettingC,LcSettingC-Class-Introspection,sc_
 
  inline LcSettingC* LcSettingC::Instances ()  {
    MkRtSetup_NULL;
    LC_CFS __retVal__L = LcSettingInstances();
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // LcSettingC_Class_CC_API
 
 
  // doc-key: LcSettingC,LcSettingC-Class-Misc,sc_
 
  inline LcSettingC* LcSettingC::GetNull ()  {
    MkRtSetup_NULL;
    LC_CFS __retVal__L = LcSettingGetNull();
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // LcSettingC_Class_CC_API
 
 
  // doc-key: LcSettingC,LcSettingC-Get,oc_
 
  inline LcSettingC* LcSettingC::GetElem (MK_I32 idx) const {
    MK_UNUSED auto setting = getCFSN();
    LC_CFS __retVal__L = LcSettingGetElem(setting, idx);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::GetElem");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::GetMember (MK_STRN name) const {
    MK_UNUSED auto setting = getCFSN();
    LC_CFS __retVal__L = LcSettingGetMember(setting, name);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::GetMember");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::GetMember (const std::string& name) const {
    MK_UNUSED auto setting = getCFSN();
    const MK_STRN name_hdl = name.c_str();
    LC_CFS __retVal__L = LcSettingGetMember(setting, name_hdl);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::GetMember");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcSettingC,LcSettingC-Get,om_
 
  inline MK_BOOL LcSettingC::GetBool () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingGetBool(setting);
    return __retVal__L;
  }
 
  inline MK_BOOL LcSettingC::GetBoolElem (MK_I32 idx) const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingGetBoolElem(setting, idx);
    return __retVal__L;
  }
 
  inline MK_DBL LcSettingC::GetFloat () const {
    MK_UNUSED auto setting = getCFSN();
    MK_DBL __retVal__L = LcSettingGetFloat(setting);
    return __retVal__L;
  }
 
  inline MK_DBL LcSettingC::GetFloatElem (MK_I32 idx) const {
    MK_UNUSED auto setting = getCFSN();
    MK_DBL __retVal__L = LcSettingGetFloatElem(setting, idx);
    return __retVal__L;
  }
 
  inline LcConfigFormatE LcSettingC::GetFormat () const {
    MK_UNUSED auto setting = getCFSN();
    enum LcConfigFormatE __retVal__L = LcSettingGetFormat(setting);
    return __retVal__L;
  }
 
  inline MK_I32 LcSettingC::GetInt () const {
    MK_UNUSED auto setting = getCFSN();
    MK_I32 __retVal__L = LcSettingGetInt(setting);
    return __retVal__L;
  }
 
  inline MK_I64 LcSettingC::GetInt64 () const {
    MK_UNUSED auto setting = getCFSN();
    MK_I64 __retVal__L = LcSettingGetInt64(setting);
    return __retVal__L;
  }
 
  inline MK_I64 LcSettingC::GetInt64Elem (MK_I32 idx) const {
    MK_UNUSED auto setting = getCFSN();
    MK_I64 __retVal__L = LcSettingGetInt64Elem(setting, idx);
    return __retVal__L;
  }
 
  inline MK_I32 LcSettingC::GetIntElem (MK_I32 idx) const {
    MK_UNUSED auto setting = getCFSN();
    MK_I32 __retVal__L = LcSettingGetIntElem(setting, idx);
    return __retVal__L;
  }
 
  inline MK_STRN LcSettingC::GetString () const {
    MK_UNUSED auto setting = getCFSN();
    MK_STRN __retVal__L = LcSettingGetString(setting);
    return __retVal__L;
  }
 
  inline MK_STRN LcSettingC::GetStringElem (MK_I32 idx) const {
    MK_UNUSED auto setting = getCFSN();
    MK_STRN __retVal__L = LcSettingGetStringElem(setting, idx);
    return __retVal__L;
  }
 
  // LcSettingC_Get_CC_API
 
 
  // doc-key: LcSettingC,LcSettingC-Is,om_
 
  inline MK_BOOL LcSettingC::IsAggregate () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingIsAggregate(setting);
    return __retVal__L;
  }
 
  inline MK_BOOL LcSettingC::IsArray () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingIsArray(setting);
    return __retVal__L;
  }
 
  inline MK_BOOL LcSettingC::IsGroup () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingIsGroup(setting);
    return __retVal__L;
  }
 
  inline MK_BOOL LcSettingC::IsList () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingIsList(setting);
    return __retVal__L;
  }
 
  inline MK_BOOL LcSettingC::IsNumber () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingIsNumber(setting);
    return __retVal__L;
  }
 
  inline MK_BOOL LcSettingC::IsRoot () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingIsRoot(setting);
    return __retVal__L;
  }
 
  inline MK_BOOL LcSettingC::IsScalar () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL __retVal__L = LcSettingIsScalar(setting);
    return __retVal__L;
  }
 
  // LcSettingC_Is_CC_API
 
 
  // doc-key: LcSettingC,LcSettingC-Lookup,oc_
 
  inline LcSettingC* LcSettingC::Lookup (MK_STRN path)  {
    MK_UNUSED auto setting = getCFS();
    LC_CFS __retVal__L = LcSettingLookup(setting, path);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::Lookup");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::Lookup (const std::string& path)  {
    MK_UNUSED auto setting = getCFS();
    const MK_STRN path_hdl = path.c_str();
    LC_CFS __retVal__L = LcSettingLookup(setting, path_hdl);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::Lookup");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline MkBufferListC* LcSettingC::LookupAll () const {
    MK_UNUSED auto setting = getCFSN();
    MK_BFL __retVal__L = LcSettingLookupAll(setting);
    return MkBufferListC::MkBufferListC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcSettingC,LcSettingC-Lookup,omo
 
  inline MK_BOOL LcSettingC::LookupBool (MK_STRN name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL value_out;
    enum MkErrorE errVal = LcSettingLookupBool(setting, name, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_BOOL LcSettingC::LookupBool (const std::string& name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_BOOL value_out;
    const MK_STRN name_hdl = name.c_str();
    enum MkErrorE errVal = LcSettingLookupBool(setting, name_hdl, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_DBL LcSettingC::LookupFloat (MK_STRN name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_DBL value_out;
    enum MkErrorE errVal = LcSettingLookupFloat(setting, name, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_DBL LcSettingC::LookupFloat (const std::string& name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_DBL value_out;
    const MK_STRN name_hdl = name.c_str();
    enum MkErrorE errVal = LcSettingLookupFloat(setting, name_hdl, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_I32 LcSettingC::LookupInt (MK_STRN name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_I32 value_out;
    enum MkErrorE errVal = LcSettingLookupInt(setting, name, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_I32 LcSettingC::LookupInt (const std::string& name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_I32 value_out;
    const MK_STRN name_hdl = name.c_str();
    enum MkErrorE errVal = LcSettingLookupInt(setting, name_hdl, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_I64 LcSettingC::LookupInt64 (MK_STRN name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_I64 value_out;
    enum MkErrorE errVal = LcSettingLookupInt64(setting, name, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_I64 LcSettingC::LookupInt64 (const std::string& name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_I64 value_out;
    const MK_STRN name_hdl = name.c_str();
    enum MkErrorE errVal = LcSettingLookupInt64(setting, name_hdl, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_STRN LcSettingC::LookupString (MK_STRN name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_STRN value_out;
    enum MkErrorE errVal = LcSettingLookupString(setting, name, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  inline MK_STRN LcSettingC::LookupString (const std::string& name) const {
    MK_UNUSED auto setting = getCFSN();
    MK_STRN value_out;
    const MK_STRN name_hdl = name.c_str();
    enum MkErrorE errVal = LcSettingLookupString(setting, name_hdl, &value_out);
    MkErrorC_Check(setting, errVal);
    return value_out;
  }
 
  // LcSettingC_Lookup_CC_API
 
 
  // doc-key: LcSettingC,LcSettingC-Misc,oc_
 
  inline LcSettingC* LcSettingC::AddIfNotExists (MK_STRN name, LcConfigTypeE cfgtype)  {
    MK_UNUSED auto setting = getCFS();
    LC_CFS __retVal__L = LcSettingAddIfNotExists(setting, name, cfgtype);
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::AddIfNotExists (const std::string& name, LcConfigTypeE cfgtype)  {
    MK_UNUSED auto setting = getCFS();
    const MK_STRN name_hdl = name.c_str();
    LC_CFS __retVal__L = LcSettingAddIfNotExists(setting, name_hdl, cfgtype);
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::Parent () const {
    MK_UNUSED auto setting = getCFSN();
    LC_CFS __retVal__L = LcSettingParent(setting);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::Parent");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcSettingC,LcSettingC-Misc,om_
 
  inline MK_BOOL LcSettingC::Exists (MK_STRN name)  {
    MK_UNUSED auto setting = getCFS();
    MK_BOOL __retVal__L = LcSettingExists(setting, name);
    return __retVal__L;
  }
 
  inline MK_BOOL LcSettingC::Exists (const std::string& name)  {
    MK_UNUSED auto setting = getCFS();
    const MK_STRN name_hdl = name.c_str();
    MK_BOOL __retVal__L = LcSettingExists(setting, name_hdl);
    return __retVal__L;
  }
 
  inline MK_I32 LcSettingC::Index () const {
    MK_UNUSED auto setting = getCFSN();
    MK_I32 __retVal__L = LcSettingIndex(setting);
    return __retVal__L;
  }
 
  inline MK_I32 LcSettingC::Length () const {
    MK_UNUSED auto setting = getCFSN();
    MK_I32 __retVal__L = LcSettingLength(setting);
    return __retVal__L;
  }
 
  // skip class-overload: Log = LcSettingLog → MkObjectLog
 
  // skip class-overload: Log = LcSettingLog → MkObjectLog
 
  inline MK_STRN LcSettingC::Name () const {
    MK_UNUSED auto setting = getCFSN();
    MK_STRN __retVal__L = LcSettingName(setting);
    return __retVal__L;
  }
 
  inline void LcSettingC::Remove (MK_STRN name)  {
    MK_UNUSED auto parent = getCFS();
    enum MkErrorE errVal = LcSettingRemove(parent, name);
    MkErrorC_Check(parent, errVal);
  }
 
  inline void LcSettingC::Remove (const std::string& name)  {
    MK_UNUSED auto parent = getCFS();
    const MK_STRN name_hdl = name.c_str();
    enum MkErrorE errVal = LcSettingRemove(parent, name_hdl);
    MkErrorC_Check(parent, errVal);
  }
 
  inline void LcSettingC::RemoveElem (MK_I32 idx)  {
    MK_UNUSED auto parent = getCFS();
    enum MkErrorE errVal = LcSettingRemoveElem(parent, idx);
    MkErrorC_Check(parent, errVal);
  }
 
  inline MK_STRN LcSettingC::SourceFile () const {
    MK_UNUSED auto setting = getCFSN();
    MK_STRN __retVal__L = LcSettingSourceFile(setting);
    return __retVal__L;
  }
 
  inline MK_I32 LcSettingC::SourceLine () const {
    MK_UNUSED auto setting = getCFSN();
    MK_I32 __retVal__L = LcSettingSourceLine(setting);
    return __retVal__L;
  }
 
  inline LcConfigTypeE LcSettingC::Type () const {
    MK_UNUSED auto setting = getCFSN();
    enum LcConfigTypeE __retVal__L = LcSettingType(setting);
    return __retVal__L;
  }
 
  // LcSettingC_Misc_CC_API
 
 
  // doc-key: LcSettingC,LcSettingC-Set,oc_
 
  inline LcSettingC* LcSettingC::SetBoolElem (MK_I32 idx, MK_I32 value)  {
    MK_UNUSED auto setting = getCFS();
    LC_CFS __retVal__L = LcSettingSetBoolElem(setting, idx, value);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::SetBoolElem");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::SetFloatElem (MK_I32 idx, MK_DBL value)  {
    MK_UNUSED auto setting = getCFS();
    LC_CFS __retVal__L = LcSettingSetFloatElem(setting, idx, value);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::SetFloatElem");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::SetInt64Elem (MK_I32 idx, MK_I64 value)  {
    MK_UNUSED auto setting = getCFS();
    LC_CFS __retVal__L = LcSettingSetInt64Elem(setting, idx, value);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::SetInt64Elem");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::SetIntElem (MK_I32 idx, MK_I32 value)  {
    MK_UNUSED auto setting = getCFS();
    LC_CFS __retVal__L = LcSettingSetIntElem(setting, idx, value);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::SetIntElem");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::SetStringElem (MK_I32 idx, MK_STRN value)  {
    MK_UNUSED auto setting = getCFS();
    LC_CFS __retVal__L = LcSettingSetStringElem(setting, idx, value);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::SetStringElem");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::SetStringElem (MK_I32 idx, const std::string& value)  {
    MK_UNUSED auto setting = getCFS();
    const MK_STRN value_hdl = value.c_str();
    LC_CFS __retVal__L = LcSettingSetStringElem(setting, idx, value_hdl);
    if (__retVal__L == NULL) {
      throw MkInitSoftError("LcSettingC::SetStringElem");
    }
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcSettingC,LcSettingC-Set,om_
 
  inline void LcSettingC::SetBool (MK_BOOL value)  {
    MK_UNUSED auto setting = getCFS();
    enum MkErrorE errVal = LcSettingSetBool(setting, value);
    MkErrorC_Check(setting, errVal);
  }
 
  inline void LcSettingC::SetFloat (MK_DBL value)  {
    MK_UNUSED auto setting = getCFS();
    enum MkErrorE errVal = LcSettingSetFloat(setting, value);
    MkErrorC_Check(setting, errVal);
  }
 
  inline void LcSettingC::SetFormat (LcConfigFormatE format)  {
    MK_UNUSED auto setting = getCFS();
    enum MkErrorE errVal = LcSettingSetFormat(setting, format);
    MkErrorC_Check(setting, errVal);
  }
 
  inline void LcSettingC::SetInt (MK_I32 value)  {
    MK_UNUSED auto setting = getCFS();
    enum MkErrorE errVal = LcSettingSetInt(setting, value);
    MkErrorC_Check(setting, errVal);
  }
 
  inline void LcSettingC::SetInt64 (MK_I64 value)  {
    MK_UNUSED auto setting = getCFS();
    enum MkErrorE errVal = LcSettingSetInt64(setting, value);
    MkErrorC_Check(setting, errVal);
  }
 
  inline void LcSettingC::SetString (MK_STRN value)  {
    MK_UNUSED auto setting = getCFS();
    enum MkErrorE errVal = LcSettingSetString(setting, value);
    MkErrorC_Check(setting, errVal);
  }
 
  inline void LcSettingC::SetString (const std::string& value)  {
    MK_UNUSED auto setting = getCFS();
    const MK_STRN value_hdl = value.c_str();
    enum MkErrorE errVal = LcSettingSetString(setting, value_hdl);
    MkErrorC_Check(setting, errVal);
  }
 
  // LcSettingC_Set_CC_API
 
 
  // doc-key: LcSettingC,LcSettingC-TOR,oC_
 
  inline LcSettingC* LcSettingC::Add (MK_STRN name, LcConfigTypeE __type)  {
    MK_UNUSED auto parent = getCFS();
    LC_CFS __retVal__L = LcSettingAdd(parent, name, __type);
    if (__retVal__L == NULL) {
      throw MkInitError("LcSettingC::Add");
    }
    return LcSettingC::LcSettingC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcSettingC::Add (const std::string& name, LcConfigTypeE __type)  {
    MK_UNUSED auto parent = getCFS();
    const MK_STRN name_hdl = name.c_str();
    LC_CFS __retVal__L = LcSettingAdd(parent, name_hdl, __type);
    if (__retVal__L == NULL) {
      throw MkInitError("LcSettingC::Add");
    }
    return LcSettingC::LcSettingC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcSettingC,LcSettingC-TOR,oc_
 
  inline LcConfigC* LcSettingC::GetConfig () const {
    MK_UNUSED auto setting = getCFSN();
    LC_CFG __retVal__L = LcSettingGetConfig(setting);
    return LcConfigC::LcConfigC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // LcSettingC_TOR_CC_API
 
  //   END-LcSettingC - created by 'cc_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
} // END - namespace "cclcconfig"