C++ save_data函数代码示例

string JabberMessageError::save()
{
    string res = Message::save();
    string s = save_data(jabberMessageErrorData, &data);
    if (!s.empty()){
        if (!res.empty())
            res += "\n";
        res += s;
    }
    return res;
}

string SMSClient::getConfig()
{
    string cfg = TCPClient::getConfig();
    string my_cfg = save_data(smsClientData, &data);
    if (!my_cfg.empty()){
        if (!cfg.empty())
            cfg += "\n";
        cfg += my_cfg;
    }
    return cfg;
}

static void deinit(void) {
	save_data();

	deinit_menu();
	deinit_main();
	deinit_info();

	window_destroy(window_menu);
	window_destroy(window_main);
	window_destroy(window_info);
}

static void cb_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length,
                              void *userdata)
{
    TOX_ERR_FRIEND_ADD err;
    tox_friend_add_norequest(m, public_key, &err);

    if (err != TOX_ERR_FRIEND_ADD_OK)
        fprintf(stderr, "tox_friend_add_norequest failed (error %d)\n", err);

    save_data(m, DATA_FILE);
}

void StringsEditor::on_languageSelector_comboBox_currentTextChanged(const QString &arg1)
{
    if (data_loading) { return; }
    save_data();
    current_lang = arg1.toStdString();
    data_loading = true;
    std::string path_new = FILEPATH + std::string("/lang/strings_ingame_") + arg1.toStdString() + std::string(".dat");
    load_language(path_new);
    fill_translation();
    data_loading = false;
}

static void exit_toxbot(Tox *m)
{
    uint32_t numchats = tox_count_chatlist(m);

    if (numchats)
        exit_groupchats(m, numchats);

    save_data(m, DATA_FILE);
    tox_kill(m);
    exit(EXIT_SUCCESS);
}

void evolve_network(network *net) {
  FILE *fh, *fhtime;
  char msg[1024], outdir[1024], msg2[80];
  double dx = 1000./(net->npcent);
  double dt = dx/(net->c);  			// physical time-step (seconds)
  int n_steps = round((net->tmax)/dt);
  //int n_steps = 4;
  int n_skip = net->nskip;
  //int n_skip = 1;
  int n_curr = 0;
  printf("Simulating network for %f hours\nTime step is %f (in secs)\nTotal steps %d\n", (net->tmax)/3600., dt, n_steps);
  
  init_dump(net);
  
  while (1) {
#if NOISE
    split_step2(net, dx, n_curr*dt);  // note (dx = dtau)
    //printf("Uncomment to run with noise\n"); exit(1);	
#else
    memcpy(p_prev, net->link[0]->p, (net->link[0]->N)*sizeof(double));
    split_step2nonoise(net, dx, n_curr*dt);  // note (dx = dtau)
#endif
    if (ADIABATIC) adiabatic_rk4(net->link[0]->fx, dt);
    n_curr++;
    
    if (n_curr % n_skip == 0) {
      printf("t = %.8e min\n", n_curr*dt/60.);
      dump_current(net, n_curr*dt);
      save_adiabatic();

      if (ADIABATIC_SAVE) save_adiabatic_temporal();
      if (PIPE_SAVE) {	
        for (int n = 0; n < net->nlinks; n++){ 
          sprintf(msg, "%s/pipe_%03d/%s_%03d.txt", net->current_dir, n, net->dname, n_curr/n_skip);
          fh = fopen(msg, "w");
	  save_data(fh, net->link[n], net, n_curr*dt);
          fclose(fh);         
        }
        /*if (net->mglf != 0) {
          sprintf(outdir, "%s/network", net->current_dir);
          sprintf(msg, "%s/%s_%03d.png", outdir, net->dname, n_curr/n_skip);
          sprintf(msg2, "t = %.3f sec", n_curr*dt);
          mgl_draw_network(net, msg, msg2);
        }*/
      }
    }
    if (n_curr == n_steps) break; 
  }
  printf("t = %.8e min\n", n_curr*dt/60.);
  fhtime = fopen("params.txt", "a");
  fprintf(fhtime, "%e\t%e\t%e\n", n_curr*dt/3600., ((net->knot[1])->P)*0.000001, ovsq2*((net->link[0])->W_l - (net->link[0])->Wb_l)/(net->c) );
  fclose(fhtime);
}

void CDFFDJump::OnOK()
{
	if (modified_)
	{
		if (!check_data())
			return;

		save_data();
	}

	CDialog::OnOK();
}

static int load_data_or_init(Tox *m, char *path)
{
    data_file_name = path;

    if (load_data(m))
        return 1;

    if (save_data(m))
        return 1;

    return 0;
}

static void terminate(int signal) {
    save_data(signal);
    running = FALSE;

    if (config.reader_thread.enabled) {
        // SIGUSR2 the reader thread to interrupt the recv() call
        config.reader_thread.enabled = FALSE;
        pthread_kill(config.reader_thread.thread, SIGUSR2);

        // As soon as reader thread is terminated, main() terminates the writer thread and wraps up
    }
}

bool accounts::modules_loaded() {
	OptionsI *options_i = (OptionsI *)core_i->get_interface(INAME_OPTIONS);
	if(options_i) options_i->add_page("Accounts", options = new AccountsOptions(this));
	connect(options, SIGNAL(applied()), this, SLOT(save_data()));

	read_data();

	if(account_list.size() == 0)
		options_i->show_options("Accounts");

	return true;
}

void CDFFDUseStruct::OnOK()
{
	if (modified_)
	{
		if (!check_data())
			return;

		save_data();
	}

	CDialog::OnOK();
}

void Tox_Dispatcher::save_save_data()
{
    std::string sdf = Platform::get_instance()->get_save_data_file();
    std::ofstream os;
    os.open(sdf, std::ios::out | std::ios::binary);
    if (os.good()) {
        LOG(INFO) << "Saving tox data";
        const size_t len = tox_get_savedata_size(tox);
        std::vector<uint8_t> save_data(len, 0);
        tox_get_savedata(tox, save_data.data());
        os.write((char *) save_data.data(), len);
    }
    os.close();
}

void CHelicopter::save(NET_Packet &output_packet)
{
    m_movement.save	(output_packet);
    m_body.save		(output_packet);
    m_enemy.save	(output_packet);
    output_packet.w_vec3(XFORM().c);
    output_packet.w_float(m_barrel_dir_tolerance);
    save_data		(m_use_rocket_on_attack, output_packet);
    save_data		(m_use_mgun_on_attack, output_packet);
    save_data		(m_min_rocket_dist, output_packet);
    save_data		(m_max_rocket_dist, output_packet);
    save_data		(m_min_mgun_dist, output_packet);
    save_data		(m_max_mgun_dist, output_packet);
    save_data		(m_time_between_rocket_attack, output_packet);
    save_data		(m_syncronize_rocket, output_packet);
}

void evolve_network_balance(network *net, network *netb){
  FILE *fh, *fhtime;
  char msg[1024], outdir[1024], msg2[80];
  double dx = 1000./(net->npcent);
  double dt = dx/(net->c);  			// physical time-step (seconds)
  int n_steps = round((net->tmax)/dt);
  int n_skip = net->nskip;
  int n_curr = 0; net->curr_T = n_curr*dt; 
  printf("Simulating network for %f hours\nTime step is %f (in secs)\nTotal steps %d\n", (net->tmax)/3600., dt, n_steps);
  init_save_balance(net);
  while (1) {
    copy_network(net, netb);
    split_step2(net, dx, n_curr*dt);  // note (dx = dtau)
    n_curr++; net->curr_T = n_curr*dt;
    
    if (n_curr % n_skip == 0) {
      printf("t = %.3f min\n", n_curr*dt/60.);
      save_balance(net, netb, dt, dx);
      fhtime = fopen("temporal_flux.txt", "a");
      fprintf(fhtime, "%e\t", n_curr*dt);  
      for (int n = 0; n < net->nlinks; n++) {
	fprintf(fhtime, "%e\t%e\t%e\t", (net->link[n]->Fl), (net->link[n]->Fm), (net->link[n]->Fr)  );
      }
      fprintf(fhtime, "\n");  
      fclose(fhtime);

      fhtime = fopen("temporal_pressure.txt", "a");
      fprintf(fhtime, "%e\t", n_curr*dt);  
      for (int n = 0; n < net->nlinks; n++) {
        fprintf(fhtime, "%e\t%e\t%e\t",  0.000001*((net->link[n])->Pl),  0.000001*((net->link[n])->Pm),  0.000001*((net->link[n])->Pr) );
      } 
      fprintf(fhtime, "\n");  
      fclose(fhtime);

      for (int n = 0; n < net->nlinks; n++){ 
        /*sprintf(outdir, "%s/figures_%03d", net->current_dir, n);
        sprintf(msg, "%s/%s_%03d.png", outdir, net->dname, n_curr/n_skip);
        sprintf(msg2, "t = %.3f sec", n_curr*dt);
        mgl_draw_pipe(net->link[n], net, msg, msg2);*/
        sprintf(msg, "%s/pipe_%03d/%s_%03d.txt", net->current_dir, n, net->dname, n_curr/n_skip);
        fh = fopen(msg, "w");
	save_data(fh, net->link[n], net, n_curr*dt);
        fclose(fh);
      }
    }
    if (n_curr == n_steps) break; 
  }
  printf("t = %.3f min\n", n_curr*dt/60.);
}