LcConfigC_lc.h

Go to the documentation of this file.

 
/* LABEL-START */
#pragma once
 
#include "LibLcConfig_lc.h"
/* LABEL-END */
 
#include "LcConfigC_def_lc.h"
#include "LcSettingC_def_lc.h"
 
BEGIN_LC_C_DECLS
 
/* MARK_C ################################################################ */
/* ###                                                                 ### */
/* ###                      C O N F I G - A P I                        ### */
/* ###                                                                 ### */
/* ####################################################################### */
 
 
// doc-key: LcConfigC,LcConfigC-TOR,sCc
 
__parser__(constructor,lng-constr)
MK_ATTR_STATIC
mk_inline LC_CFG LcConfigCreate (
  MK_TYP        type    __parser__(internal,default=NULL),
  config_t      *nat    __parser__(internal,keep-original-type,default=NULL)
) {
  MkRtSetup_NULL;
  if (LcConfigC_TT == NULL) {
    MkErrorSetC_1E("initialization failed, use 'LcConfig.Setup()' at startup");
    return NULL;
  }
    
  if (type == NULL) type = LcConfigC_TT;
  return (LC_CFG)MkObjCreate(type,nat,NULL);
} 
 
__parser__(destructor)
LC_EXTERN void MK_DECL LcConfigDelete_RT (
  MK_PARSER_RT
  LC_CFG const cfg
) MK_ATTR_RT_INSTANCE;
 
// LcConfigC_TOR_C_API
 
// ======================================================================================================
 
// \brief \b addon - check if \arg{cfg} is \null …
// mk_inline bool LcConfigIsNullI ( LC_CFG const cfg ) {
//   return cfg->nat == NULL;
// }
 
// \brief \b addon - check if \arg{cfg} is \null …
// __parser__(inline=LcConfigIsNullI)
// LC_EXTERN MK_BOOL MK_DECL LcConfigIsNull(LC_CFG cfg);
 
__parser__(internal,no-alias,overload-c-no,class=LcConfigC)
LC_EXTERN enum MkErrorE MK_DECL LcConfigIncludeCall ( 
    LcConfigIncludeCallF_ARGS
);
 
__parser__(internal,no-alias,class=LcConfigC)
LC_EXTERN void MK_DECL LcConfigIncludeFree ( 
    LcConfigIncludeFreeF_ARGS
);
 
// [LcConfigSetIncludeFunc_RT]
__parser__(callback-name=ConfigInclude, callback-null)
LC_EXTERN enum MkErrorE MK_DECL LcConfigSetIncludeFunc_RT ( 
  MK_PARSER_RT
  LC_CFG const          cfg, 
  LcConfigIncludeCallF  fConfigIncludeCall  __parser__(callback-call) ,
  LC_CBP                fConfigIncludeData  __parser__(callback-data) ,
  LcConfigIncludeFreeF  fConfigIncludeFree  __parser__(callback-free)
) MK_ATTR_RT_INSTANCE;
// [LcConfigSetIncludeFunc_RT]
 
MK_ATTR_INSTANCE
mk_inline MK_PTR MK_DECL LcConfigGetIncludeFunc (
  LC_CFG const          cfg
) {
  return cfg ? cfg->fConfigIncludeData : NULL;
} 
 
__parser__( callback-name=SettingDelete, callback-null)
LC_EXTERN enum MkErrorE MK_DECL LcConfigSetSettingDeleteFunc_RT ( 
  MK_PARSER_RT
  LC_CFG const          cfg, 
  LcSettingDeleteCallF  fSettingDeleteCall  __parser__(callback-call), 
  LC_CBP                fSettingDeleteData  __parser__(callback-data),
  LcSettingDeleteFreeF  fSettingDeleteFree  __parser__(callback-free)
) MK_ATTR_RT_INSTANCE;
 
__parser__(hide)
MK_ATTR_INSTANCE
mk_inline MK_PTR MK_DECL LcConfigGetSettingDeleteFunc (
  LC_CFG const          cfg
) {
  return cfg ? cfg->fSettingDeleteData : NULL;
} 
 
__parser__(no-alias)
LC_EXTERN enum MkErrorE MK_DECL LcConfigWriteString_RT ( 
  MK_PARSER_RT
  LC_CFGN const      cfg,
  MK_STRN            *val_out
) MK_ATTR_RT_INSTANCE;
 
__parser__(const,flags=new)
LC_EXTERN void MK_DECL LcConfigLog_RT (
  MK_PARSER_RT
  LC_CFGN const  cfg        ,
  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 ;
 
 
// =========================================================================
// BEGIN-LcConfigC-fupu - created by 'c_Native.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// -> no data
 
// END-LcConfigC-fupu - created by 'c_Native.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
 
// =========================================================================
// BEGIN-LcConfigC-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: LcConfigC,LcConfigC-Error,om_
 
  mk_inline enum LcErrorTypeE LcConfigErrorType (LC_CFGN config) {
    LC_INSTANCE_HDL(config);
    return (enum LcErrorTypeE)config_error_type(config->nat);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcConfigC,LcConfigC-Get,om_
 
  mk_inline enum LcConfigFormatE LcConfigGetDefaultFormat (LC_CFGN config) {
    LC_INSTANCE_HDL(config);
    return (enum LcConfigFormatE)config_get_default_format(config->nat);
  }
 
  mk_inline MK_I16 LcConfigGetFloatPrecision (LC_CFGN config) {
    LC_INSTANCE_HDL(config);
    return (MK_I16)config_get_float_precision(config->nat);
  }
 
  mk_inline MK_STRN LcConfigGetIncludeDir (LC_CFGN config) {
    LC_INSTANCE_HDL(config);
    MK_STRN __retVal__L = config_get_include_dir(config->nat);
    return __retVal__L;
  }
 
  mk_inline MK_BOOL LcConfigGetOption (LC_CFGN config, enum LcConfigOptionsEF option) {
    LC_INSTANCE_HDL(config);
    return (MK_BOOL)config_get_option(config->nat, option);
  }
 
  mk_inline enum LcConfigOptionsEF LcConfigGetOptions (LC_CFGN config) {
    LC_INSTANCE_HDL(config);
    return (enum LcConfigOptionsEF)config_get_options(config->nat);
  }
 
  mk_inline MK_I16 LcConfigGetTabWidth (LC_CFGN config) {
    LC_INSTANCE_HDL(config);
    return (MK_I16)config_get_tab_width(config->nat);
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcConfigC,LcConfigC-Lookup,oc_
 
  mk_inline LC_CFS LcConfigLookup (LC_CFGN config, MK_STRN path) {
    LC_INSTANCE_HDL(config);
    return LcSettingC_ObjNew(config_lookup(config->nat, path));
  }
 
  // doc-key: LcConfigC,LcConfigC-Lookup,omo
 
  mk_inline enum MkErrorE LcConfigLookupBool (LC_CFGN config, MK_STRN path, MK_BOOL *value_out) {
    LC_INSTANCE_HDL(config);
    MK_I32 value_out_val = 0;
    enum LcErrorE errVal = (enum LcErrorE)config_lookup_bool(config->nat, path, &value_out_val);
    *value_out = (MK_BOOL)(value_out_val);
    LcErrorE_Check(config, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcConfigLookupFloat (LC_CFGN config, MK_STRN path, MK_DBL *value_out) {
    LC_INSTANCE_HDL(config);
    enum LcErrorE errVal = (enum LcErrorE)config_lookup_float(config->nat, path, value_out);
    LcErrorE_Check(config, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcConfigLookupInt (LC_CFGN config, MK_STRN path, MK_I32 *value_out) {
    LC_INSTANCE_HDL(config);
    enum LcErrorE errVal = (enum LcErrorE)config_lookup_int(config->nat, path, value_out);
    LcErrorE_Check(config, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcConfigLookupInt64 (LC_CFGN config, MK_STRN path, MK_I64 *value_out) {
    LC_INSTANCE_HDL(config);
    enum LcErrorE errVal = (enum LcErrorE)config_lookup_int64(config->nat, path, value_out);
    LcErrorE_Check(config, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcConfigLookupString (LC_CFGN config, MK_STRN path, MK_STRN *value_out) {
    LC_INSTANCE_HDL(config);
    enum LcErrorE errVal = (enum LcErrorE)config_lookup_string(config->nat, path, value_out);
    LcErrorE_Check(config, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcConfigC,LcConfigC-Misc,oc_
 
  mk_inline LC_CFS LcConfigRootSetting (LC_CFGN config) {
    LC_INSTANCE_HDL(config);
    return LcSettingC_ObjNew(config_root_setting(config->nat));
  }
 
  // doc-key: LcConfigC,LcConfigC-Misc,om_
 
  mk_inline void LcConfigClear (LC_CFG config) {
    LC_INSTANCE_HDL(config);
    config_clear(config->nat);
  }
 
  mk_inline enum MkErrorE LcConfigReadFile (LC_CFG config, MK_STRN filename) {
    LC_INSTANCE_HDL(config);
    enum LcErrorE errVal = (enum LcErrorE)config_read_file(config->nat, filename);
    LcErrorE_Check(config, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcConfigReadString (LC_CFG config, MK_STRN str) {
    LC_INSTANCE_HDL(config);
    enum LcErrorE errVal = (enum LcErrorE)config_read_string(config->nat, str);
    LcErrorE_Check(config, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
 
  mk_inline enum MkErrorE LcConfigWriteFile (LC_CFG config, MK_STRN filename) {
    LC_INSTANCE_HDL(config);
    enum LcErrorE errVal = (enum LcErrorE)config_write_file(config->nat, filename);
    LcErrorE_Check(config, errVal);
    return MK_OK;
  error:
    return MK_ERROR;
  }
#endif
 
#ifndef PARSE_C_HEADER_TO_META
 
  // doc-key: LcConfigC,LcConfigC-Set,om_
 
  mk_inline void LcConfigSetDefaultFormat (LC_CFG config, enum LcConfigFormatE format) {
    LC_INSTANCE_HDL(config);
    config_set_default_format(config->nat, format);
  }
 
  mk_inline void LcConfigSetFloatPrecision (LC_CFG config, MK_I16 digits) {
    LC_INSTANCE_HDL(config);
    config_set_float_precision(config->nat, (MK_U16)digits);
  }
 
  mk_inline void LcConfigSetIncludeDir (LC_CFG config, MK_STRN include_dir) {
    LC_INSTANCE_HDL(config);
    config_set_include_dir(config->nat, include_dir);
  }
 
  mk_inline void LcConfigSetIncludeFuncHide (LC_CFG config, config_include_fn_t func) {
    LC_INSTANCE_HDL(config);
    config_set_include_func(config->nat, func);
  }
 
  mk_inline void LcConfigSetOption (LC_CFG config, enum LcConfigOptionsEF option, MK_BOOL flag) {
    LC_INSTANCE_HDL(config);
    config_set_option(config->nat, option, flag);
  }
 
  mk_inline void LcConfigSetOptions (LC_CFG config, enum LcConfigOptionsEF options) {
    LC_INSTANCE_HDL(config);
    config_set_options(config->nat, options);
  }
 
  mk_inline void LcConfigSetTabWidth (LC_CFG config, MK_I16 width) {
    LC_INSTANCE_HDL(config);
    config_set_tab_width(config->nat, (MK_U16)width);
  }
#endif
 
// END-LcConfigC-inline - created by 'c_Native.tcl -i NHI1_HOME/theConfig/c/gen/c_lcconfig.meta' - DO NOT change
  
END_LC_C_DECLS