自学教程：C++ CFG_END函数代码示例

bool readVarConfig(cfg_t **cfg) {	cfg_opt_t device_opts[] = {		CFG_INT(const_cast<char *>("state"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("stateValue"), const_cast<char *>(""), CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_SEC(const_cast<char *>("device"), device_opts, CFGF_MULTI | CFGF_TITLE),		CFG_END()	};	FILE *fp = fopen(VAR_CONFIG_FILE, "re");  // e for setting O_CLOEXEC on the file handle	if (!fp) {		Log::warning("Unable to open var config file, %s", VAR_CONFIG_FILE);		return false;	}	(*cfg) = cfg_init(opts, CFGF_NOCASE);	if (cfg_parse_fp((*cfg), fp) == CFG_PARSE_ERROR) {		(*cfg) = 0;		fclose(fp);		Log::warning("Unable to parse var config file, %s", VAR_CONFIG_FILE);		return false;	}	fclose(fp);	return true;}

void read_config(void){    static cfg_opt_t arg_opts[] = {        CFG_STR("value", "default", CFGF_NONE),        CFG_END()    };    cfg_opt_t opts[] = {        CFG_INT("delay", 3, CFGF_NONE),        CFG_STR("message", "This is a message", CFGF_NONE),        CFG_SEC("argument", arg_opts, CFGF_MULTI | CFGF_TITLE),        CFG_END()    };    char *buf = "" /        " delay = 3/n" /        "# message = /"asdfasfasfd tersf/"/n" /        " argument one { value = 1 }/n" /        " argument two { value=foo}/n";    cfg_free(cfg);    cfg = cfg_init(opts, 0);    cfg_parse_buf(cfg, buf);    cfg_parse(cfg, config_filename);}

int main(void){	static cfg_opt_t section_opts[] = {		CFG_STR("prop", 0, CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_SEC("section", section_opts, CFGF_TITLE | CFGF_MULTI),		CFG_END()	};	const char *config_data =		"section title_one { prop = 'value_one' }/n"		"section title_two { prop = 'value_two' }/n";	int rc;	cfg_t *cfg = cfg_init(opts, CFGF_NONE);	fail_unless(cfg);	rc = cfg_parse_buf(cfg, config_data);	fail_unless(rc == CFG_SUCCESS);	fail_unless(cfg_addtsec(cfg, "section", "title_three"));	fail_unless(cfg_size(cfg, "section") == 3);	fail_unless(cfg_title(cfg_gettsec(cfg, "section", "title_three")));	/* attempt to add a pre-existing section should fail */	fail_unless(!cfg_addtsec(cfg, "section", "title_three"));	cfg_free(cfg);	return 0;}

bool SyncLogger::ParseFile(const char* pszHash){	if (strcmp(m_szCurShare, pszHash) == 0)	{		// File is currently parsed, there is no need to parse it again.		return true;	}    cfg_opt_t modEntry[] =    {        // Parses within the group.        CFG_STR(FILE_PATH_VARNAME, FILE_PATH_DEFAULT, CFGF_NONE),        CFG_STR(MOD_TIME_VARNAME, MOD_TIME_DEFAULT, CFGF_NONE),        CFG_STR(MOD_TYPE_VARNAME, MOD_TYPE_DEFAULT, CFGF_NONE),        CFG_END()    };    cfg_opt_t entries[] =    {        // Parses the single groups.        CFG_SEC(MOD_NUMBER_VARNAME, modEntry, CFGF_TITLE | CFGF_MULTI),        CFG_END()    };    // Initializes the parser.    m_pCFG = cfg_init(entries, CFGF_NONE);    // Parses the file.	char szLogName[MAX_PATH];	CalcLogFileName(pszHash, szLogName);    if (cfg_parse(m_pCFG, szLogName) == CFG_PARSE_ERROR)        return false;    return true;}

cfg_t *parse_conf(const char *filename){    cfg_opt_t process_opts[] = {        CFG_STR("comm", 0, CFGF_NODEFAULT),        CFG_STR("args", 0, CFGF_NODEFAULT),        CFG_STR("pre", 0, CFGF_NONE),        CFG_END()    };    cfg_opt_t opts[] = {        CFG_SEC("process", process_opts, CFGF_MULTI | CFGF_TITLE),        CFG_INT("frequency", 10, CFGF_NONE),        CFG_END()    };    cfg_t *cfg = cfg_init(opts, CFGF_NONE);    //cfg_set_validate_func(cfg, "bookmark|port", conf_validate_port);    //cfg_set_validate_func(cfg, "bookmark", conf_validate_bookmark);    switch(cfg_parse(cfg, filename))    {        case CFG_FILE_ERROR:            printf("warning: configuration file '%s' could not be read: %s/n",                    filename, strerror(errno));            printf("continuing with default values.../n/n");        case CFG_SUCCESS:            break;        case CFG_PARSE_ERROR:            return 0;    }    return cfg;}

cfg_t *parse_conf(char *conf){	cfg_opt_t provider_opts[] = {		CFG_STR     ("username",  0, CFGF_NONE),		CFG_STR     ("password",  0, CFGF_NONE),		CFG_STR_LIST("alias",     0, CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_BOOL("syslog",	  cfg_false, CFGF_NONE),		CFG_BOOL("wildcard",	  cfg_false, CFGF_NONE),		CFG_STR ("bind",	  0, CFGF_NONE),		CFG_INT ("period",	  60, CFGF_NONE),		CFG_INT ("startup-delay", 0, CFGF_NONE),		CFG_INT ("forced-update", 720000, CFGF_NONE),		CFG_SEC ("provider", provider_opts, CFGF_MULTI | CFGF_TITLE),		CFG_END()	};	cfg_t *cfg = cfg_init(opts, CFGF_NONE);	switch (cfg_parse(cfg, conf)) {	case CFG_FILE_ERROR:		fprintf(stderr, "Cannot read configuration file %s: %s/n", conf, strerror(errno));	case CFG_PARSE_ERROR:		return NULL;	case CFG_SUCCESS:		break;	}    return cfg;}

int main(void){	cfg_opt_t sub_opts[] = {		CFG_BOOL("bool", cfg_false, CFGF_NONE),		CFG_STR("string", NULL, CFGF_NONE),		CFG_INT("int", 0, CFGF_NONE),		CFG_FLOAT("float", 0.0, CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_BOOL_LIST("bool", cfg_false, CFGF_NONE),		CFG_STR_LIST("string", NULL, CFGF_NONE),		CFG_INT_LIST("int", 0, CFGF_NONE),		CFG_FLOAT_LIST("float", "0.0", CFGF_NONE),		CFG_SEC("sub", sub_opts,			CFGF_MULTI | CFGF_TITLE | CFGF_NO_TITLE_DUPES),		CFG_END()	};	char *cmd = NULL;	const char *reply;	int res;	int i;	cfg = cfg_init(opts, CFGF_NONE);	for (;;) {		printf("cli> ");		fflush(stdout);		if (cmd)			free(cmd);		cmd = input_cmd();		if (!cmd)			exit(0);		res = split_cmd(cmd);		if (res < 0) {			printf("Parse error/n");			continue;		}		if (cmdc == 0)			continue;		for (i = 0; cmds[i].cmd; ++i) {			if (strcmp(cmdv[0], cmds[i].cmd))				continue;			reply = cmds[i].handler(cmdc, cmdv);			if (!reply)				exit(0);			printf("%s", reply);			break;		}		if (!cmds[i].cmd)			printf("Unknown command/n");	}	cfg_free(cfg);	return 0;}

bool readConfig(cfg_t **cfg) {	// All the const_cast keywords is to remove the compiler warnings generated by the C++-compiler.	cfg_opt_t controller_opts[] = {		CFG_INT(const_cast<char *>("id"), -1, CFGF_NONE),		CFG_STR(const_cast<char *>("name"), const_cast<char *>(""), CFGF_NONE),		CFG_INT(const_cast<char *>("type"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("serial"), const_cast<char *>(""), CFGF_NONE),		CFG_END()	};	cfg_opt_t device_parameter_opts[] = {		// Groups		CFG_STR(const_cast<char *>("devices"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("house"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("unit"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("code"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("system"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("units"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("fade"), 0, CFGF_NONE),		CFG_END()	};	cfg_opt_t device_opts[] = {		CFG_INT(const_cast<char *>("id"), -1, CFGF_NONE),		CFG_STR(const_cast<char *>("name"), const_cast<char *>("Unnamed"), CFGF_NONE),		CFG_INT(const_cast<char *>("controller"), 0, CFGF_NONE),		CFG_STR(const_cast<char *>("protocol"), const_cast<char *>("arctech"), CFGF_NONE),		CFG_STR(const_cast<char *>("model"), const_cast<char *>(""), CFGF_NONE),		CFG_SEC(const_cast<char *>("parameters"), device_parameter_opts, CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_STR(const_cast<char *>("user"), const_cast<char *>("nobody"), CFGF_NONE),		CFG_STR(const_cast<char *>("group"), const_cast<char *>("plugdev"), CFGF_NONE),		CFG_STR(const_cast<char *>("deviceNode"), const_cast<char *>("/dev/tellstick"), CFGF_NONE),		CFG_STR(const_cast<char *>("ignoreControllerConfirmation"), const_cast<char *>("false"), CFGF_NONE),		CFG_SEC(const_cast<char *>("device"), device_opts, CFGF_MULTI),		CFG_SEC(const_cast<char *>("controller"), controller_opts, CFGF_MULTI),		CFG_END()	};	FILE *fp = fopen(CONFIG_FILE, "re");  // e for setting O_CLOEXEC on the file handle	if (!fp) {		return false;	}	(*cfg) = cfg_init(opts, CFGF_NOCASE);	if (cfg_parse_fp((*cfg), fp) == CFG_PARSE_ERROR) {		(*cfg) = 0;		fclose(fp);		return false;	}	fclose(fp);	return true;}

void validate_setup(void){	cfg_opt_t *opt = 0;	static cfg_opt_t action_opts[] = {		CFG_INT("speed", 0, CFGF_NONE),		CFG_STR("name", 0, CFGF_NONE),		CFG_INT("xspeed", 0, CFGF_NONE),		CFG_END()	};	static cfg_opt_t multi_opts[] = {		CFG_INT_LIST("speeds", 0, CFGF_NONE),		CFG_SEC("options", action_opts, CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_STR_LIST("ip-address", 0, CFGF_NONE),		CFG_INT_CB("action", ACTION_NONE, CFGF_NONE, parse_action),		CFG_SEC("options", action_opts, CFGF_NONE),		CFG_SEC("multi_options", multi_opts, CFGF_MULTI),		CFG_END()	};	cfg = cfg_init(opts, 0);	cfg_set_validate_func(cfg, "ip-address", validate_ip);	fail_unless(cfg_set_validate_func(cfg, "ip-address", validate_ip) == validate_ip);	opt = cfg_getopt(cfg, "ip-address");	fail_unless(opt != 0);	fail_unless(opt->validcb == validate_ip);	cfg_set_validate_func(cfg, "options", validate_action);	fail_unless(cfg_set_validate_func(cfg, "options", validate_action) == validate_action);	opt = cfg_getopt(cfg, "options");	fail_unless(opt != 0);	fail_unless(opt->validcb == validate_action);	cfg_set_validate_func(cfg, "options|speed", validate_speed);	fail_unless(cfg_set_validate_func(cfg, "options|speed", validate_speed) == validate_speed);	opt = cfg_getopt(cfg, "options|speed");	fail_unless(opt != 0);	fail_unless(opt->validcb == validate_speed);	cfg_set_validate_func(cfg, "multi_options|speeds", validate_speed);	fail_unless(cfg_set_validate_func(cfg, "multi_options|speeds", validate_speed) == validate_speed);	cfg_set_validate_func(cfg, "multi_options|options|xspeed", validate_speed);	fail_unless(cfg_set_validate_func(cfg, "multi_options|options|xspeed", validate_speed) == validate_speed);	/* Validate callbacks for *set*() functions, i.e. not when parsing file content */	cfg_set_validate_func2(cfg, "multi_options|speed", validate_speed2);	cfg_set_validate_func2(cfg, "multi_options|options|name", validate_name2);}

static cfg_t *create_config(void){	static cfg_opt_t sec_opts[] = {		CFG_INT("a", 1, CFGF_NONE),		CFG_INT("b", 2, CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_SEC("sec", sec_opts, CFGF_MULTI | CFGF_TITLE),		CFG_END()	};	return cfg_init(opts, 0);}

int main(void){	char *comment;	char *expect = "Now, is it this comment that goes with the option?";	cfg_t *cfg;	cfg_opt_t *opt;	cfg_opt_t section_opts[] = {		CFG_INT("key", 0, CFGF_NONE),		CFG_BOOL("bool", 0, CFGF_NONE),		CFG_STR("option", NULL, CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_STR("option", NULL, CFGF_NONE),		CFG_SEC("section", section_opts, CFGF_MULTI),		CFG_END()	};	cfg = cfg_init(opts, CFGF_COMMENTS);	fail_unless(cfg != NULL);	fail_unless(cfg_parse(cfg, SRC_DIR "/annotate.conf") == CFG_SUCCESS);	/* Verify the parser read the correct comment for this tricky option */	opt = cfg_getopt(cfg, "section|option");	fail_unless(opt != NULL);	comment = cfg_opt_getcomment(opt);	fail_unless(comment != NULL);	fail_unless(strcmp(comment, expect) == 0);	expect = "But what's the worst poetry in the universe?";	fail_unless(cfg_opt_setcomment(opt, expect) == CFG_SUCCESS);	cfg_opt_setnstr(opt, "Paula Nancy Millstone Jennings was a poet who wrote the worst poetry in "			"the universe. In fact, her poetry is still considered to be the worst in "			"the Galaxy, closely followed by that of the Azgoths of Kria and the "			"Vogons, in that order.", 0);	/* Verify that the comment is not reset when changing option value */	comment = cfg_opt_getcomment(opt);	fail_unless(comment != NULL);	fail_unless(strcmp(comment, expect) == 0);	cfg_print(cfg, stdout);	fail_unless(cfg_free(cfg) == CFG_SUCCESS);	return 0;}

cfg_opt_t * build_section(section_t *section, section_ptrs &ptrs){   static const char *funcname = "conf::build_section";   cfg_opt_t *ptr = new cfg_opt_t[section->size() + 1];   ptrs.push_back(std::unique_ptr<cfg_opt_t []>(ptr));   for (auto &entry : *section)   {      char *name = const_cast<char *>(entry.first.c_str());      switch (entry.second.what_type())      {         case val_type::integer:     *ptr = CFG_INT(name, 0, CFGF_NODEFAULT); break;         case val_type::string:      *ptr = CFG_STR(name, 0, CFGF_NODEFAULT); break;         case val_type::multistring: *ptr = CFG_STR_LIST(name, 0, CFGF_NODEFAULT); break;         case val_type::section:     *ptr = CFG_SEC(name, build_section(entry.second.get<conf::section_t *>(), ptrs), CFGF_NONE); break;         case val_type::unknown:            throw logging::error(funcname, "Val with unknown type in section: %s", name);      }      ptr++;   }   *ptr = CFG_END();   return ptrs.back().get();}

BOOL saveConfFile(user_input_data *user_dat){    FILE *U2Mconf_file = fopen(cfg_filename, "w");    if (!U2Mconf_file) return FALSE;    cfg_opt_t email_opts[] = {        CFG_STR("From", user_dat->FROM, CFGF_NONE),        CFG_STR("To", user_dat->TO, CFGF_NONE),        CFG_STR("Cc", user_dat->CC, CFGF_NONE),        CFG_STR("Subject", user_dat->SUBJECT, CFGF_NONE),        CFG_STR("Body", user_dat->BODY, CFGF_NONE),        CFG_STR("Password", user_dat->pass, CFGF_NONE),        CFG_STR("SMTP_server", user_dat->SMTP_SERVER, CFGF_NONE),        CFG_INT("Port_number", (int)user_dat->PORT, CFGF_NONE),        CFG_END()    };    cfg_t *U2MConf = cfg_init(email_opts, CFGF_NONE);    cfg_print(U2MConf, U2Mconf_file);    fclose(U2Mconf_file);    cfg_free(U2MConf);    return TRUE;}

/*Function to parse the server config file.@param Config file location in the file system.@param Struct to write results into.@return -1 on failure, 0 on success.*/int parse_config(char * config_file, struct config_struct * running_config){  print_to_log("Parsing config file", LOG_INFO);  cfg_opt_t opts[] =	{	  CFG_STR("domain", "", CFGF_NONE),    CFG_INT("connection_timeout_in_seconds", 0, CFGF_NONE),    CFG_INT("max_connections", 0, CFGF_NONE),	  CFG_END()	};	cfg_t *cfg;	cfg = cfg_init(opts, CFGF_NONE);	 if(cfg_parse(cfg, config_file) == CFG_PARSE_ERROR)   {     printf("Reading config %s has failed/n", config_file);     return -1;   }   if (strcmp(cfg_getstr(cfg, "domain"),"")!=0)   {     //Load domain into struct here.   }   if (cfg_getint(cfg, "connection_timeout_in_seconds")<=60)   {     //load connection_timeout_in_seconds into struct here.     running_config->connection_timeout_in_seconds = cfg_getint(cfg, "connection_timeout_in_seconds");   }   if (cfg_getint(cfg, "max_connections")<=1000)   {     //load connection_timeout_in_seconds into struct here.     running_config->max_connections = cfg_getint(cfg, "max_connections");   }   return 0;}

/** * Parses the config file * * @return a pointer to the configuration data structure, NULL on failure */static cfg_t * parse_config(void) {	cfg_t * cfg = NULL;	cfg_opt_t target_opts[] = {	                              CFG_STR("comment", 0, CFGF_NONE),	                              CFG_INT("strip", 0, CFGF_NONE),	                              CFG_STR("rewrite_prefix", 0, CFGF_NONE),	                              CFG_FLOAT("prob", 0, CFGF_NONE),	                              CFG_INT("hash_index", 0, CFGF_NONE),	                              CFG_STR("rewrite_suffix", 0, CFGF_NONE),	                              CFG_INT("status", 1, CFGF_NONE),	                              CFG_INT_LIST("backed_up", NULL, CFGF_NONE),	                              CFG_INT("backup", -1, CFGF_NONE),	                              CFG_END()	                          };	cfg_opt_t prefix_opts[] = {	                              CFG_SEC("target", target_opts, CFGF_MULTI | CFGF_TITLE),	                              CFG_INT("max_targets", -1, CFGF_NONE),	                              CFG_END()	                          };	cfg_opt_t domain_opts[] = {	                              CFG_SEC("prefix", prefix_opts, CFGF_MULTI | CFGF_TITLE),	                              CFG_END()	                          };	cfg_opt_t opts[] = {	                       CFG_SEC("domain", domain_opts, CFGF_MULTI | CFGF_TITLE),	                       CFG_END()	                   };	cfg = cfg_init(opts, CFGF_NONE);	cfg_set_error_function(cfg, conf_error);	switch (cfg_parse(cfg, config_file)) {		case CFG_FILE_ERROR: LM_ERR("file not found: %s/n", config_file);			return NULL;		case CFG_PARSE_ERROR: LM_ERR("error while parsing %s in line %i, section %s/n",			                          cfg->filename, cfg->line, cfg->name);			return NULL;		case CFG_SUCCESS: break;	}	return cfg;}

int main(void){	static cfg_opt_t section_opts[] = {		CFG_STR("prop", 0, CFGF_NONE),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_SEC("section", section_opts, CFGF_TITLE | CFGF_MULTI),		CFG_END()	};	const char *config_data =		"section title_one { prop = 'value_one' }/n"		"section title_two { prop = 'value_two' }/n"		"section title_one { prop = 'value_one' }/n";	int rc;	cfg_t *cfg = cfg_init(opts, CFGF_NONE);	fail_unless(cfg);	rc = cfg_parse_buf(cfg, config_data);	fail_unless(rc == CFG_SUCCESS);	cfg_rmtsec(cfg, "section", "title_two");	fail_unless(cfg_size(cfg, "section") == 1);	fail_unless(strcmp(cfg_title(cfg_getnsec(cfg, "section", 0)), "title_one") == 0);	cfg_free(cfg);	cfg = cfg_init(opts, CFGF_NONE);	fail_unless(cfg);	rc = cfg_parse_buf(cfg, config_data);	fail_unless(rc == CFG_SUCCESS);	cfg_rmsec(cfg, "section");	fail_unless(cfg_size(cfg, "section") == 1);	fail_unless(strcmp(cfg_title(cfg_getnsec(cfg, "section", 0)), "title_two") == 0);	cfg_free(cfg);	return 0;}

int main(void){	cfg_opt_t group_opts[] = {		CFG_INT("number", 0, CFGF_NONE),		CFG_INT("total", 0, CFGF_NONE),		CFG_END()	};	cfg_opt_t groups_opts[] = {		CFG_STR("name", "Esmé", CFGF_NONE),		CFG_SEC("group", group_opts, CFGF_TITLE | CFGF_MULTI),		CFG_END()	};	cfg_opt_t opts[] = {		CFG_SEC("groups", groups_opts, CFGF_NONE),		CFG_END()	};	cfg_t *cfg, *sec;	size_t i, j;	cfg = cfg_init(opts, CFGF_NONE);	if (!cfg || cfg_parse(cfg, CONF) == CFG_PARSE_ERROR) {		perror("Failed parsing " CONF);		return 1;	}	/* Iterate over the sections and print fields from each section. */	for (i = 0; i < cfg_size(cfg, "groups"); i++) {		sec = cfg_getnsec(cfg, "groups", i);		for (j = 0; j < cfg_size(sec, "group"); j++) {			cfg_t *opt = cfg_getnsec(sec, "group", j);			printf("group title:  '%s'/n", cfg_title(opt));			printf("group number:  %ld/n", cfg_getint(opt, "number"));			printf("group total:   %ld/n", cfg_getint(opt, "total"));			printf("/n");		}	}	cfg_free(cfg);	return 0;}

cfg_opt_t *filters_get_cfg_opts(void){    cfg_opt_t *opts = malloc(sizeof(cfg_opt_t) * (NUM_FILTER_OPTIONS + 1));    for (int i = 0; i < NUM_FILTER_OPTIONS; ++i)        memcpy(&opts[i], &filter_options[i].confuse_opt, sizeof(cfg_opt_t));    cfg_opt_t end = CFG_END();    memcpy(&opts[NUM_FILTER_OPTIONS], &end, sizeof(cfg_opt_t));    return opts;}

cfg_t *parse_conf(const char *filename){    cfg_opt_t bookmark_opts[] = {        CFG_STR("host", 0, CFGF_NODEFAULT),        CFG_INT("port", 21, CFGF_NONE),        CFG_STR("login", "anonymous", CFGF_NONE),        CFG_STR("password", "[email
C++ CFGetAllocator函数代码示例
C++ CFG80211DBG函数代码示例