C++ config_set_int函数代码示例

bool config_args(int argc, char **argv)
{
	for(int i = 1; i < argc; i++)
	{
		if(!util_strncmp(argv[i], "-h", 2))
		{
			argv[i] += 2;

			fprintf(stdout, "Usage: (%s -h) or (%s -cConfigValue)\n", argv[0], argv[0]);

			return false;
		}
		else if(!util_strncmp(argv[i], "-c", 2))
		{
			argv[i] += 2;

			const char *m = "c_autoSelect";
			if(!util_strncmp(argv[i], m, strlen(m)))
			{
				argv[i] += strlen(m);
				config_set_int(c_autoSelect, util_atoi(argv[i]));
			}
			m = "c_noModify";
			if(!util_strncmp(argv[i], m, strlen(m)))
			{
				argv[i] += strlen(m);
				config_set_int(c_noModify, util_atoi(argv[i]));
			}
		}
	}

	return true;
}

static void grab_defaults (GtkWidget *w, gpointer data) {
	config_set_int ("/" CONFIG_FILE "/Statistics/country", selected_country);
	config_set_int ("/" CONFIG_FILE "/Statistics/game", selected_type);

	config_set_int ("/" CONFIG_FILE "/Statistics/page", 
			gtk_notebook_get_current_page (GTK_NOTEBOOK (stat_notebook)));
}

void AutoConfig::SaveSettings()
{
	OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());

	if (recordingEncoder != Encoder::Stream)
		config_set_string(main->Config(), "SimpleOutput", "RecEncoder",
				GetEncoderId(recordingEncoder));

	const char *quality = recordingQuality == Quality::High
		? "Small"
		: "Stream";

	config_set_string(main->Config(), "Output", "Mode", "Simple");
	config_set_string(main->Config(), "SimpleOutput", "RecQuality", quality);
	config_set_int(main->Config(), "Video", "BaseCX", baseResolutionCX);
	config_set_int(main->Config(), "Video", "BaseCY", baseResolutionCY);
	config_set_int(main->Config(), "Video", "OutputCX", idealResolutionCX);
	config_set_int(main->Config(), "Video", "OutputCY", idealResolutionCY);

	if (fpsType != FPSType::UseCurrent) {
		config_set_uint(main->Config(), "Video", "FPSType", 0);
		config_set_string(main->Config(), "Video", "FPSCommon",
				std::to_string(idealFPSNum).c_str());
	}

	main->ResetVideo();
	main->ResetOutputs();
	config_save_safe(main->Config(), "tmp", nullptr);
}

static int bind_resolution_set(OptionBinding *b, int v) {
	if(v >= 0) {
		VideoMode *m = video.modes + v;
		config_set_int(CONFIG_VID_WIDTH, m->width);
		config_set_int(CONFIG_VID_HEIGHT, m->height);
	}

	return v;
}

static void config_init()
{
	for(int i = 0; i < c_numConfig; i++)
		config[i] = 0;

	init = true;

	config_set_int(c_autoSelect, c_autoSelectDefault);
	config_set_int(c_noModify, c_noModifyDefault);
	config_set_int(c_autoNoTexture, c_autoNoTextureDefault);
	config_set_int(c_hideDetail, c_hideDetailDefault);
}

void config_get(char *file_path, config *conf)
{
    /***********************************************/
	/** Initialization of configuration variables **/
	/***********************************************/
    
    int i=0, j=0;
    
    conf->server_port=36000;
    strcpy(conf->server_address,"localhost");
    
    
    for (i=0; i<HASH_TYPE_COUNT; i++)
        for (j=0; j<2; j++)
            conf->idp[i][j]=0;
    
	/************************/
	/** Read existing file **/
	/************************/
    
    conf->nb_core = config_get_int(file_path, "NB_CORE");
    config_get_string(file_path, "SERVER_ADDRESS", conf->server_address);
    conf->server_port = config_get_int(file_path, "SERVER_PORT");
    conf->idp[HASH_TYPE_MD5][IDP_TYPE_CPU] = config_get_int(file_path, "IDP_MD5_CPU");
    conf->idp[HASH_TYPE_MD5][IDP_TYPE_GPU] = config_get_int(file_path, "IDP_MD5_GPU");

	/************************/
	/** Confirm parameters **/
	/************************/

	printf("\nCore(s) available : %d\n", get_core_count());
    conf->nb_core = ui_input_int("Number of core to use", conf->nb_core, 1, get_core_count());
    ui_input_string("Server address", conf->server_address, conf->server_address);
    conf->server_port = ui_input_int("Server port", conf->server_port, 1, 65535);

	/*******************************/
	/** Write preferences in file **/
	/*******************************/
    
    remove(file_path);
	
	config_set_int(file_path,"NB_CORE", conf->nb_core);
	config_set_string(file_path, "SERVER_ADDRESS", conf->server_address);

	config_set_int(file_path,"SERVER_PORT", conf->server_port);
    config_set_int(file_path, "IDP_MD5_CPU", conf->idp[HASH_TYPE_MD5][IDP_TYPE_CPU]);
    config_set_int(file_path, "IDP_MD5_GPU", conf->idp[HASH_TYPE_MD5][IDP_TYPE_GPU]);
    
    

}

int main(int argc, char *argv[])
{
   parse_input(argc, argv);

   config_file_t *conf = config_file_new(g_in_path);
   if (!conf)
   {
      fprintf(stderr, "Couldn't open config file ...\n");
      return 1;
   }

   const char *index_list[] = { 
      "input_player1_joypad_index", 
      "input_player2_joypad_index", 
      "input_player3_joypad_index", 
      "input_player4_joypad_index", 
      "input_player5_joypad_index",
      "input_player6_joypad_index",
      "input_player7_joypad_index",
      "input_player8_joypad_index",
   };

   config_set_int(conf, index_list[g_player - 1], g_joypad);

   get_binds(conf, g_player - 1, g_joypad);
   config_file_write(conf, g_out_path);
   config_file_free(conf);
   if (g_in_path)
      free(g_in_path);
   if (g_out_path)
      free(g_out_path);
   return 0;
}

static void announce_player_cb(GtkToggleButton * widget,
			       G_GNUC_UNUSED gpointer user_data)
{
	gboolean announce_player = gtk_toggle_button_get_active(widget);
	config_set_int("settings/announce_player", announce_player);
	set_announce_player(announce_player);
}

static void summary_color_cb(GtkToggleButton * widget,
			     G_GNUC_UNUSED gpointer user_data)
{
	gboolean color_summary = gtk_toggle_button_get_active(widget);
	config_set_int("settings/color_summary", color_summary);
	set_color_summary(color_summary);
}

static void toggle_16_9_cb(GtkToggleButton * widget,
			   G_GNUC_UNUSED gpointer user_data)
{
	gboolean layout_16_9 = gtk_toggle_button_get_active(widget);
	config_set_int("settings/layout_16_9", layout_16_9);
	set_16_9_layout(layout_16_9);
}

/* 
 * A simple static test for the feature vectors
 */
int test_static()
{
    int i, err = 0;
    fvec_t *f;

    test_printf("Extraction of feature vectors");

    for (i = 0; tests[i].str; i++) {
        fvec_reset_delim();
        config_set_string(&cfg, "features.ngram_delim", tests[i].dlm);
        config_set_int(&cfg, "features.ngram_len", tests[i].nlen);

        /* Extract features */
        f = fvec_extract(tests[i].str, strlen(tests[i].str), "test");

        /* Check for correct number of dimensions */
        if (f->len != tests[i].len) {
            test_error("(%d) len %d != %d", i, f->len, tests[i].len);
            err++;
        }

        fvec_destroy(f);
    }

    test_return(err, i);
    return err;
}

static void message_color_cb(GtkToggleButton * widget,
			     G_GNUC_UNUSED gpointer user_data)
{
	color_messages_enabled = gtk_toggle_button_get_active(widget);
	config_set_int("settings/color_messages", color_messages_enabled);
	log_set_func_message_color_enable(color_messages_enabled);
}

static void show_legend_cb(GtkToggleButton * widget,
			   G_GNUC_UNUSED gpointer user_data)
{
	legend_page_enabled = gtk_toggle_button_get_active(widget);
	gui_show_legend_page(legend_page_enabled);
	config_set_int("settings/legend_page", legend_page_enabled);
}

//===========================================================================
int varset_message(int tokencount, char *tokens[], bool from_core, module* caller)
{
    int varnameidx;
    bool is_static;
    if (tokencount == 4)
    {
        varnameidx = 2;
        is_static = false;
    }
    else if (tokencount == 5 && !strcmp(tokens[2], "Static") )
    {
        varnameidx = 3;
        is_static = true;
    }
    else
        return 1;

    int i = atoi(variables_get(tokens[varnameidx],"0", caller));
    if	(	config_set_int(tokens[varnameidx+1],&i) //Try reading it as an int
            ||	config_set_int_expr(tokens[varnameidx+1],&i) // Try calculating the string as an expression
       )
        variables_set(is_static,tokens[varnameidx],i, caller);
    else variables_set(is_static, tokens[varnameidx], tokens[varnameidx+1], caller);
    return 0;
}

/* 
 * A simple stress test for the feature table
 */
int test_stress()
{
    int i, j, err = 0;
    fvec_t *f;
    char buf[STR_LENGTH + 1];

    test_printf("Stress test for feature vectors");

    config_set_string(&cfg, "features.ngram_delim", "0");

    ftable_init();

    for (i = 0; i < STRESS_RUNS; i++) {
        config_set_int(&cfg, "features.ngram_len", rand() % 10 + 1);

        /* Create random key and string */
        for (j = 0; j < STR_LENGTH; j++)
            buf[j] = rand() % 10 + '0';
        buf[j] = 0;

        /* Extract features */
        f = fvec_extract(buf, strlen(buf), "test");
        /* Destroy features */
        fvec_destroy(f);
    }

    ftable_destroy();

    test_return(err, STRESS_RUNS);
    return err;
}