int writeCfgCond(void) {
config_t cfg;
config_setting_t *tminTemp = 0;
config_setting_t *tmaxTemp = 0;
config_setting_t *tminHum = 0;
config_setting_t *tmaxHum = 0;
config_setting_t *twebOR = 0;
config_init(&cfg);
if (!config_read_file(&cfg, config_cond_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 */
tminTemp = config_lookup(&cfg, "minTemp");
tmaxTemp = config_lookup(&cfg, "maxTemp");
tminHum = config_lookup(&cfg, "minHum");
tmaxHum = config_lookup(&cfg, "maxHum");
twebOR = config_lookup(&cfg, "webOR");
/* get variables from config file then print the variables that changed */
if (config_setting_get_int(tminTemp) != minTemp) {
printf("\nminTemp: %i -> ", config_setting_get_int(tminTemp));
config_setting_set_int(tminTemp, minTemp);
printf("%i", config_setting_get_int(tminTemp));
}
if (config_setting_get_int(tmaxTemp) != maxTemp) {
printf("\nmaxTemp: %i -> ", config_setting_get_int(tmaxTemp));
config_setting_set_int(tmaxTemp, maxTemp);
printf("%i", config_setting_get_int(tmaxTemp));
}
if (config_setting_get_int(tminHum) != minHum) {
printf("\nminHum: %i -> ", config_setting_get_int(tminHum));
config_setting_set_int(tminHum, minHum);
printf("%i", config_setting_get_int(tminHum));
}
if (config_setting_get_int(tmaxHum) != maxHum) {
printf("\nmaxHum: %i -> ", config_setting_get_int(tmaxHum));
config_setting_set_int(tmaxHum, maxHum);
printf("%i", config_setting_get_int(tmaxHum));
}
if (config_setting_get_int(twebOR) != webOR) {
printf("\nwebOR: %i -> ", config_setting_get_int(twebOR));
config_setting_set_int(twebOR, webOR);
printf("%i", config_setting_get_int(twebOR));
}
/* write the modified config file */
config_write_file(&cfg, config_cond_path);
config_destroy(&cfg);
return 0;
}
config_setting_t *config_setting_set_int_elem(config_setting_t *vector,
int idx, int value)
{
config_setting_t *element = NULL;
if((vector->type != CONFIG_TYPE_ARRAY) && (vector->type != CONFIG_TYPE_LIST))
return(NULL);
if(idx < 0)
{
if(! __config_vector_checktype(vector, CONFIG_TYPE_INT))
return(NULL);
element = config_setting_create(vector, NULL, CONFIG_TYPE_INT);
}
else
{
element = config_setting_get_elem(vector, idx);
if(! element)
return(NULL);
}
if(! config_setting_set_int(element, value))
return(NULL);
return(element);
}
int main()
{
/* Initialize the configuration */
config_init(&cfg);
/* Load the file */
printf("loading [test.cfg]..");
if (!config_load_file(&cfg, "test.cfg")) printf("failed\n");
else {
printf("ok\n");
/* Add setting "foo" */
printf("add setting \"foo\"..");
config_setting_t *setting = config_setting_add(cfg.root,"foo",CONFIG_TYPE_INT);
if (!setting) printf("failed\n");
else {
config_setting_set_int(setting,1234);
printf("ok\n");
/* Save to "testfoo.cfg" */
printf("saving [testfoo.cfg]..");
config_save_file(&cfg, "testfoo.cfg");
printf("ok\n");
printf("Done!\n");
}
}
/* Free the configuration */
config_destroy(&cfg);
return 0;
}
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));
}
}
}
int main(int argc, char **argv)
{
static const char *output_file = "newconfig.cfg";
config_t cfg;
config_setting_t *root, *setting, *group, *array;
int i;
config_init(&cfg);
root = config_root_setting(&cfg);
/* Add some settings to the configuration. */
group = config_setting_add(root, "address", CONFIG_TYPE_GROUP);
setting = config_setting_add(group, "street", CONFIG_TYPE_STRING);
config_setting_set_string(setting, "1 Woz Way");
setting = config_setting_add(group, "city", CONFIG_TYPE_STRING);
config_setting_set_string(setting, "San Jose");
setting = config_setting_add(group, "state", CONFIG_TYPE_STRING);
config_setting_set_string(setting, "CA");
setting = config_setting_add(group, "zip", CONFIG_TYPE_INT);
config_setting_set_int(setting, 95110);
array = config_setting_add(root, "numbers", CONFIG_TYPE_ARRAY);
for(i = 0; i < 10; ++i)
{
setting = config_setting_add(array, NULL, CONFIG_TYPE_INT);
config_setting_set_int(setting, 10 * i);
}
/* Write out the new configuration. */
if(! config_write_file(&cfg, output_file))
{
fprintf(stderr, "Error while writing file.\n");
config_destroy(&cfg);
return(EXIT_FAILURE);
}
fprintf(stderr, "New configuration successfully written to: %s\n",
output_file);
config_destroy(&cfg);
return(EXIT_SUCCESS);
}
/*********************************************
Update an entry from a network frame
return RET_NOK on error
*********************************************/
ret_code_t entry_update(char * data)
{
char * elements[5] = {NULL,NULL,NULL,NULL,NULL};
config_setting_t * setting;
const config_t * config= NULL;
int value;
char * token;
int index = 0;
ret_code_t ret = RET_NOK;
token = _strsep(&data,NETWORK_DELIMITER);
while( token != NULL ) {
elements[index] = strdup(token);
index++;
if(index>5) {
werr(LOGDEV,"Split string error");
goto entry_update_cleanup;
}
token = _strsep(&data,NETWORK_DELIMITER);
}
SDL_LockMutex(entry_mutex);
config = get_config(elements[1],elements[2]);
if(config==NULL) {
goto entry_update_cleanup;
}
setting = config_lookup (config, elements[3]);
if(setting==NULL) {
goto entry_update_cleanup;
}
if( strcmp(elements[0],ENTRY_TYPE_INT) == 0 ) {
value = atoll(elements[4]);
if(config_setting_set_int (setting, value) == CONFIG_FALSE) {
werr(LOGUSER,"Errror setting %s/%s/%s to %d",elements[1],elements[2],elements[3],value);
} else {
write_config(config,elements[1],elements[2]);
}
} else if( strcmp(elements[0],ENTRY_TYPE_STRING) == 0 ) {
if(config_setting_set_string (setting,elements[4]) == CONFIG_FALSE) {
werr(LOGUSER,"Errror setting %s/%s/%s to %s",elements[1],elements[2],elements[3],elements[4]);
} else {
write_config(config,elements[1],elements[2]);
}
}
ret = RET_OK;
entry_update_cleanup:
SDL_UnlockMutex(entry_mutex);
for(index=0; index<5; index++) {
if(elements[index]) {
free(elements[index]);
}
}
return ret;
}
void MainDialog::configSetInt(const char* key, int val) {
config_setting_t* setting = config_lookup(&config_, key);
if(!setting) { // setting not found
// add a new setting for it
config_setting_t* root = config_root_setting(&config_);
setting = config_setting_add(root, key, CONFIG_TYPE_INT);
}
config_setting_set_int(setting, val);
}
int store_settings(char *cfg_file,
int show_line_numbers,
int show_lang,
int show_spelling_errors,
int defualt_window_width,
int default_window_height,
int undo_level,
int show_full_path
#ifdef AUTO_TAB_TOGGLE
,
int auto_tab
#endif
){
config_t cfg;
config_setting_t *root, *setting, *group, *UI;
config_init(&cfg);
int ret=0;
root = config_root_setting(&cfg);
group = config_setting_add(root,"User_Pref", CONFIG_TYPE_GROUP);
setting = config_setting_add(group,"LineNumbers", CONFIG_TYPE_INT);
config_setting_set_int(setting, show_line_numbers);
setting = config_setting_add(group,"Spelling", CONFIG_TYPE_INT);
config_setting_set_int(setting, show_spelling_errors);
setting = config_setting_add(group,"ShowLang", CONFIG_TYPE_INT);
config_setting_set_int(setting, show_lang);
#ifdef AUTO_TAB_TOGGLE
setting = config_setting_add(group,"Auto_Tab", CONFIG_TYPE_INT);
config_setting_set_int(setting, auto_tab);
#endif
setting = config_setting_add(group,"Show_Full_Path", CONFIG_TYPE_INT);
config_setting_set_int(setting, show_full_path);
UI = config_setting_add(root,"User_Interface_Settings", CONFIG_TYPE_GROUP);
setting = config_setting_add(UI,"Default_Window_Width", CONFIG_TYPE_INT);
config_setting_set_int(setting, defualt_window_width);
setting = config_setting_add(UI,"Default_Window_Height", CONFIG_TYPE_INT);
config_setting_set_int(setting, default_window_height);
setting = config_setting_add(UI,"Undo_Level", CONFIG_TYPE_INT);
config_setting_set_int(setting, undo_level);
if (! config_write_file(&cfg,(char*)cfg_file)) ret=0;
else ret=1;
config_destroy(&cfg);
return(ret);
}
config_setting_t *cfgSetInt(config_setting_t *parent, const TCHAR *name, int value)
{
config_setting_t *setting;
char uName[CONFIG_UTF8_MAXSTRING];
UTF8_Encode(name, uName, CONFIG_UTF8_MAXSTRING);
setting = config_setting_add(parent, uName, CONFIG_TYPE_INT);
config_setting_set_int(setting, value);
return setting;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int general_settings_save_configuration (config_setting_t *setting)
{
config_setting_t *s = NULL ;
s = config_setting_add(setting, "path_1_wire_directory", CONFIG_TYPE_STRING) ;
if (s != NULL) config_setting_set_string(s, path_1_wire_directory->str);
s = config_setting_add(setting, "path_data_directory", CONFIG_TYPE_STRING) ;
if (s != NULL) config_setting_set_string(s, path_data_directory->str);
s = config_setting_add(setting, "write_samples_interval", CONFIG_TYPE_INT) ;
if (s != NULL) config_setting_set_int(s, write_samples_interval);
return 0 ;
} ;
void Settings::Save()
{
config_t cfg;
config_setting_t *root, *setting, *group;
config_init(&cfg);
root = config_root_setting(&cfg);
group = config_setting_add(root, "Graphics", CONFIG_TYPE_GROUP);
setting = config_setting_add(group, "Fullscreen", CONFIG_TYPE_INT);
config_setting_set_int(setting, FullScreen);
group = config_setting_add(root, "Audio", CONFIG_TYPE_GROUP);
setting = config_setting_add(group, "PlaySFX", CONFIG_TYPE_INT);
config_setting_set_int(setting, PlaySFX);
setting = config_setting_add(group, "PlayMusic", CONFIG_TYPE_INT);
config_setting_set_int(setting, PlayMusic);
group = config_setting_add(root, "Input", CONFIG_TYPE_GROUP);
setting = config_setting_add(group, "keyLeft", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyLeft);
setting = config_setting_add(group, "keyRight", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyRight);
setting = config_setting_add(group, "keyUp", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyUp);
setting = config_setting_add(group, "keyDown", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyDown);
setting = config_setting_add(group, "keyFire1", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyFire1);
setting = config_setting_add(group, "keyFire2", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyFire2);
setting = config_setting_add(group, "keyQuit", CONFIG_TYPE_INT);
config_setting_set_int(setting, keyQuit);
config_write_file( &cfg, "settings.cfg" );
config_destroy(&cfg);
}
int main(int argc, char **argv)
{
char *file = "sample.cfg", *var = "x";
if(argc >= 2)
file = argv[1];
if(argc >= 3)
var = argv[2];
/* Initialize the configuration */
config_init(&cfg);
/* Load the file */
printf("loading [%s]...", file);
if(!config_read_file(&cfg, file))
printf("failed\n");
else
{
config_setting_t *setting = NULL;
printf("ok\n");
/* Get the variable setting from the configuration.. */
printf("increment \"%s\"...", var);
setting = config_lookup(&cfg, var);
if(!setting)
printf("failed\n");
else
{
long x = config_setting_get_int(setting);
x++;
config_setting_set_int(setting, x);
printf("ok (%s=%lu)\n", var, x);
/* Save the changes */
printf("saving [%s]...", file);
config_write_file(&cfg, file);
printf("ok\n");
printf("Done!\n");
}
}
/* Free the configuration */
config_destroy(&cfg);
return 0;
}
/*******************************************************************************
函数名称 : webauth_rdx_set_int_setting
功能描述 : 向配置结构中增加整数型配置
输入参数 : onfig_setting_t * setting 配置结构
char* attr 配置属性名
int val 配置属性值
int def 配置默认属性
输出参数 :
返 回 值 :
--------------------------------------------------------------------------------
最近一次修改记录 :
修改作者 : 王群
修改目的 : 新添加函数
修改日期 : 2010-08-16
*******************************************************************************/
void webauth_rdx_set_int_setting (config_setting_t * setting, char *attr, int val,
int def)
{
config_setting_t *s;
if (val != def)
{
s = config_setting_add (setting, attr, CONFIG_TYPE_INT);
if (NULL != s)
{
config_setting_set_int (s, val);
}
}
return;
}
void rtm_init_params(struct fins_module *module) {
metadata_element *root = config_root_setting(module->params);
metadata_element *exec_elem = config_setting_add(root, "exec", CONFIG_TYPE_GROUP);
if (exec_elem == NULL) {
PRINT_DEBUG("todo error");
exit(-1);
}
metadata_element *get_elem = config_setting_add(root, "get", CONFIG_TYPE_GROUP);
if (get_elem == NULL) {
PRINT_DEBUG("todo error");
exit(-1);
}
metadata_element *set_elem = config_setting_add(root, "set", CONFIG_TYPE_GROUP);
if (set_elem == NULL) {
PRINT_DEBUG("todo error");
exit(-1);
}
metadata_element *sub = config_setting_add(exec_elem, "test", CONFIG_TYPE_GROUP);
if (sub == NULL) {
PRINT_DEBUG("todo error");
exit(-1);
}
metadata_element *elem = config_setting_add(sub, "key", CONFIG_TYPE_INT);
if (elem == NULL) {
PRINT_DEBUG("todo error");
exit(-1);
}
uint32_t value = 10;
int status = config_setting_set_int(elem, *(int *) &value);
if (status == CONFIG_FALSE) {
PRINT_DEBUG("todo error");
exit(-1);
}
}
/*********************
return RET_NOK on error
*********************/
static ret_code_t __write_int(const char * table, const char * file, int data, va_list ap)
{
config_setting_t * setting;
const config_t * config;
SDL_LockMutex(entry_mutex);
config = get_config(table,file);
if(config==NULL) {
SDL_UnlockMutex(entry_mutex);
return RET_NOK;
}
setting = create_tree(config,NULL,NULL,NULL,CONFIG_TYPE_INT,ap);
/* update int */
if(config_setting_set_int(setting, data)==CONFIG_FALSE) {
SDL_UnlockMutex(entry_mutex);
return RET_NOK;
}
write_config(config,table,file);
SDL_UnlockMutex(entry_mutex);
return RET_OK;
}
int writeCfg (void)
{
config_t cfg;
config_setting_t *tonTemp = 0;
config_setting_t *toffTemp = 0;
config_setting_t *thighTemp = 0;
config_setting_t *tonHum = 0;
config_setting_t *toffHum = 0;
config_setting_t *twebOR = 0;
config_setting_t *ttempState = 0;
config_setting_t *thumState = 0;
config_init(&cfg);
if (!config_read_file(&cfg, config_file_name))
{
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 */
tonTemp = config_lookup(&cfg, "onTemp");
toffTemp = config_lookup(&cfg, "offTemp");
thighTemp = config_lookup(&cfg, "highTemp");
tonHum = config_lookup(&cfg, "onHum");
toffHum = config_lookup(&cfg, "offHum");
twebOR = config_lookup(&cfg, "webOR");
ttempState = config_lookup(&cfg, "tempState");
thumState = config_lookup(&cfg, "humState");
/* get variables from config file then print the variables that changed */
if (config_setting_get_int(tonTemp) != onTemp) {
printf("\nonTemp: %i -> ", config_setting_get_int(tonTemp));
config_setting_set_int(tonTemp, onTemp);
printf("%i", config_setting_get_int(tonTemp));
}
if (config_setting_get_int(toffTemp) != offTemp) {
printf("\noffTemp: %i -> ", config_setting_get_int(toffTemp));
config_setting_set_int(toffTemp, offTemp);
printf("%i", config_setting_get_int(toffTemp));
}
if (config_setting_get_int(thighTemp) != highTemp) {
printf("\nhighTemp: %i -> ", config_setting_get_int(thighTemp));
config_setting_set_int(thighTemp, highTemp);
printf("%i", config_setting_get_int(thighTemp));
}
if (config_setting_get_int(tonHum) != onHum) {
printf("\nonHum: %i -> ", config_setting_get_int(tonHum));
config_setting_set_int(tonHum, onHum);
printf("%i", config_setting_get_int(tonHum));
}
if (config_setting_get_int(toffHum) != offHum) {
printf("\noffHum: %i -> ", config_setting_get_int(toffHum));
config_setting_set_int(toffHum, offHum);
printf("%i", config_setting_get_int(toffHum));
}
if (config_setting_get_int(twebOR) != webOR) {
printf("\nwebOR: %i -> ", config_setting_get_int(twebOR));
config_setting_set_int(twebOR, webOR);
printf("%i", config_setting_get_int(twebOR));
}
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));
}
/* write the modified config file */
config_write_file(&cfg, config_file_name);
config_destroy(&cfg);
return 0;
}
//-----------------------------------------------------------------------------
int t_display_save_configuration (config_setting_t *setting, T_Display *d)
{
config_setting_t *s, *sp = NULL ;
s = config_setting_add(setting, NULL, CONFIG_TYPE_GROUP) ;
sp = config_setting_add(s, "type", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->type);
sp = config_setting_add(s, "width", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->canvas->allocation.width);
sp = config_setting_add(s, "height", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->canvas->allocation.height);
sp = config_setting_add(s, "position_x", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->canvas->allocation.x);
sp = config_setting_add(s, "position_y", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->canvas->allocation.y);
sp = config_setting_add(s, "time_range", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->time_range);
sp = config_setting_add(s, "last_time", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->last_time);
sp = config_setting_add(s, "time_step", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->time_step);
sp = config_setting_add(s, "temp_max", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->temp_max);
sp = config_setting_add(s, "temp_min", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->temp_min);
sp = config_setting_add(s, "temp_step", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->temp_step);
sp = config_setting_add(s, "font_size", CONFIG_TYPE_INT) ;
config_setting_set_int(sp, d->font_size);
sp = config_setting_add(s, "show_legend", CONFIG_TYPE_BOOL) ;
config_setting_set_bool(sp, d->show_legend);
// sp = config_setting_add(s, "n_plots", CONFIG_TYPE_INT) ;
// config_setting_set_int(sp, g_list_length(d->plots));
sp = config_setting_add(s, "Plots", CONFIG_TYPE_LIST) ;
GList *tmp = d->plots ;
while (tmp != NULL) {
t_plot_save_configuration(sp, (T_Plot*)tmp->data) ;
tmp = g_list_next(tmp) ;
} ;
return 0 ;
} ;
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;
}
/*********************
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;
}
