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

/** * Write the hit record. * * /param ctx GL context. * * Write the hit record, i.e., the number of names in the stack, the minimum and * maximum depth values and the number of names in the name stack at the time * of the event. Resets the hit flag. * * /sa gl_selection. */static voidwrite_hit_record(struct gl_context *ctx){    GLuint i;    GLuint zmin, zmax, zscale = (~0u);    /* HitMinZ and HitMaxZ are in [0,1].  Multiply these values by */    /* 2^32-1 and round to nearest unsigned integer. */    assert( ctx != NULL ); /* this line magically fixes a SunOS 5.x/gcc bug */    zmin = (GLuint) ((GLfloat) zscale * ctx->Select.HitMinZ);    zmax = (GLuint) ((GLfloat) zscale * ctx->Select.HitMaxZ);    write_record( ctx, ctx->Select.NameStackDepth );    write_record( ctx, zmin );    write_record( ctx, zmax );    for (i = 0; i < ctx->Select.NameStackDepth; i++) {        write_record( ctx, ctx->Select.NameStack[i] );    }    ctx->Select.Hits++;    ctx->Select.HitFlag = GL_FALSE;    ctx->Select.HitMinZ = 1.0;    ctx->Select.HitMaxZ = -1.0;}

static int bwrite (int chan, void *buffer, int nelem, char *dtype)     /* To fill the write buffer of initialized channel "chan". When	the write buffer "chn[chan].buffer" is full, it will write the contents	out to the data file related to the channel */{  int nb, i, j, msg;  msg = send_command_to_server(chn[chan].gchannel, "WRITE");#ifdef DEBUG  printf("mgilib2::bwrite(), ==/n");#endif  if(*dtype == 'I' || *dtype == 'R')    {      nb = write_record(chn[chan].gchannel, (unsigned char *)buffer, nelem, sizeof(int));      get_ack_nack(chn[chan].gchannel);    }  else if(*dtype == 'D')    {      nb = write_record(chn[chan].gchannel, (char *)buffer, nelem, sizeof(double));      get_ack_nack(chn[chan].gchannel);    }    else if(*dtype == 'C')    {      nb = write_record(chn[chan].gchannel, buffer, nelem, 1);      get_ack_nack(chn[chan].gchannel);    }  return nb;}

static int encode(FILE *in, FILE *out) {    unsigned bank = 0, address = 0;    unsigned char buffer[0x10];    size_t nbytes;    /* write data records, 16 bytes each */    while ((nbytes = fread(buffer, 1, sizeof(buffer), in)) > 0) {        write_record(out, (size_t)nbytes, address,                     0, buffer);        address += (size_t)nbytes;        if (address >= BANK_SIZE) {            /* switch to next bank */            bank++;            address %= BANK_SIZE;            write_record(out, 0, 0, 0x10 + bank, NULL);        }    }    /* write end-of-file record */    write_record(out, 0, 0, 1, NULL);    return 0;}

static int save_serial(ulong address, ulong count){	int i, c, reclen, checksum, length;	char *hex = "0123456789ABCDEF";	char record[2*SREC_BYTES_PER_RECORD+16]; /* buffer for one S-Record */	char data[2*SREC_BYTES_PER_RECORD+1];	/* buffer for hex data	*/	reclen = 0;	checksum = 0;	if (write_record(SREC3_START))	/* write the header */		return -1;	do {		if (count) {		/* collect hex data in the buffer  */			c = *(volatile uchar*)(address + reclen);	/* get one byte    */			checksum += c;	/* accumulate checksum */			data[2*reclen]   = hex[(c>>4)&0x0f];			data[2*reclen+1] = hex[c & 0x0f];			data[2*reclen+2] = '/0';			++reclen;			--count;		}		if (reclen == SREC_BYTES_PER_RECORD || count == 0) {			/* enough data collected for one record: dump it */			if (reclen) {	/* build & write a data record: */				/* address + data + checksum */				length = 4 + reclen + 1;				/* accumulate length bytes into checksum */				for (i = 0; i < 2; i++)					checksum += (length >> (8*i)) & 0xff;				/* accumulate address bytes into checksum: */				for (i = 0; i < 4; i++)					checksum += (address >> (8*i)) & 0xff;				/* make proper checksum byte: */				checksum = ~checksum & 0xff;				/* output one record: */				sprintf(record, SREC3_FORMAT, length, address, data, checksum);				if (write_record(record))					return -1;			}			address  += reclen;  /* increment address */			checksum  = 0;			reclen    = 0;		}	} while (count);	if (write_record(SREC3_END))	/* write the final record */		return -1;	return 0;}

int main (int argc, char *argv[])  {    // Déclare un timer, ainsi que deux recorder qui vont contenir les résultats de l'exécution du programme    timer *t = timer_alloc();    recorder *bash_rec = recorder_alloc("shell-bash.csv");    recorder *prog_rec = recorder_alloc("shell-prog.csv");    // Nom du programme C et du script à comparer    char * progr = "./shell-program ";    char * bash =  "./shell-bash.sh ";    // Cette variable contient la transformation du nombre d'instruction (i).    // Puisque cette variable est un int, 7 caractères suffisent à sa représentation.    char  nbr[7];    int i;    // Allocation des emplacements contenant la commande à exécuter    char*argProgr = (char *) malloc(24*sizeof(char));    char*argBash = (char *) malloc(24*sizeof(char));    if(argProgr == NULL || argBash == NULL)        exit(EXIT_FAILURE);    for(i=1; i<MAX_SIZE; i+=1) {        // Convertit "i" en char* et le place dans nbr        snprintf(nbr, 7, "%d", i);        // Concatene les deux parties de la commande        strncpy(argProgr, progr, 24);        strncpy(argBash, bash, 24);        strncat(argProgr, nbr, 7);        strncat(argBash, nbr, 7);        // Commence le timer et lance la commande, puis écrit le résultat dans le record approprié        start_timer(t);        system(argProgr);        write_record(prog_rec, i, stop_timer(t));        start_timer(t);        system(argBash);        write_record(bash_rec, i, stop_timer(t));    }    // Libère la mémoire    recorder_free(bash_rec);    recorder_free(prog_rec);    timer_free(t);    return EXIT_SUCCESS;}

static voidgenerate_process64ex_record(const char *directory, const char *record_filename,    u_int32_t type){	token_t *process64ex_token;	char *buf;	buf = (char *)malloc(strlen(record_filename) + 6);	if (type == AU_IPv6) {		inet_pton(AF_INET6, "fe80::1", process64_tid_addr.at_addr);		process64_tid_addr.at_type = AU_IPv6;		sprintf(buf, "%s%s", record_filename, "-IPv6");	} else {		process64_tid_addr.at_addr[0] = inet_addr("127.0.0.1");		process64_tid_addr.at_type = AU_IPv4;		sprintf(buf, "%s%s", record_filename, "-IPv4");	}	process64ex_token = au_to_process64_ex(process64_auid, process64_euid,	    process64_egid, process64_ruid, process64_rgid, process64_pid,	    process64_sid, &process64_tid_addr);	if (process64ex_token == NULL)		err(EX_UNAVAILABLE, "au_to_process64_ex");	write_record(directory, buf, process64ex_token, AUE_NULL);	free(buf);}

void save_area(struct element *xy, int num_points, int category){    int incr;    float first_cell, last_cell;    for (incr = 0; incr < num_points;) {	if (START_ROW != STOP_ROW) {	    fprintf(stderr, "ERROR: start and end row not same/n");	    for (incr = 0; incr < num_points; incr += 2) {		fprintf(stderr, "%d: %d %f %d %f/n",			incr, xy[incr].row, xy[incr].col,			xy[incr + 1].row, xy[incr + 1].col);	    }	    incr++;	    continue;	}	first_cell = START_COL + 1.;	last_cell = STOP_COL;	if (last_cell >= first_cell)	    write_record(START_ROW, first_cell, last_cell, category);	incr += 2;    }}

/* Tries to write the specified number of records. Stops when the log gets   full. Returns the number of records written. Spins for random   number of times, up to 'max_spin_count', between writes. */static size_t write_records_to_log(int writer_id, int32_t record_size,                                   int32_t num_records,                                   int32_t max_spin_count) {  int32_t ix;  int counter = 0;  for (ix = 0; ix < num_records; ++ix) {    int32_t jx;    int32_t spin_count = max_spin_count ? rand() % max_spin_count : 0;    char *record;    if (counter++ == num_records / 10) {      printf("   Writer %d: %d out of %d written/n", writer_id, ix,             num_records);      counter = 0;    }    record = (char *)(census_log_start_write(record_size));    if (record == NULL) {      return ix;    }    write_record(record, record_size);    census_log_end_write(record, record_size);    for (jx = 0; jx < spin_count; ++jx) {      GPR_ASSERT(jx >= 0);    }  }  return num_records;}

gbooleanamar_file_close(    amar_file_t *file,    GError **error){    gboolean success = TRUE;    amar_t *archive = file->archive;    /* close all attributes that haven't already written EOA */    g_hash_table_foreach(file->attributes, foreach_attr_close, error);    if (*error)	success = FALSE;    /* write an EOF record */    if (success) {	if (!write_record(archive, file->filenum, AMAR_ATTR_EOF, 1,			  NULL, 0, error))	    success = FALSE;    }    /* remove from archive->file list */    g_hash_table_remove(archive->files, &file->filenum);    /* clean up */    g_hash_table_destroy(file->attributes);    amfree(file);    return success;}

void entry_menu(){  int ch,num;  clrscr();  cout<<"/n/n/n/t/tENTRY MENU";  cout<<"/n/n/t1.CREATE STUDENT RECORD";  cout<<"/n/n/t2.DISPLAY ALL STUDENTS RECORD";  cout<<"/n/n/t3.SEARCH STUDENT RECORD";  cout<<"/n/n/t4.MODIFY STUDENT RECORD ";  cout<<"/n/n/t5.DELETE STUDENT RECORD ";  cout<<"/n/n/t6.RETURN TO MAIN MENU";  cout<<"/n/nPlease Enter Your Choice(1-6).......";  cin>>ch;  clrscr();  switch(ch)  {	  case 1:write_record();break;	  case 2:read_record();break;	  case 3:cout<<"/n/n/tPlease enter the roll no. of student ";		 cin>>num;		 display(num);		 break;	  case 4:cout<<"/n/n/tPlease enter the roll no. of student ";		 cin>>num;		 modify_record(num);		 break;	  case 5:cout<<"/n/n/tPlease enter the roll no. of student ";		 cin>>num;	    delete_record(num);		 break;     case 6:break;     default : cout<<"/a";entry_menu();  }}

void DbDumperWriter::run(tbsys::CThread *thr_, void *arg){  last_rotate_time_ = time(NULL);  UNUSED(thr_);  UNUSED(arg);  int ret = OB_SUCCESS;  while(running_ || !records_.empty()) {    ret = OB_SUCCESS;    bool flush = !running_;    if (need_rotate_output_file()) {      ret = rotate_output_file();      if (ret != OB_SUCCESS) {        TBSYS_LOG(ERROR, "can't rotate file");        break;      }    }    if (ret == OB_SUCCESS) {      ret = write_record(flush);       if (ret != OB_SUCCESS) {        TBSYS_LOG(ERROR, "write record failed, %d", ret);        sleep(1);      }    }  }  //mv last_file.TMP to last_file  if (ret == OB_SUCCESS)    mv_output_file();}

void TeamEdit::save() {    dbo::Transaction t(tApp->session());    write_record(team_.modify(), /* init */ false);    team_chat(team_, "change name/description of the team", tApp->user());    t.commit();    t_emit(TEAM_OBJECT, team_.id());}

int main (int argc, char *argv[])  {  timer *t = timer_alloc();  recorder *parent_rec = recorder_alloc("parent.csv");  recorder *child_rec = recorder_alloc("child.csv");  pid_t pid;  int status, i;  for (i = 0; i < N; i++) {    start_timer(t);    pid = fork();    if (pid == -1) {      // erreur à l'exécution de fork      perror("fork");      return EXIT_FAILURE;    }    // pas d'erreur    // BEGIN    if (pid == 0) {      // processus fils      write_record(child_rec, i, stop_timer(t));      recorder_free(child_rec);      recorder_free(parent_rec);      timer_free(t);      return EXIT_SUCCESS;    }    else {      // processus père      write_record(parent_rec, i, stop_timer(t));      pid = waitpid(pid, &status, 0);      if (pid == -1) {        perror("wait");        return EXIT_FAILURE;      }    }    // END  }  recorder_free(child_rec);  recorder_free(parent_rec);  timer_free(t);  return EXIT_SUCCESS;}

int mcs_file::save(const char* file, void* data, int len){	FILE* f;	int rc = -1;    int addr, addr_offs, count;	const int buff_len = 16;	union {		u8 buff[buff_len];		u16 word;	} u;	f = fopen(file, "wt");	if (f == NULL)	{		msgf(STR_UNABLE_TO_OPEN_FILE);		return -1;	}    addr = 0;    addr_offs = 0;        u.word = 0x0000;    if (write_record(f, 2, 0, RECORD_ADDRESS, u.buff))        goto cleanup;        while (addr_offs + addr < len)    {        if (addr_offs + addr + buff_len < len)            count = buff_len;        else            count = len - addr_offs - addr;        if (write_record(f, count, addr, RECORD_DATA, (u8*)data + addr_offs + addr))            goto cleanup;        addr += count;        if (addr >= 0x10000 && addr_offs + addr < len)        {            addr_offs += 0x10000;            addr &= 0xFFFF;            u.word = HTON16(addr_offs >> 16);            if (write_record(f, 2, 0, RECORD_ADDRESS, u.buff))                goto cleanup;        }    }

void file_bstore::write_root(const std::vector<char>& record){    if (m_cur_slab == NULL)        throw io_exception("file_store is not open");    lock_t lock(m_mutex);    m_root = write_record('R', record);    //printf("Writing root record: %d/n", (int) m_root);}

int avro_schema_to_json(const avro_schema_t schema, avro_writer_t out){	check_param(EINVAL, is_avro_schema(schema), "schema");	check_param(EINVAL, out, "writer");	int rval;	if (is_avro_primitive(schema)) {		check(rval, avro_write_str(out, "{/"type/":/""));	}	switch (avro_typeof(schema)) {	case AVRO_STRING:		check(rval, avro_write_str(out, "string"));		break;	case AVRO_BYTES:		check(rval, avro_write_str(out, "bytes"));		break;	case AVRO_INT32:		check(rval, avro_write_str(out, "int"));		break;	case AVRO_INT64:		check(rval, avro_write_str(out, "long"));		break;	case AVRO_FLOAT:		check(rval, avro_write_str(out, "float"));		break;	case AVRO_DOUBLE:		check(rval, avro_write_str(out, "double"));		break;	case AVRO_BOOLEAN:		check(rval, avro_write_str(out, "boolean"));		break;	case AVRO_NULL:		check(rval, avro_write_str(out, "null"));		break;	case AVRO_RECORD:		return write_record(out, avro_schema_to_record(schema));	case AVRO_ENUM:		return write_enum(out, avro_schema_to_enum(schema));	case AVRO_FIXED:		return write_fixed(out, avro_schema_to_fixed(schema));	case AVRO_MAP:		return write_map(out, avro_schema_to_map(schema));	case AVRO_ARRAY:		return write_array(out, avro_schema_to_array(schema));	case AVRO_UNION:		return write_union(out, avro_schema_to_union(schema));	case AVRO_LINK:		return write_link(out, avro_schema_to_link(schema));	}	if (is_avro_primitive(schema)) {		return avro_write_str(out, "/"}");	}	avro_set_error("Unknown schema type");	return EINVAL;}

static void at_exit(void){	write_log();	write_record();	if (unlink(lockname) < 0) {		fprintf(stderr, "%s: cannot unlink '%s'/n", PACKAGE_NAME, lockname);		fprintf(stderr, "%s: %s/n", PACKAGE_NAME, strerror(errno));	}}

int main(int argc, char *argv[]) {    FILE *in_fp                = NULL;    FILE *out_fp               = NULL;    FILE *err_fp               = NULL;    char *in_file              = "/dev/stdin";    char *out_file             = NULL;    char *err_file             = NULL;    int   byte_no              = 0;    int   record_no            = 0;    int   rc                   = 0;    int   time_travel          = DEFAULT_TIME_TRAVEL;    struct futmpx record, last_valid_record;    debug("Record length: %i/n/n", RECORD_LENGTH);    (void)memset(&last_valid_record, 0, RECORD_LENGTH);    (void)memset(&record, 0, RECORD_LENGTH);    /* Functions parse_args() and open_files() exit on error: */    parse_args(argc, argv, &out_file, &err_file, &time_travel);    open_files(in_file, &in_fp, out_file, &out_fp, err_file, &err_fp);    /* Loop over input file records */    byte_no = 0;    record_no = 0;    while(1 == fread(&record, RECORD_LENGTH, 1, in_fp)) {        byte_no += RECORD_LENGTH;        record_no++;        if(g_DEBUG) {            print_record(stderr, record_no, byte_no, record);        }        if(is_record_valid(last_valid_record, record, time_travel)) {            if(out_fp) {                write_record(out_fp, record);            }            (void)memcpy(&last_valid_record, &record, RECORD_LENGTH);        } else {            rc = 1;            debug("Invalid record encountered at byte %i, seeking/n", byte_no);            seek_valid_record(in_fp, &byte_no, time_travel, last_valid_record, &record, err_fp);        }    }    if(ferror(in_fp)) {        error("a read error occurred at or around byte %i/n", byte_no);        rc = 1;    }    /* Tidy up and exit */    rc |= flush_and_close_files(in_file, in_fp, out_file, out_fp, err_file, err_fp);    rc |= check_out_file_size(out_file);    return rc;}

static voidgenerate_ipc_record(const char *directory, const char *record_filename){	token_t *ipc_token;	ipc_token = au_to_ipc(ipc_type, ipc_id);	if (ipc_token == NULL)		err(EX_UNAVAILABLE, "au_to_ipc");	write_record(directory, record_filename, ipc_token, AUE_NULL);}

static voidarraystorage_backup(void *self, FILE *f){  if (self == 0)    return;  int i;  CountryStorage *rs = (CountryStorage *) self;  for (i=0; i < rs->maxid; i++)    write_record(f,rs->countries[i]);}

static voidgenerate_file_record(const char *directory, const char *record_filename){	token_t *file_token;	file_token = au_to_file("test", file_token_timeval);	if (file_token == NULL)		err(EX_UNAVAILABLE, "au_to_file");	write_record(directory, record_filename, file_token, AUE_NULL);}

static voidgenerate_zonename_record(const char *directory, const char *record_filename){	token_t *zonename_token;	zonename_token = au_to_zonename(zonename_sample);	if (zonename_token == NULL)		err(EX_UNAVAILABLE, "au_to_zonename");	write_record(directory, record_filename, zonename_token, AUE_NULL);}

static voidgenerate_opaque_record(const char *directory, const char *record_filename){	token_t *opaque_token;	opaque_token = au_to_opaque(opaque_token_data, opaque_token_bytes);	if (opaque_token == NULL)		err(EX_UNAVAILABLE, "au_to_opaque");	write_record(directory, record_filename, opaque_token, AUE_NULL);}

static voidgenerate_seq_record(const char *directory, const char *record_filename){	token_t *seq_token;	seq_token = au_to_seq(seq_audit_count);	if (seq_token == NULL)		err(EX_UNAVAILABLE, "au_to_seq");	write_record(directory, record_filename, seq_token, AUE_NULL);}

static voidgenerate_text_record(const char *directory, const char *record_filename){	token_t *text_token;	text_token = au_to_text(text_token_text);	if (text_token == NULL)		err(EX_UNAVAILABLE, "au_to_text");	write_record(directory, record_filename, text_token, AUE_NULL);}

static voidgenerate_path_record(const char *directory, const char *record_filename){	token_t *path_token;	path_token = au_to_path(path_token_path);	if (path_token == NULL)		err(EX_UNAVAILABLE, "au_to_path");	write_record(directory, record_filename, path_token, AUE_NULL);}

static voidwrite_recent_blocks (union block *h, size_t blocks){  size_t i;  for (i = 0; i < blocks; i++)    {      new_record[new_blocks++] = h[i];      if (new_blocks == blocking_factor)	write_record (1);    }}

static voidgenerate_arg32_record(const char *directory, const char *record_filename){	token_t *arg32_token;	arg32_token = au_to_arg32(arg32_token_n, arg32_token_text,	    arg32_token_v);	if (arg32_token == NULL)		err(EX_UNAVAILABLE, "au_to_arg32");	write_record(directory, record_filename, arg32_token, AUE_NULL);}

static voidgenerate_return32_record(const char *directory, const char *record_filename){	token_t *return32_token;	return32_token = au_to_return32(au_errno_to_bsm(return32_status),	    return32_ret);	if (return32_token == NULL)		err(EX_UNAVAILABLE, "au_to_return32");	write_record(directory, record_filename, return32_token, AUE_NULL);}

static voidgenerate_data_record(const char *directory, const char *record_filename){	token_t *data_token;	data_token = au_to_data(data_token_unit_print, data_token_unit_type,	    data_token_unit_count, data_token_data);	if (data_token == NULL)		err(EX_UNAVAILABLE, "au_to_data");	write_record(directory, record_filename, data_token, AUE_NULL);}