LcConfigC_inline_cc.hh

Go to the documentation of this file.

 
/* LABEL-NO */
 
/*****************************************************************************/
/*                                                                           */
/*                                context                                    */
/*                                                                           */
/*****************************************************************************/
 
#include "LcCall_cc.hh"
 
namespace cclcconfig {
 
/*
  inline MK_PTR LcConfigC::LcConfigC_selfCreateTLS(MK_OBJ obj) {
    return new LcConfigC(obj);
  }
 
  inline MK_PTR LcConfigC::LcConfigC_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 ? LcConfigC_selfCreateTLS(obj) : new LcConfigC(obj);
  }
*/
 
  //   BEGIN-LcConfigC - created by 'cc_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
 
  // doc-key: LcConfigC,LcConfigC-Class-Export,sc_
 
  inline LcConfigC* LcConfigC::HandleResolve (MK_HDL netHdl)  {
    MkRtSetup_NULL;
    LC_CFG __retVal__L = LcConfigHandleResolve(netHdl);
    return LcConfigC::LcConfigC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcConfigC,LcConfigC-Class-Export,om_
 
  // skip class-overload: HandleGet = LcConfigHandleGet → MkObjectHandleGet
 
  // LcConfigC_Class_CC_API
 
 
  // doc-key: LcConfigC,LcConfigC-Class-Introspection,oc_
 
  inline LcConfigC* LcConfigC::Next ()  {
    MK_UNUSED auto cfg = getCFG();
    LC_CFG __retVal__L = LcConfigNext(cfg);
    return LcConfigC::LcConfigC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcConfigC* LcConfigC::Prev ()  {
    MK_UNUSED auto cfg = getCFG();
    LC_CFG __retVal__L = LcConfigPrev(cfg);
    return LcConfigC::LcConfigC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcConfigC,LcConfigC-Class-Introspection,sc_
 
  inline LcConfigC* LcConfigC::Instances ()  {
    MkRtSetup_NULL;
    LC_CFG __retVal__L = LcConfigInstances();
    return LcConfigC::LcConfigC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // LcConfigC_Class_CC_API
 
 
  // doc-key: LcConfigC,LcConfigC-Class-Misc,sc_
 
  inline LcConfigC* LcConfigC::GetNull ()  {
    MkRtSetup_NULL;
    LC_CFG __retVal__L = LcConfigGetNull();
    return LcConfigC::LcConfigC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // LcConfigC_Class_CC_API
 
 
  // doc-key: LcConfigC,LcConfigC-Error,om_
 
  inline LcErrorTypeE LcConfigC::ErrorType () const {
    MK_UNUSED auto config = getCFGN();
    enum LcErrorTypeE __retVal__L = LcConfigErrorType(config);
    return __retVal__L;
  }
 
  // LcConfigC_Error_CC_API
 
 
  // doc-key: LcConfigC,LcConfigC-Get,om_
 
  inline LcConfigFormatE LcConfigC::GetDefaultFormat () const {
    MK_UNUSED auto config = getCFGN();
    enum LcConfigFormatE __retVal__L = LcConfigGetDefaultFormat(config);
    return __retVal__L;
  }
 
  inline MK_I16 LcConfigC::GetFloatPrecision () const {
    MK_UNUSED auto config = getCFGN();
    MK_I16 __retVal__L = LcConfigGetFloatPrecision(config);
    return __retVal__L;
  }
 
  inline MK_STRN LcConfigC::GetIncludeDir () const {
    MK_UNUSED auto config = getCFGN();
    MK_STRN __retVal__L = LcConfigGetIncludeDir(config);
    return __retVal__L;
  }
 
  inline MK_BOOL LcConfigC::GetOption (LcConfigOptionsEF option) const {
    MK_UNUSED auto config = getCFGN();
    MK_BOOL __retVal__L = LcConfigGetOption(config, option);
    return __retVal__L;
  }
 
  inline LcConfigOptionsEF LcConfigC::GetOptions () const {
    MK_UNUSED auto config = getCFGN();
    enum LcConfigOptionsEF __retVal__L = LcConfigGetOptions(config);
    return __retVal__L;
  }
 
  inline MK_I16 LcConfigC::GetTabWidth () const {
    MK_UNUSED auto config = getCFGN();
    MK_I16 __retVal__L = LcConfigGetTabWidth(config);
    return __retVal__L;
  }
 
  // LcConfigC_Get_CC_API
 
 
  // doc-key: LcConfigC,LcConfigC-Lookup,oc_
 
  inline LcSettingC* LcConfigC::Lookup (MK_STRN path) const {
    MK_UNUSED auto config = getCFGN();
    LC_CFS __retVal__L = LcConfigLookup(config, path);
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  inline LcSettingC* LcConfigC::Lookup (const std::string& path) const {
    MK_UNUSED auto config = getCFGN();
    const MK_STRN path_hdl = path.c_str();
    LC_CFS __retVal__L = LcConfigLookup(config, path_hdl);
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcConfigC,LcConfigC-Lookup,omo
 
  inline MK_BOOL LcConfigC::LookupBool (MK_STRN path) const {
    MK_UNUSED auto config = getCFGN();
    MK_BOOL value_out;
    enum MkErrorE errVal = LcConfigLookupBool(config, path, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_BOOL LcConfigC::LookupBool (const std::string& path) const {
    MK_UNUSED auto config = getCFGN();
    MK_BOOL value_out;
    const MK_STRN path_hdl = path.c_str();
    enum MkErrorE errVal = LcConfigLookupBool(config, path_hdl, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_DBL LcConfigC::LookupFloat (MK_STRN path) const {
    MK_UNUSED auto config = getCFGN();
    MK_DBL value_out;
    enum MkErrorE errVal = LcConfigLookupFloat(config, path, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_DBL LcConfigC::LookupFloat (const std::string& path) const {
    MK_UNUSED auto config = getCFGN();
    MK_DBL value_out;
    const MK_STRN path_hdl = path.c_str();
    enum MkErrorE errVal = LcConfigLookupFloat(config, path_hdl, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_I32 LcConfigC::LookupInt (MK_STRN path) const {
    MK_UNUSED auto config = getCFGN();
    MK_I32 value_out;
    enum MkErrorE errVal = LcConfigLookupInt(config, path, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_I32 LcConfigC::LookupInt (const std::string& path) const {
    MK_UNUSED auto config = getCFGN();
    MK_I32 value_out;
    const MK_STRN path_hdl = path.c_str();
    enum MkErrorE errVal = LcConfigLookupInt(config, path_hdl, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_I64 LcConfigC::LookupInt64 (MK_STRN path) const {
    MK_UNUSED auto config = getCFGN();
    MK_I64 value_out;
    enum MkErrorE errVal = LcConfigLookupInt64(config, path, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_I64 LcConfigC::LookupInt64 (const std::string& path) const {
    MK_UNUSED auto config = getCFGN();
    MK_I64 value_out;
    const MK_STRN path_hdl = path.c_str();
    enum MkErrorE errVal = LcConfigLookupInt64(config, path_hdl, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_STRN LcConfigC::LookupString (MK_STRN path) const {
    MK_UNUSED auto config = getCFGN();
    MK_STRN value_out;
    enum MkErrorE errVal = LcConfigLookupString(config, path, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  inline MK_STRN LcConfigC::LookupString (const std::string& path) const {
    MK_UNUSED auto config = getCFGN();
    MK_STRN value_out;
    const MK_STRN path_hdl = path.c_str();
    enum MkErrorE errVal = LcConfigLookupString(config, path_hdl, &value_out);
    MkErrorC_Check(config, errVal);
    return value_out;
  }
 
  // LcConfigC_Lookup_CC_API
 
 
  // doc-key: LcConfigC,LcConfigC-Misc,oc_
 
  inline LcSettingC* LcConfigC::RootSetting () const {
    MK_UNUSED auto config = getCFGN();
    LC_CFS __retVal__L = LcConfigRootSetting(config);
    return LcSettingC::LcSettingC_ObjNew(MK_RT_CALL __retVal__L);
  }
 
  // doc-key: LcConfigC,LcConfigC-Misc,om_
 
  inline void LcConfigC::Clear ()  {
    MK_UNUSED auto config = getCFG();
    LcConfigClear(config);
  }
 
  inline void LcConfigC::Log (const MkObjectC* fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto cfg = getCFGN();
    MK_OBJN fmtobj_hdl = MkObjectC::getOBJN__null_allow(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    LcConfigLog(cfg, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void LcConfigC::Log (const MkObjectC& fmtobj, MK_DBG debug, MK_STRN callfunc, MK_I32 lvl) const {
    MK_UNUSED auto cfg = getCFGN();
    const MK_OBJN fmtobj_hdl = MkObjectC::getOBJN(fmtobj);
    if (callfunc == NULL) {callfunc = __builtin_FUNCTION();}
    if (debug > (MK_DBG)(MkRuntimeDebugGet())) {return;}
    LcConfigLog(cfg, fmtobj_hdl, debug, callfunc, lvl);
  }
 
  inline void LcConfigC::ReadFile (MK_STRN filename)  {
    MK_UNUSED auto config = getCFG();
    enum MkErrorE errVal = LcConfigReadFile(config, filename);
    MkErrorC_Check(config, errVal);
  }
 
  inline void LcConfigC::ReadFile (const std::string& filename)  {
    MK_UNUSED auto config = getCFG();
    const MK_STRN filename_hdl = filename.c_str();
    enum MkErrorE errVal = LcConfigReadFile(config, filename_hdl);
    MkErrorC_Check(config, errVal);
  }
 
  inline void LcConfigC::ReadString (MK_STRN str)  {
    MK_UNUSED auto config = getCFG();
    enum MkErrorE errVal = LcConfigReadString(config, str);
    MkErrorC_Check(config, errVal);
  }
 
  inline void LcConfigC::ReadString (const std::string& str)  {
    MK_UNUSED auto config = getCFG();
    const MK_STRN str_hdl = str.c_str();
    enum MkErrorE errVal = LcConfigReadString(config, str_hdl);
    MkErrorC_Check(config, errVal);
  }
 
  inline void LcConfigC::WriteFile (MK_STRN filename)  {
    MK_UNUSED auto config = getCFG();
    enum MkErrorE errVal = LcConfigWriteFile(config, filename);
    MkErrorC_Check(config, errVal);
  }
 
  inline void LcConfigC::WriteFile (const std::string& filename)  {
    MK_UNUSED auto config = getCFG();
    const MK_STRN filename_hdl = filename.c_str();
    enum MkErrorE errVal = LcConfigWriteFile(config, filename_hdl);
    MkErrorC_Check(config, errVal);
  }
 
  // doc-key: LcConfigC,LcConfigC-Misc,omo
 
  inline MK_STRN LcConfigC::WriteString () const {
    MK_UNUSED auto cfg = getCFGN();
    MK_STRN val_out;
    enum MkErrorE errVal = LcConfigWriteString(cfg, &val_out);
    MkErrorC_Check(cfg, errVal);
    return val_out;
  }
 
  // LcConfigC_Misc_CC_API
 
 
  // doc-key: LcConfigC,LcConfigC-Set,om_
 
  inline void LcConfigC::SetDefaultFormat (LcConfigFormatE format)  {
    MK_UNUSED auto config = getCFG();
    LcConfigSetDefaultFormat(config, format);
  }
 
  inline void LcConfigC::SetFloatPrecision (MK_I16 digits)  {
    MK_UNUSED auto config = getCFG();
    LcConfigSetFloatPrecision(config, digits);
  }
 
  inline void LcConfigC::SetIncludeDir (MK_STRN include_dir)  {
    MK_UNUSED auto config = getCFG();
    LcConfigSetIncludeDir(config, include_dir);
  }
 
  inline void LcConfigC::SetIncludeDir (const std::string& include_dir)  {
    MK_UNUSED auto config = getCFG();
    const MK_STRN include_dir_hdl = include_dir.c_str();
    LcConfigSetIncludeDir(config, include_dir_hdl);
  }
 
  inline void LcConfigC::SetIncludeFunc (LcConfigIncludeIF* fConfigIncludeData)  {
    MK_UNUSED auto cfg = getCFG();
    auto fConfigIncludeCall = LcConfigIncludeCallbackC::Call;
    auto fConfigIncludeData_ptr = LcConfigIncludeCallbackC::Create(MK_RT_CALL fConfigIncludeData, this);
    if (fConfigIncludeData_ptr == NULL) fConfigIncludeCall = NULL;
    enum MkErrorE errVal = LcConfigSetIncludeFunc(cfg, fConfigIncludeCall, fConfigIncludeData_ptr, LcConfigIncludeCallbackC::Free);
    MkErrorC_Check(cfg, errVal);
  }
 
  inline void LcConfigC::SetIncludeFunc (LcConfigIncludeSCB fConfigIncludeData)  {
    MK_UNUSED auto cfg = getCFG();
    auto fConfigIncludeCall = LcConfigIncludeCallbackC::Call;
    auto fConfigIncludeData_ptr = LcConfigIncludeCallbackC::Create(MK_RT_CALL fConfigIncludeData, this);
    if (fConfigIncludeData_ptr == NULL) fConfigIncludeCall = NULL;
    enum MkErrorE errVal = LcConfigSetIncludeFunc(cfg, fConfigIncludeCall, fConfigIncludeData_ptr, LcConfigIncludeCallbackC::Free);
    MkErrorC_Check(cfg, errVal);
  }
 
  inline void LcConfigC::SetOption (LcConfigOptionsEF option, MK_BOOL flag)  {
    MK_UNUSED auto config = getCFG();
    LcConfigSetOption(config, option, flag);
  }
 
  inline void LcConfigC::SetOptions (LcConfigOptionsEF options)  {
    MK_UNUSED auto config = getCFG();
    LcConfigSetOptions(config, options);
  }
 
  inline void LcConfigC::SetSettingDeleteFunc (LcSettingDeleteIF* fSettingDeleteData)  {
    MK_UNUSED auto cfg = getCFG();
    auto fSettingDeleteCall = LcSettingDeleteCallbackC::Call;
    auto fSettingDeleteData_ptr = LcSettingDeleteCallbackC::Create(MK_RT_CALL fSettingDeleteData, this);
    if (fSettingDeleteData_ptr == NULL) fSettingDeleteCall = NULL;
    enum MkErrorE errVal = LcConfigSetSettingDeleteFunc(cfg, fSettingDeleteCall, fSettingDeleteData_ptr, LcSettingDeleteCallbackC::Free);
    MkErrorC_Check(cfg, errVal);
  }
 
  inline void LcConfigC::SetSettingDeleteFunc (LcSettingDeleteSCB fSettingDeleteData)  {
    MK_UNUSED auto cfg = getCFG();
    auto fSettingDeleteCall = LcSettingDeleteCallbackC::Call;
    auto fSettingDeleteData_ptr = LcSettingDeleteCallbackC::Create(MK_RT_CALL fSettingDeleteData, this);
    if (fSettingDeleteData_ptr == NULL) fSettingDeleteCall = NULL;
    enum MkErrorE errVal = LcConfigSetSettingDeleteFunc(cfg, fSettingDeleteCall, fSettingDeleteData_ptr, LcSettingDeleteCallbackC::Free);
    MkErrorC_Check(cfg, errVal);
  }
 
  inline void LcConfigC::SetTabWidth (MK_I16 width)  {
    MK_UNUSED auto config = getCFG();
    LcConfigSetTabWidth(config, width);
  }
 
  // LcConfigC_Set_CC_API
 
 
  // doc-key: LcConfigC,LcConfigC-TOR,sCc
 
  inline MK_OBJ LcConfigC::CTOR ()  {
    MkRtSetup_NULL;
    LC_CFG __retVal__L = LcConfigCreate(NULL, NULL);
    if (__retVal__L == NULL) {
      throw MkInitError("LcConfigC::CTOR");
    }
    return (MK_OBJ)__retVal__L;
  }
 
  inline LcConfigC* LcConfigC::Create ()  {
    MkRtSetup_NULL;
    LC_CFG __retVal__L = LcConfigCreate(NULL, NULL);
    if (__retVal__L == NULL) {
      throw MkInitError("LcConfigC::Create");
    }
    return LcConfigC::LcConfigC_ObjCreate(MK_RT_CALL __retVal__L);
  }
 
  // LcConfigC_TOR_CC_API
 
  //   END-LcConfigC - created by 'cc_MqC.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
} // END - namespace "cclcconfig"