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

static void conflict_rename_rename_2(struct rename *ren1,				     const char *branch1,				     struct rename *ren2,				     const char *branch2){	char *new_path1 = unique_path(ren1->pair->two->path, branch1);	char *new_path2 = unique_path(ren2->pair->two->path, branch2);	output(1, "Renamed %s to %s and %s to %s instead",	       ren1->pair->one->path, new_path1,	       ren2->pair->one->path, new_path2);	remove_file(0, ren1->pair->two->path, 0);	update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path1);	update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, new_path2);	free(new_path2);	free(new_path1);}

double cpu_system_func ( void ) {	char *p;	double val;	double last_system_jiffies,  system_jiffies,                 last_total_jiffies, total_jiffies, diff; 	p = update_file(&proc_stat);	p = skip_token(p);	p = skip_token(p);	p = skip_token(p);	system_jiffies = strtod( p , (char **)NULL );	if (num_cpustates > NUM_CPUSTATES_24X) {		p = skip_token(p);		p = skip_token(p);		p = skip_token(p);		system_jiffies += strtod( p , (char **)NULL ); /* "intr" counted in system */		p = skip_token(p);		system_jiffies += strtod( p , (char **)NULL ); /* "sintr" counted in system */	}	total_jiffies  = total_jiffies_func();	diff = system_jiffies  - last_system_jiffies;	if ( diff )	val = (diff/(total_jiffies - last_total_jiffies))*100;	else	val = 0.0;	last_system_jiffies  = system_jiffies;	last_total_jiffies = total_jiffies;   	return val;}

static int update_cnstat(uint32_t udp, uint32_t tcp, uint32_t other){	char path[1024];	struct stat s;	struct conn_entry e;	snprintf(path, sizeof(path), DB_CN_FILE);	if (stat(path, &s))	{		if (init_file(path, sizeof(struct conn_entry)))		{			fprintf(stderr, "Failed to init %s: %s/n",					path, strerror(errno));			return -1;		}	}	e.time  = htonl(time(NULL));	e.udp   = htonl(udp);	e.tcp   = htonl(tcp);	e.other = htonl(other);	return update_file(path, &e, sizeof(struct conn_entry));}

static int update_ldstat(uint16_t load1, uint16_t load5, uint16_t load15){	char path[1024];	struct stat s;	struct load_entry e;	snprintf(path, sizeof(path), DB_LD_FILE);	if (stat(path, &s))	{		if (init_file(path, sizeof(struct load_entry)))		{			fprintf(stderr, "Failed to init %s: %s/n",					path, strerror(errno));			return -1;		}	}	e.time   = htonl(time(NULL));	e.load1  = htons(load1);	e.load5  = htons(load5);	e.load15 = htons(load15);	return update_file(path, &e, sizeof(struct load_entry));}

static int update_ifstat(	const char *ifname, uint32_t rxb, uint32_t rxp, uint32_t txb, uint32_t txp) {	char path[1024];	struct stat s;	struct traffic_entry e;	snprintf(path, sizeof(path), DB_IF_FILE, ifname);	if (stat(path, &s))	{		if (init_file(path, sizeof(struct traffic_entry)))		{			fprintf(stderr, "Failed to init %s: %s/n",					path, strerror(errno));			return -1;		}	}	e.time = htonl(time(NULL));	e.rxb  = htonl(rxb);	e.rxp  = htonl(rxp);	e.txb  = htonl(txb);	e.txp  = htonl(txp);	return update_file(path, &e, sizeof(struct traffic_entry));}

static int update_radiostat(	const char *ifname, uint16_t rate, uint8_t rssi, uint8_t noise) {	char path[1024];	struct stat s;	struct radio_entry e;	snprintf(path, sizeof(path), DB_RD_FILE, ifname);	if (stat(path, &s))	{		if (init_file(path, sizeof(struct radio_entry)))		{			fprintf(stderr, "Failed to init %s: %s/n",					path, strerror(errno));			return -1;		}	}	e.time  = htonl(time(NULL));	e.rate  = htons(rate);	e.rssi  = rssi;	e.noise = noise;	return update_file(path, &e, sizeof(struct radio_entry));}

char *select_strategy(const char *msg) {	int deep = 1;	debug(deep, "Received string: '%s'", msg);	info(deep, "Select strategy");	unsigned char action = msg[0];	char *result;	switch (action) {	case COMMAND_CREATE:		append_strings("", create_file(msg), &result);		break;	case COMMAND_UPDATE:		append_strings("", update_file(msg), &result);		break;	case COMMAND_DELETE:		append_strings("", delete_file(msg), &result);		break;	case COMMAND_READ:		result = read_file(msg);		break;	case COMMAND_LIST:		result = list_files(msg);		break;	default:		append_strings("", ANSWER_UNKOWN, &result);		error(deep, "Wrong action %c", action);	}	info(deep, "Return value: '%s'", result);	return result;}

static voidupdate_each_file (gpointer key, gpointer unused, gpointer data){	UpdateDescendants *ctx = (UpdateDescendants*)data;	if (update_file (ctx->tracker, FALSE, key))		g_hash_table_remove (ctx->checks, key);}

/** * @brief ... * @param filename */void dofile(char *filename){    struct stat statbuf;    currentfile = filename;    /* Checks if this is a tex file */    det_tflag(filename);    det_defdupchar(filename);    if ((infile = fopen(filename, "r")) == NULL) {		fprintf(stderr, CANT_OPEN, filename);		sleep((unsigned) 2);		return;    }    det_readonly_access(filename);    open_outfile(&statbuf);    quit = 0;    changes = 0;    checkfile();    fclose(infile);    fclose(outfile);    if (!cflag)        treeoutput();    if (changes && !readonly)        update_file(filename, &statbuf);    unlink(tempfile);}

void inst_book(char *student_id) {  int c;  char buff[100];  struct tm tim;  time_t now= time(0);    tim= *(localtime(&now));  strftime (buff, 100, "%d/%m/%Y %H:%M:%S", &tim);  initscr();  mvprintw(0,40,buff);    c= get_comp(student_id,tim.tm_hour,tim.tm_min,1);  if(c==0)    mvprintw(9,10,"Sorry! All computers booked at the moment");  else {    tim.tm_hour ++;    strftime (buff, 100, "%d/%m/%Y %H:%M:%S", &tim);    mvprintw(9,10,"Successfully booked comp_id = %d under user_id /"%s/"/n/t/tuptill %s",c,student_id,buff);  }  refresh();  if(!get_confirm())    return;  if(c!=0)    update_file(c,student_id,tim.tm_hour-1,tim.tm_min,1);}

static intemit_code_defs(const char *to){  const char *tmp = "vmi.tmp";  FILE *out = fopen(tmp, "w");  int i;  fprintf(out, "/*  File: %s/n/n", to);  fprintf(out, "    This file provides the definition of type code./n");  fprintf(out, "/n");  fprintf(out, "    Note: this file is generated by %s from %s.  DO NOT EDIT", program, vmi_file);  fprintf(out, "    /n");  fprintf(out, "*//n/n");  fprintf(out, "typedef enum/n");  fprintf(out, "{/n");  for(i=0; i<vmi_count; i++)  { fprintf(out, "  %s,/n", vmi_list[i].name);  }  fprintf(out, "  VMI_END_LIST/n");  fprintf(out, "} vmi;/n/n");  fprintf(out, "#define I_HIGHEST ((int)VMI_END_LIST)/n");  fprintf(out, "#define VM_SIGNATURE 0x%x/n", MurmurHashAligned2(synopsis, syn_size, 0x12345678));  fclose(out);  return update_file(tmp, to);}

unsigned intnum_cpustates_func ( void ){   char *p;   unsigned int i=0;   proc_stat.last_read.tv_sec=0;   proc_stat.last_read.tv_usec=0;   p = update_file(&proc_stat);   proc_stat.last_read.tv_sec=0;   proc_stat.last_read.tv_usec=0;/*** Skip initial "cpu" token*/   p = skip_token(p);   p = skip_whitespace(p);/*** Loop over file until next "cpu" token is found.** i=4 : Linux 2.4.x** i=7 : Linux 2.6.x*/   while (strncmp(p,"cpu",3)) {     p = skip_token(p);     p = skip_whitespace(p);     i++;     }   return i;}

intmain (int argc, char **argv){  int ch, executable_stack = 0, recovery_code = 0;  extern int optind;  prog_name = argv[0];  if (argc < 2)    {      usage (stderr);      exit (-1);    }  while (1)    {      ch = getopt_long (argc, argv, "eErRh", long_options, NULL);      if (ch == -1)        break;      switch (ch)        {        case 'e': executable_stack = -1; break;        case 'E': executable_stack =  1; break;        case 'r': recovery_code = -1; break;        case 'R': recovery_code =  1; break;        case 'h': usage (stdout); exit (0);        }    }  while (optind < argc)    update_file (argv[optind++], executable_stack, recovery_code);  return 0;}

/* * A helper function to return the total number of cpu jiffies */JTtotal_jiffies_func ( void ){   char *p;   JT user_jiffies, nice_jiffies, system_jiffies, idle_jiffies,                 wio_jiffies, irq_jiffies, sirq_jiffies;   p = update_file(&proc_stat);   p = skip_token(p);   p = skip_whitespace(p);   user_jiffies = strtod( p, &p );   p = skip_whitespace(p);   nice_jiffies = strtod( p, &p );   p = skip_whitespace(p);   system_jiffies = strtod( p, &p );   p = skip_whitespace(p);   idle_jiffies = strtod( p, &p );   if(num_cpustates == NUM_CPUSTATES_24X)     return user_jiffies + nice_jiffies + system_jiffies + idle_jiffies;   p = skip_whitespace(p);   wio_jiffies = strtod( p, &p );   p = skip_whitespace(p);   irq_jiffies = strtod( p, &p );   p = skip_whitespace(p);   sirq_jiffies = strtod( p, &p );   return user_jiffies + nice_jiffies + system_jiffies + idle_jiffies +          wio_jiffies + irq_jiffies + sirq_jiffies;}

g_val_tcpu_idle_func ( void ){   char *p;   static g_val_t val;   static struct timeval stamp={0, 0};   static JT last_idle_jiffies,  idle_jiffies,             last_total_jiffies, total_jiffies, diff;   p = update_file(&proc_stat);   if((proc_stat.last_read.tv_sec != stamp.tv_sec) &&      (proc_stat.last_read.tv_usec != stamp.tv_usec)) {     stamp = proc_stat.last_read;     p = skip_token(p);     p = skip_token(p);     p = skip_token(p);     p = skip_token(p);     idle_jiffies  = strtod( p , (char **)NULL );     total_jiffies = total_jiffies_func();     diff = idle_jiffies - last_idle_jiffies;     if ( diff )       val.f = ((double)diff/(double)(total_jiffies - last_total_jiffies)) * 100.0;     else       val.f = 0.0;     last_idle_jiffies  = idle_jiffies;     last_total_jiffies = total_jiffies;   }   return val;}

g_val_tcpu_nice_func ( void ){   char *p;   static g_val_t val;   static struct timeval stamp={0, 0};   static JT last_nice_jiffies,  nice_jiffies,             last_total_jiffies, total_jiffies, diff;   p = update_file(&proc_stat);   if((proc_stat.last_read.tv_sec != stamp.tv_sec) &&      (proc_stat.last_read.tv_usec != stamp.tv_usec)) {     stamp = proc_stat.last_read;     p = skip_token(p);     p = skip_token(p);     nice_jiffies  = strtod( p , (char **)NULL );     total_jiffies = total_jiffies_func();     diff = (nice_jiffies  - last_nice_jiffies);     if ( diff )       val.f = ((double)diff/(double)(total_jiffies - last_total_jiffies)) * 100.0;     else       val.f = 0.0;     val.f = sanityCheck( __LINE__, __FILE__, __FUNCTION__, val.f, (double)diff, (double)(total_jiffies - last_total_jiffies), nice_jiffies, last_nice_jiffies, total_jiffies, last_total_jiffies );     last_nice_jiffies  = nice_jiffies;     last_total_jiffies = total_jiffies;   }   return val;}

static g_val_t multi_cpu_sintr_func (int cpu_index){    char *p;    cpu_util *cpu = &(cpu_sintr[cpu_index]);        if (num_cpustates == NUM_CPUSTATES_24X) {        cpu->val.f = 0.;        return cpu->val;    }        p = update_file(&proc_stat);    if((proc_stat.last_read.tv_sec != cpu->stamp.tv_sec) &&       (proc_stat.last_read.tv_usec != cpu->stamp.tv_usec)) {        cpu->stamp = proc_stat.last_read;            p = find_cpu (p, cpu_index, &cpu->curr_total_jiffies);        p = skip_token(p);        p = skip_token(p);        p = skip_token(p);        p = skip_token(p);        p = skip_token(p);        p = skip_token(p);        p = skip_whitespace(p);            calculate_utilization (p, cpu);    }        return cpu->val;}

g_val_t cpu_idle_func ( void ){   char *p;   static g_val_t val;   static int stamp;   static double last_idle_jiffies,  idle_jiffies,                 last_total_jiffies, total_jiffies, diff;    p = update_file(&proc_stat);   if(proc_stat.last_read != stamp) {     stamp = proc_stat.last_read;          p = skip_token(p);     p = skip_token(p);     p = skip_token(p);     p = skip_token(p);     idle_jiffies  = strtod( p , (char **)NULL );     total_jiffies = total_jiffies_func();          diff = idle_jiffies - last_idle_jiffies;          if ( diff )        val.f = (diff/(total_jiffies - last_total_jiffies))*100;     else       val.f = 0.0;          last_idle_jiffies  = idle_jiffies;     last_total_jiffies = total_jiffies;        }      return val;}

void repository::distributor::update_meta(const entry &package) {  try {    BUNSAN_LOG_DEBUG << "Starting /"" << package << "/" " << __func__;    const tempfile checksum_tmp = local_system_().small_tempfile();    try {      m_fetcher->fetch(checksum_url(package), checksum_tmp.path());    } catch (std::exception &) {      BOOST_THROW_EXCEPTION(          distributor_update_meta_no_package_error()          << distributor_update_meta_no_package_error::path(checksum_tmp.path())          << distributor_update_meta_no_package_error::message(                 "Unable to fetch checksum") << enable_nested_current());    }    boost::filesystem::copy_file(        checksum_tmp.path(), cache_().checksum_path(package),        boost::filesystem::copy_option::overwrite_if_exists);    update_file(index_url(package), cache_().index_path(package),                // /pre index is treated like regular source                cache_().read_checksum(package).at(format().name.get_index()));  } catch (std::exception &) {    BOOST_THROW_EXCEPTION(distributor_update_meta_error()                          << distributor_update_meta_error::package(package)                          << enable_nested_current());  }}

double cpu_idle_func ( void ) {	char *p;	static double val; 	static double last_idle_jiffies,  idle_jiffies,	              last_total_jiffies, total_jiffies, diff;									  	p = update_file(&proc_stat);		      	p = skip_token(p);	p = skip_token(p);	p = skip_token(p);	p = skip_token(p);	idle_jiffies  = strtod( p , (char **)NULL );	total_jiffies = total_jiffies_func();		 	diff = idle_jiffies - last_idle_jiffies;																							   	if ( diff ) 		val = (diff/(total_jiffies - last_total_jiffies))*100;	else 		val = 0.0; 	last_idle_jiffies = idle_jiffies;	last_total_jiffies = total_jiffies;	return val; }

// sorting itemcode are calculated herevoid Inventory::sortItem_code(ingredient inventory[]){	x = readFile();	for( int i = 1; i <= x; ++i )	{		while( inventory[i].itemcode < inventory[i-1].itemcode )		{            // swapping the item so that the lowest is at the top			swap( inventory[i].itemcode, inventory[i-1].itemcode );			swap( inventory[i].perPrice, inventory[i-1].perPrice );			swap( inventory[i].itemName, inventory[i-1].itemName );			swap( inventory[i].intrQty, inventory[i-1].intrQty );			 // see predefined function above			--i;			if( !i )			break;		}	}	system("cls");	cout << "Sorted by Itemcode" << endl;	bar();	printInventory(inventory, x);	update_file();	cout << "/n/nPress any key to continue...";	getch();	menuDisplay();}

static intemit_jump_table(const char *to){  const char *tmp = "vmi.tmp";  FILE *out = fopen(tmp, "w");  int i;  fprintf(out, "/*  File: %s/n/n", to);  fprintf(out, "    This file provides the GCC-2 jump-labels to exploit GCC's/n");  fprintf(out, "    support for threaded code./n");  fprintf(out, "/n");  fprintf(out, "    Note: this file is generated by %s from %s.  DO NOT EDIT", program, vmi_file);  fprintf(out, "    /n");  fprintf(out, "*//n/n");  fprintf(out, "static void *jmp_table[] =/n");  fprintf(out, "{/n");  for(i=0; i<vmi_count; i++)  { fprintf(out, "  &&%s_LBL,/n", vmi_list[i].name);  }  fprintf(out, "  NULL/n");  fprintf(out, "};/n");  fclose(out);  return update_file(tmp, to);}

g_val_tload_one_func ( void ){   g_val_t val;   val.f = strtod( update_file(&proc_loadavg), (char **)NULL);   return val;}

static void conflict_rename_dir(struct merge_options *o,				struct rename *ren1,				const char *branch1){	char *new_path = unique_path(o, ren1->pair->two->path, branch1);	output(o, 1, "Renaming %s to %s instead", ren1->pair->one->path, new_path);	remove_file(o, 0, ren1->pair->two->path, 0);	update_file(o, 0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path);	free(new_path);}

	//子进程写文件	void do_child_loop(int sem_set_id, char* file_name)	{		pid_t pid = getpid();		int i, j;		for (i=0; i<3; i++) {			update_file(sem_set_id, file_name, pid);			for (j=0; j<400000; j++) ;		}	}

int counter_staff(int no_staff)    /*Recursion function*/{	while(no_staff>0)	{		staff=enter_staff_data(staff);		update_file(staff);		return counter_staff(no_staff-1);	}	return 0;}

double load_five_func ( void ) {	char *p;	double val;	p = update_file(&proc_loadavg);	p = skip_token(p);	val = strtod( p, (char **)NULL);	return val;}

/* * This function is called only once by the gmond.  Use to * initialize data structures, etc or just return SYNAPSE_SUCCESS; */g_val_tmetric_init(void){   g_val_t rval;   char * dummy;   struct stat struct_stat;   num_cpustates = num_cpustates_func();   /* scaling_max_freq will contain the max CPU speed if available */   cpufreq = 0;   if ( stat(SCALING_MAX_FREQ, &struct_stat) == 0 ) {      cpufreq = 1;      dummy = sys_devices_system_cpu;      slurpfile(SCALING_MAX_FREQ, &dummy, 32);   }   dummy = proc_cpuinfo;   rval.int32 = slurpfile("/proc/cpuinfo", &dummy, BUFFSIZE);   if (proc_cpuinfo == NULL)      proc_cpuinfo = dummy;   if ( rval.int32 == SLURP_FAILURE )      {         err_msg("metric_init() got an error from slurpfile() /proc/cpuinfo");         rval.int32 = SYNAPSE_FAILURE;         return rval;      }   dummy = proc_sys_kernel_osrelease;   rval.int32 = slurpfile("/proc/sys/kernel/osrelease", &dummy,                          MAX_G_STRING_SIZE);   if ( rval.int32 == SLURP_FAILURE )      {         err_msg("metric_init() got an error from slurpfile()");         rval.int32 = SYNAPSE_FAILURE;         return rval;      }   /* Get rid of pesky /n in osrelease */   proc_sys_kernel_osrelease[rval.int32-1] = '/0';   dummy = update_file(&proc_net_dev);   if ( dummy == NULL )      {         err_msg("metric_init() got an error from update_file()");         rval.int32 = SYNAPSE_FAILURE;         return rval;      }   update_ifdata("metric_inint");   rval.int32 = SYNAPSE_SUCCESS;   return rval;}

static void handle_delete_modify(struct merge_options *o,                                 const char *path,                                 const char *new_path,                                 unsigned char *a_sha, int a_mode,                                 unsigned char *b_sha, int b_mode){    /* Only need to checkout other's version if I deleted the file. */    if (!a_sha) {        update_file(o, 0, b_sha, b_mode, new_path);    }}

g_val_tload_five_func ( void ){   char *p;   g_val_t val;   p = update_file(&proc_loadavg);   p = skip_token(p);   val.f = strtod(p, (char **)NULL);   return val;}