void config_setting_copy_simple(config_setting_t *parent, const config_setting_t *src)
{
if (config_setting_is_aggregate(src)) {
config_setting_copy_aggregate(parent, src);
}
else {
config_setting_t *set;
if( config_setting_get_member(parent, config_setting_name(src)) != NULL )
return;
if ((set = config_setting_add(parent, config_setting_name(src), config_setting_type(src))) == NULL)
return;
if (CONFIG_TYPE_INT == config_setting_type(src)) {
config_setting_set_int(set, config_setting_get_int(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_INT64 == config_setting_type(src)) {
config_setting_set_int64(set, config_setting_get_int64(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_FLOAT == config_setting_type(src)) {
config_setting_set_float(set, config_setting_get_float(src));
} else if (CONFIG_TYPE_STRING == config_setting_type(src)) {
config_setting_set_string(set, config_setting_get_string(src));
} else if (CONFIG_TYPE_BOOL == config_setting_type(src)) {
config_setting_set_bool(set, config_setting_get_bool(src));
}
}
}
LIBCONFIG_API double config_setting_get_float_elem(
const config_setting_t *vector, int index)
{
config_setting_t *element = config_setting_get_elem(vector, index);
return(element ? config_setting_get_float(element) : 0.0);
}
LIBCONFIG_API double config_lookup_float(const config_t *config,
const char *path)
{
const config_setting_t *s = config_lookup(config, path);
if(! s)
return(0.0);
return(config_setting_get_float(s));
}
int config_setting_lookup_float(const config_setting_t *setting,
const char *name, double *value)
{
config_setting_t *member = config_setting_get_member(setting, name);
if(! member)
return(CONFIG_FALSE);
if(config_setting_type(member) != CONFIG_TYPE_FLOAT)
return(CONFIG_FALSE);
*value = config_setting_get_float(member);
return(CONFIG_TRUE);
}
int config_lookup_float(const config_t *config, const char *path,
double *value)
{
const config_setting_t *s = config_lookup(config, path);
if(! s)
return(CONFIG_FALSE);
if(config_setting_type(s) != CONFIG_TYPE_FLOAT)
return(CONFIG_FALSE);
*value = config_setting_get_float(s);
return(CONFIG_TRUE);
}
static void get_value_libconfig(const config_setting_t *e, void *dest)
{
int type = config_setting_type(e);
switch (type) {
case CONFIG_TYPE_INT:
*(int *)dest = config_setting_get_int(e);
case CONFIG_TYPE_INT64:
*(long long *)dest = config_setting_get_int64(e);
break;
case CONFIG_TYPE_STRING:
dest = (void *)config_setting_get_string(e);
break;
case CONFIG_TYPE_BOOL:
*(int *)dest = config_setting_get_bool(e);
break;
case CONFIG_TYPE_FLOAT:
*(double *)dest = config_setting_get_float(e);
/* Do nothing, add if needed */
}
}
void config_setting_copy_elem(config_setting_t *parent, const config_setting_t *src)
{
config_setting_t *set = NULL;
if (config_setting_is_aggregate(src))
config_setting_copy_aggregate(parent, src);
else if (CONFIG_TYPE_INT == config_setting_type(src)) {
set = config_setting_set_int_elem(parent, -1, config_setting_get_int(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_INT64 == config_setting_type(src)) {
set = config_setting_set_int64_elem(parent, -1, config_setting_get_int64(src));
config_setting_set_format(set, src->format);
} else if (CONFIG_TYPE_FLOAT == config_setting_type(src)) {
config_setting_set_float_elem(parent, -1, config_setting_get_float(src));
} else if (CONFIG_TYPE_STRING == config_setting_type(src)) {
config_setting_set_string_elem(parent, -1, config_setting_get_string(src));
} else if (CONFIG_TYPE_BOOL == config_setting_type(src)) {
config_setting_set_bool_elem(parent, -1, config_setting_get_bool(src));
}
}
/**
* Print a configuration setting.
* @param f File stream to print to
* @param cs Configuration setting
* @param d Current depth.
*/
static void config_setting_fprint(FILE *f, config_setting_t * cs, int d)
{
assert(cs && d >= 0);
int i;
for (i = 0; i < d; i++)
fprintf(f, " ");
char *n = config_setting_name(cs);
switch (config_setting_type(cs)) {
case CONFIG_TYPE_GROUP:
if (d > 0)
fprintf(f, "%s = {\n", n);
for (i = 0; i < config_setting_length(cs); i++)
config_setting_fprint(f, config_setting_get_elem(cs, i), d + 1);
if (d > 0) {
for (i = 0; i < d; i++)
fprintf(f, " ");
fprintf(f, "};\n");
}
break;
case CONFIG_TYPE_STRING:
fprintf(f, "%s\t= \"%s\";\n", n, config_setting_get_string(cs));
break;
case CONFIG_TYPE_FLOAT:
fprintf(f, "%s\t= %7.5f;\n", n, config_setting_get_float(cs));
break;
case CONFIG_TYPE_INT:
fprintf(f, "%s\t= %d;\n", n, config_setting_get_int(cs));
break;
default:
error("Unsupported type for configuration setting '%s'", n);
}
}
/*********************
return RET_NOK on error
*********************/
ret_code_t entry_copy_config(config_setting_t * source, config_setting_t * dest)
{
config_setting_t * new_source;
config_setting_t * new_dest;
int index = -1;
int int_value;
long long long_value;
double double_value;
const char * string;
while((new_source=config_setting_get_elem(source,index+1))!= NULL ) {
index++;
if(config_setting_is_group(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_GROUP)) {
return RET_NOK;
}
}
else if(config_setting_is_array(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_ARRAY)) {
return RET_NOK;
}
}
else if(config_setting_is_list(new_source)) {
if(!entry_copy_aggregate(new_source,dest,CONFIG_TYPE_LIST)) {
return RET_NOK;
}
}
else {
switch(config_setting_type(new_source)) {
case CONFIG_TYPE_INT:
int_value = config_setting_get_int(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT);
config_setting_set_int(new_dest,int_value);
continue;
case CONFIG_TYPE_INT64:
long_value = config_setting_get_int64(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_INT64);
config_setting_set_int64(new_dest,long_value);
continue;
case CONFIG_TYPE_FLOAT:
double_value = config_setting_get_float(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_FLOAT);
config_setting_set_float(new_dest,double_value);
continue;
case CONFIG_TYPE_BOOL:
int_value = config_setting_get_bool(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_BOOL);
config_setting_set_bool(new_dest,int_value);
continue;
case CONFIG_TYPE_STRING:
string = config_setting_get_string(new_source);
new_dest = config_setting_add (dest, config_setting_name(new_source),CONFIG_TYPE_STRING);
config_setting_set_string(new_dest,string);
continue;
default:
return RET_NOK;
}
}
}
return RET_OK;
}
int writeCfgState(void) {
config_t cfg;
config_setting_t *ttempState = 0;
config_setting_t *thumState = 0;
config_setting_t *tRHeatTS = 0;
config_setting_t *tRHumTS = 0;
config_setting_t *tRHepaTS = 0;
config_setting_t *tRFanTS = 0;
config_setting_t *twfactor = 0;
config_setting_t *trelay1o = 0;
config_setting_t *trelay2o = 0;
config_setting_t *trelay3o = 0;
config_setting_t *trelay4o = 0;
config_setting_t *trelay5o = 0;
config_setting_t *trelay6o = 0;
config_setting_t *trelay7o = 0;
config_setting_t *trelay8o = 0;
config_init(&cfg);
if (!config_read_file(&cfg, config_state_path))
{
printf("\n%s:%d - %s", config_error_file(&cfg), config_error_line(&cfg), config_error_text(&cfg));
config_destroy(&cfg);
return -1;
}
/* lookup variables in config file */
ttempState = config_lookup(&cfg, "tempState");
thumState = config_lookup(&cfg, "humState");
trelay1o = config_lookup(&cfg, "relay1o");
trelay2o = config_lookup(&cfg, "relay2o");
trelay3o = config_lookup(&cfg, "relay3o");
trelay4o = config_lookup(&cfg, "relay4o");
trelay5o = config_lookup(&cfg, "relay5o");
trelay6o = config_lookup(&cfg, "relay6o");
trelay7o = config_lookup(&cfg, "relay7o");
trelay8o = config_lookup(&cfg, "relay8o");
tRHeatTS = config_lookup(&cfg, "RHeatTS");
tRHumTS = config_lookup(&cfg, "RHumTS");
tRHepaTS = config_lookup(&cfg, "RHepaTS");
tRFanTS = config_lookup(&cfg, "RFanTS");
twfactor = config_lookup(&cfg, "wfactor");
/* get variables from config file then print the variables that changed */
if (config_setting_get_int(ttempState) != tempState) {
printf("\ntempState: %i -> ", config_setting_get_int(ttempState));
config_setting_set_int(ttempState, tempState);
printf("%i", config_setting_get_int(ttempState));
}
if (config_setting_get_int(thumState) != humState) {
printf("\nhumState: %i -> ", config_setting_get_int(thumState));
config_setting_set_int(thumState, humState);
printf("%i", config_setting_get_int(thumState));
}
if (config_setting_get_int(trelay1o) != relay1o) {
printf("\nrelay1o: %i -> ", config_setting_get_int(trelay1o));
config_setting_set_int(trelay1o, relay1o);
printf("%i", config_setting_get_int(trelay1o));
}
if (config_setting_get_int(trelay2o) != relay2o) {
printf("\nrelay2o: %i -> ", config_setting_get_int(trelay2o));
config_setting_set_int(trelay2o, relay2o);
printf("%i", config_setting_get_int(trelay2o));
}
if (config_setting_get_int(trelay3o) != relay3o) {
printf("\nrelay3o: %i -> ", config_setting_get_int(trelay3o));
config_setting_set_int(trelay3o, relay3o);
printf("%i", config_setting_get_int(trelay3o));
}
if (config_setting_get_int(trelay4o) != relay4o) {
printf("\nrelay4o: %i -> ", config_setting_get_int(trelay4o));
config_setting_set_int(trelay4o, relay4o);
printf("%i", config_setting_get_int(trelay4o));
}
if (config_setting_get_int(trelay5o) != relay5o) {
printf("\nrelay5o: %i -> ", config_setting_get_int(trelay5o));
config_setting_set_int(trelay5o, relay5o);
printf("%i", config_setting_get_int(trelay5o));
}
if (config_setting_get_int(trelay6o) != relay6o) {
printf("\nrelay6o: %i -> ", config_setting_get_int(trelay6o));
config_setting_set_int(trelay6o, relay6o);
printf("%i", config_setting_get_int(trelay6o));
}
if (config_setting_get_int(trelay7o) != relay7o) {
printf("\nrelay7o: %i -> ", config_setting_get_int(trelay7o));
config_setting_set_int(trelay7o, relay7o);
printf("%i", config_setting_get_int(trelay7o));
}
if (config_setting_get_int(trelay8o) != relay8o) {
printf("\nrelay8o: %i -> ", config_setting_get_int(trelay8o));
config_setting_set_int(trelay8o, relay8o);
printf("%i", config_setting_get_int(trelay8o));
}
if (config_setting_get_int(tRHeatTS) != RHeatTS) {
printf("\nRHeatTS: %i -> ", config_setting_get_int(tRHeatTS));
config_setting_set_int(tRHeatTS, RHeatTS);
printf("%i", config_setting_get_int(tRHeatTS));
}
if (config_setting_get_int(tRHumTS) != RHumTS) {
printf("\nRHumTS: %i -> ", config_setting_get_int(tRHumTS));
config_setting_set_int(tRHumTS, RHumTS);
printf("%i", config_setting_get_int(tRHumTS));
}
if (config_setting_get_int(tRHepaTS) != RHepaTS) {
printf("\nRHepaTS: %i -> ", config_setting_get_int(tRHepaTS));
config_setting_set_int(tRHepaTS, RHepaTS);
printf("%i", config_setting_get_int(tRHepaTS));
}
if (config_setting_get_int(tRFanTS) != RFanTS) {
printf("\nRFanTS: %i -> ", config_setting_get_int(tRFanTS));
config_setting_set_int(tRFanTS, RFanTS);
printf("%i", config_setting_get_int(tRFanTS));
}
if (config_setting_get_float(twfactor) != wfactor) {
printf("\nwfactor: %i -> ", config_setting_get_float(twfactor));
config_setting_set_float(twfactor, wfactor);
printf("%i", config_setting_get_float(twfactor));
}
/* write the modified config file */
config_write_file(&cfg, config_state_path);
config_destroy(&cfg);
return 0;
}
double config_setting_get_float_elem(const struct config_setting_t *vector, int idx)
{
struct config_setting_t *element = config_setting_get_elem(vector, idx);
return(element ? config_setting_get_float(element) : 0.0);
}
