LcSettingC_lc.h

Go to the documentation of this file.

 
/* LABEL-START */
#pragma once
 
#include "LibLcConfig_lc.h"
/* LABEL-END */
 
BEGIN_LC_C_DECLS
 
/* MARK_S ################################################################ */
/* ###                                                                 ### */
/* ###              C O N F I G - S E T T I N G - A P I                ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
LC_EXTERN MK_BFL MK_DECL LcSettingLookupAll(LC_CFSN setting) MK_ATTR_INSTANCE;
 
__parser__(const,class-overload=MkObjectLog)
LC_EXTERN void MK_DECL LcSettingLog_RT (
  MK_PARSER_RT
  LC_CFSN const  setting    ,
  MK_PARSER_fmtobj          ,
  MK_DBG  const  debug      __parser__(default=0),
  MK_STRN const  callfunc   __parser__(default=F#FUNC),
  MK_I32  const  lvl        __parser__(default=0)
) MK_ATTR_RT_INSTANCE;
 
/*
__parser__(class-overload=MkObjectToString)
LC_EXTERN MK_STRN MK_DECL LcSettingToString_RT (
  MK_PARSER_RT
  MK_OBJN const inst __parser__(null-allowed)
) MK_ATTR_RT_INSTANCE;
*/
 
/*****************************************************************************/
/*                                                                           */
/*                            inline functions                               */
/*                                                                           */
/*****************************************************************************/
 
// =========================================================================
// BEGIN-LcSettingC-fupu - created by 'c_Native.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// -> no data
 
// END-LcSettingC-fupu - created by 'c_Native.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// =========================================================================
// BEGIN-LcSettingC-inline - created by 'c_Native.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcSettingC,LcSettingC-Get,oc_
 
  mk_inline LC_CFS LcSettingGetElem (LC_CFSN setting, MK_I32 idx) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_get_elem(setting->nat, (MK_U32)idx));
  }
 
  mk_inline LC_CFS LcSettingGetMember (LC_CFSN setting, MK_STRN name) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_get_member(setting->nat, name));
  }
 
  // doc-key: LcSettingC,LcSettingC-Get,om_
 
  mk_inline MK_BOOL LcSettingGetBool (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return (MK_BOOL)config_setting_get_bool(setting->nat);
  }
 
  mk_inline MK_BOOL LcSettingGetBoolElem (LC_CFSN setting, MK_I32 idx) {
    LC_INSTANCE_HDL(setting);
    return (MK_BOOL)config_setting_get_bool_elem(setting->nat, idx);
  }
 
  mk_inline MK_DBL LcSettingGetFloat (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_get_float(setting->nat);
  }
 
  mk_inline MK_DBL LcSettingGetFloatElem (LC_CFSN setting, MK_I32 idx) {
    LC_INSTANCE_HDL(setting);
    return config_setting_get_float_elem(setting->nat, idx);
  }
 
  mk_inline enum LcConfigFormatE LcSettingGetFormat (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return (enum LcConfigFormatE)config_setting_get_format(setting->nat);
  }
 
  mk_inline MK_PTR LcSettingGetHookHide (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return (MK_PTR)config_setting_get_hook(setting->nat);
  }
 
  mk_inline MK_I32 LcSettingGetInt (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_get_int(setting->nat);
  }
 
  mk_inline MK_I64 LcSettingGetInt64 (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_get_int64(setting->nat);
  }
 
  mk_inline MK_I64 LcSettingGetInt64Elem (LC_CFSN setting, MK_I32 idx) {
    LC_INSTANCE_HDL(setting);
    return config_setting_get_int64_elem(setting->nat, idx);
  }
 
  mk_inline MK_I32 LcSettingGetIntElem (LC_CFSN setting, MK_I32 idx) {
    LC_INSTANCE_HDL(setting);
    return config_setting_get_int_elem(setting->nat, idx);
  }
 
  mk_inline MK_STRN LcSettingGetString (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    MK_STRN __retVal__L = config_setting_get_string(setting->nat);
    return __retVal__L;
  }
 
  mk_inline MK_STRN LcSettingGetStringElem (LC_CFSN setting, MK_I32 idx) {
    LC_INSTANCE_HDL(setting);
    MK_STRN __retVal__L = config_setting_get_string_elem(setting->nat, idx);
    return __retVal__L;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcSettingC,LcSettingC-Is,om_
 
  mk_inline MK_BOOL LcSettingIsAggregate (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return (MK_BOOL)config_setting_is_aggregate(setting->nat);
  }
 
  mk_inline MK_BOOL LcSettingIsArray (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_is_array(setting->nat);
  }
 
  mk_inline MK_BOOL LcSettingIsGroup (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_is_group(setting->nat);
  }
 
  mk_inline MK_BOOL LcSettingIsList (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_is_list(setting->nat);
  }
 
  mk_inline MK_BOOL LcSettingIsNumber (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_is_number(setting->nat);
  }
 
  mk_inline MK_BOOL LcSettingIsRoot (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_is_root(setting->nat);
  }
 
  mk_inline MK_BOOL LcSettingIsScalar (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return (MK_BOOL)config_setting_is_scalar(setting->nat);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcSettingC,LcSettingC-Lookup,oc_
 
  mk_inline LC_CFS LcSettingLookup (LC_CFS setting, MK_STRN path) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_lookup(setting->nat, path));
  }
 
  // doc-key: LcSettingC,LcSettingC-Lookup,omo
 
  mk_inline enum MkErrorE LcSettingLookupBool (LC_CFSN setting, MK_STRN name, MK_BOOL *value_out) {
    LC_INSTANCE_HDL(setting);
    MK_I32 value_out_val = 0;
    enum LcErrorE errVal = (enum LcErrorE)config_setting_lookup_bool(setting->nat, name, &value_out_val);
    *value_out = (MK_BOOL)(value_out_val);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingLookupFloat (LC_CFSN setting, MK_STRN name, MK_DBL *value_out) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_lookup_float(setting->nat, name, value_out);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingLookupInt (LC_CFSN setting, MK_STRN name, MK_I32 *value_out) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_lookup_int(setting->nat, name, value_out);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingLookupInt64 (LC_CFSN setting, MK_STRN name, MK_I64 *value_out) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_lookup_int64(setting->nat, name, value_out);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingLookupString (LC_CFSN setting, MK_STRN name, MK_STRN *value_out) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_lookup_string(setting->nat, name, value_out);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcSettingC,LcSettingC-Misc,oc_
 
  mk_inline LC_CFS LcSettingParent (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_parent(setting->nat));
  }
 
  // doc-key: LcSettingC,LcSettingC-Misc,om_
 
  mk_inline MK_I32 LcSettingIndex (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_index(setting->nat);
  }
 
  mk_inline MK_I32 LcSettingLength (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return config_setting_length(setting->nat);
  }
 
  mk_inline MK_STRN LcSettingName (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    MK_STRN __retVal__L = config_setting_name(setting->nat);
    return __retVal__L;
  }
 
  mk_inline enum MkErrorE LcSettingRemove (LC_CFS parent, MK_STRN name) {
    LC_INSTANCE_HDL(parent);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_remove(parent->nat, name);
    LcErrorE_Check(parent, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingRemoveElem (LC_CFS parent, MK_I32 idx) {
    LC_INSTANCE_HDL(parent);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_remove_elem(parent->nat, (MK_U32)idx);
    LcErrorE_Check(parent, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline MK_STRN LcSettingSourceFile (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    MK_STRN __retVal__L = config_setting_source_file(setting->nat);
    return __retVal__L;
  }
 
  mk_inline MK_I32 LcSettingSourceLine (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return (MK_I32)config_setting_source_line(setting->nat);
  }
 
  mk_inline enum LcConfigTypeE LcSettingType (LC_CFSN setting) {
    LC_INSTANCE_HDL(setting);
    return (enum LcConfigTypeE)config_setting_type(setting->nat);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcSettingC,LcSettingC-Set,oc_
 
  mk_inline LC_CFS LcSettingSetBoolElem (LC_CFS setting, MK_I32 idx, MK_I32 value) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_set_bool_elem(setting->nat, idx, value));
  }
 
  mk_inline LC_CFS LcSettingSetFloatElem (LC_CFS setting, MK_I32 idx, MK_DBL value) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_set_float_elem(setting->nat, idx, value));
  }
 
  mk_inline LC_CFS LcSettingSetInt64Elem (LC_CFS setting, MK_I32 idx, MK_I64 value) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_set_int64_elem(setting->nat, idx, value));
  }
 
  mk_inline LC_CFS LcSettingSetIntElem (LC_CFS setting, MK_I32 idx, MK_I32 value) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_set_int_elem(setting->nat, idx, value));
  }
 
  mk_inline LC_CFS LcSettingSetStringElem (LC_CFS setting, MK_I32 idx, MK_STRN value) {
    LC_INSTANCE_HDL(setting);
    return LcSettingC_ObjNew(config_setting_set_string_elem(setting->nat, idx, value));
  }
 
  // doc-key: LcSettingC,LcSettingC-Set,om_
 
  mk_inline enum MkErrorE LcSettingSetBool (LC_CFS setting, MK_BOOL value) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_set_bool(setting->nat, value);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingSetFloat (LC_CFS setting, MK_DBL value) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_set_float(setting->nat, value);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingSetFormat (LC_CFS setting, enum LcConfigFormatE format) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_set_format(setting->nat, format);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline void LcSettingSetHookHide (LC_CFS setting, MK_PTR hook) {
    LC_INSTANCE_HDL(setting);
    config_setting_set_hook(setting->nat, (MK_PTR)(hook));
  }
 
  mk_inline enum MkErrorE LcSettingSetInt (LC_CFS setting, MK_I32 value) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_set_int(setting->nat, value);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingSetInt64 (LC_CFS setting, MK_I64 value) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_set_int64(setting->nat, value);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcSettingSetString (LC_CFS setting, MK_STRN value) {
    LC_INSTANCE_HDL(setting);
    enum LcErrorE errVal = (enum LcErrorE)config_setting_set_string(setting->nat, value);
    LcErrorE_Check(setting, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcSettingC,LcSettingC-TOR,oC_
 
  mk_inline LC_CFS LcSettingAdd (LC_CFS parent, MK_STRN name, enum LcConfigTypeE __type) {
    LC_INSTANCE_HDL(parent);
    return LcSettingC_ObjCreate(config_setting_add(parent->nat, name, __type));
  }
#endif
 
// END-LcSettingC-inline - created by 'c_Native.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// =================================================================================================
// OVERLOAD
 
MK_ATTR_INSTANCE
mk_inline LC_CFS LcSettingAddIfNotExists ( 
  LC_CFS              setting, 
  MK_STRN             name, 
  enum LcConfigTypeE  cfgtype 
) {
  config_setting_t* mbr = config_setting_get_member(setting->nat,name);
  if (mbr == NULL) {
   mbr = config_setting_add ( setting->nat, name, cfgtype );
  }
  return LcSettingC_ObjNew(mbr);
} 
 
__parser__(doc-group=TOR)
MK_ATTR_INSTANCE
mk_inline LC_CFG LcSettingGetConfig (LC_CFSN setting) {
  return LcConfigC_ObjNew(setting->nat->config);
} 
 
MK_ATTR_INSTANCE
mk_inline bool LcSettingExists (
  const LC_CFS setting,
  MK_STRN name
) {
  return config_setting_get_member(setting->nat,name) != NULL;
} 
 
// end c++ save definition
END_LC_C_DECLS