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

inline VALUE wrap< CEGUI::FrameComponent >(CEGUI::FrameComponent *framecomponent ){	return Data_Wrap_Struct(rb_cCeguiFrameComponent, NULL, NULL, framecomponent);}

static VALUE cState_s_allocate(VALUE klass){    JSON_Generator_State *state = State_allocate();    return Data_Wrap_Struct(klass, NULL, State_free, state);}

static VALUE connection_parent_context_alloc(VALUE klass) {    redisParentContext *pc = malloc(sizeof(*pc));    pc->context = NULL;    pc->timeout = NULL;    return Data_Wrap_Struct(klass, parent_context_mark, parent_context_free, pc);}

static VALUErb_cogl_program_allocate (VALUE klass){  return Data_Wrap_Struct (klass, NULL, rb_cogl_program_free, NULL);}

VALUEnew_object(int blocksize){  CvMemStorage *storage = cvCreateMemStorage(blocksize);  return Data_Wrap_Struct(rb_klass, 0, free, storage);}

static VALUEfs_watcher_init(VALUE arg) {	FSWatcher *watcher = (FSWatcher *) arg;	struct kevent *events;	VALUE filename;	unsigned int i;	uint32_t fflags;	VALUE filenum;	struct stat buf;	int fd;		/* Open each file in the filenames list and add each one to the events array. */		/* +2 for the termination pipe and the interruption pipe. */	events = alloca((RARRAY_LEN(watcher->filenames) + 2) * sizeof(struct kevent));	watcher->fds = malloc(RARRAY_LEN(watcher->filenames) * sizeof(int));	if (watcher->fds == NULL) {		rb_raise(rb_eNoMemError, "Cannot allocate memory.");		return Qnil;	}	for (i = 0; i < RARRAY_LEN(watcher->filenames); i++) {		filename = rb_ary_entry(watcher->filenames, i);		if (TYPE(filename) != T_STRING) {			filename = rb_obj_as_string(filename);		}				if (stat(RSTRING_PTR(filename), &buf) == -1) {			watcher->preparation_error = 1;			goto end;		}				#ifdef O_EVTONLY			fd = open(RSTRING_PTR(filename), O_EVTONLY);		#else			fd = open(RSTRING_PTR(filename), O_RDONLY);		#endif		if (fd == -1) {			watcher->preparation_error = 1;			goto end;		}				watcher->fds[i] = fd;		watcher->fds_len++;		fflags = NOTE_WRITE | NOTE_EXTEND | NOTE_RENAME | NOTE_DELETE | NOTE_REVOKE;		EV_SET(&events[i], fd, EVFILT_VNODE, EV_ADD | EV_ENABLE | EV_CLEAR,			fflags, 0, 0);	}		watcher->events_len = watcher->fds_len;		/* Create pipes for inter-thread communication. */		if (pipe(watcher->notification_fd) == -1) {		rb_sys_fail("pipe()");		return Qnil;	}	if (pipe(watcher->interruption_fd) == -1) {		rb_sys_fail("pipe()");		return Qnil;	}		/* Create a kqueue and register all events. */		watcher->kq = kqueue();	if (watcher->kq == -1) {		rb_sys_fail("kqueue()");		return Qnil;	}		if (watcher->termination_pipe != Qnil) {		filenum = rb_funcall(watcher->termination_pipe,			rb_intern("fileno"), 0);		EV_SET(&events[watcher->events_len], NUM2INT(filenum),			EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, 0);		watcher->termination_fd = NUM2INT(filenum);		watcher->events_len++;	}	EV_SET(&events[watcher->events_len], watcher->interruption_fd[0],		EVFILT_READ, EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, 0);	watcher->events_len++;		if (kevent(watcher->kq, events, watcher->events_len, NULL, 0, NULL) == -1) {		rb_sys_fail("kevent()");		return Qnil;	}	end:	if (watcher->preparation_error) {		for (i = 0; i < watcher->fds_len; i++) {			close(watcher->fds[i]);		}		free(watcher->fds);		watcher->fds = NULL;		watcher->fds_len = 0;	}	return Data_Wrap_Struct(watcher->klass, NULL, fs_watcher_free, watcher);}

static VALUE allocate(VALUE klass){  return Data_Wrap_Struct(klass, NULL, deallocate, NULL);}

// Allocate objectVALUE audio_stream_alloc(VALUE klass) {	AudioStreamInternal * internal = (AudioStreamInternal *)av_mallocz(sizeof(AudioStreamInternal));	if (!internal) rb_raise(rb_eNoMemError, "Failed to allocate internal structure");	return Data_Wrap_Struct(klass, audio_stream_mark, audio_stream_free, (void *)internal);}

VALUE virtualmachine_initialize(VALUE self, VALUE vmname, VALUE memsize){	VALUE vctx, vvme;	struct vmctx *ctx;	struct vm_exit *vme;	uint64_t *gdt, *pt4, *pt3, *pt2;	int i, err;	_vm_create(StringValuePtr(vmname));	ctx = _vm_open(StringValuePtr(vmname));	vctx = Data_Wrap_Struct(rb_cVMCtx, NULL, vmctx_free, ctx);	vme = (struct vm_exit *)calloc(1, sizeof(*vme));	vvme = Data_Wrap_Struct(rb_cVMCtx, NULL, vme_free, vme);	rb_iv_set(self, "@ctx", vctx);	rb_iv_set(self, "@vmname", vmname);	rb_iv_set(self, "@memsize", memsize);	rb_iv_set(self, "@vmexit", vvme);	_vm_setup_memory(ctx, FIX2INT(memsize) * MB, VM_MMAP_ALL);	pt4 = _vm_map_gpa(ctx, ADDR_PT4, sizeof(uint64_t) * 512);	pt3 = _vm_map_gpa(ctx, ADDR_PT3, sizeof(uint64_t) * 512);	pt2 = _vm_map_gpa(ctx, ADDR_PT2, sizeof(uint64_t) * 512);	gdt = _vm_map_gpa(ctx, ADDR_GDT, sizeof(uint64_t) * 3);	bzero(pt4, PAGE_SIZE);	bzero(pt3, PAGE_SIZE);	bzero(pt2, PAGE_SIZE);	for (i = 0; i < 512; i++) {		pt4[i] = (uint64_t)ADDR_PT3;		pt4[i] |= PG_V | PG_RW | PG_U;		pt3[i] = (uint64_t)ADDR_PT2;		pt3[i] |= PG_V | PG_RW | PG_U;		pt2[i] = i * (2 * 1024 * 1024);		pt2[i] |= PG_V | PG_RW | PG_PS | PG_U;	}	gdt[GUEST_NULL_SEL] = 0;	gdt[GUEST_CODE_SEL] = 0x0020980000000000;	gdt[GUEST_DATA_SEL] = 0x0000900000000000;	_vm_set_desc(ctx, 0, VM_REG_GUEST_CS, 0, 0, 0x0000209B);	_vm_set_desc(ctx, 0, VM_REG_GUEST_DS, 0, 0, 0x00000093);	_vm_set_desc(ctx, 0, VM_REG_GUEST_ES, 0, 0, 0x00000093);	_vm_set_desc(ctx, 0, VM_REG_GUEST_FS, 0, 0, 0x00000093);	_vm_set_desc(ctx, 0, VM_REG_GUEST_GS, 0, 0, 0x00000093);	_vm_set_desc(ctx, 0, VM_REG_GUEST_SS, 0, 0, 0x00000093);	_vm_set_desc(ctx, 0, VM_REG_GUEST_TR, 0, 0, 0x0000008b);	_vm_set_desc(ctx, 0, VM_REG_GUEST_LDTR, 0, 0, DESC_UNUSABLE);	_vm_set_desc(ctx, 0, VM_REG_GUEST_GDTR, ADDR_GDT, GUEST_GDTR_LIMIT, 0);	_vm_set_register(ctx, 0, VM_REG_GUEST_CS, GSEL(GUEST_CODE_SEL, SEL_KPL));	_vm_set_register(ctx, 0, VM_REG_GUEST_DS, GSEL(GUEST_DATA_SEL, SEL_KPL));	_vm_set_register(ctx, 0, VM_REG_GUEST_ES, GSEL(GUEST_DATA_SEL, SEL_KPL));	_vm_set_register(ctx, 0, VM_REG_GUEST_FS, GSEL(GUEST_DATA_SEL, SEL_KPL));	_vm_set_register(ctx, 0, VM_REG_GUEST_GS, GSEL(GUEST_DATA_SEL, SEL_KPL));	_vm_set_register(ctx, 0, VM_REG_GUEST_SS, GSEL(GUEST_DATA_SEL, SEL_KPL));	_vm_set_register(ctx, 0, VM_REG_GUEST_TR, 0);	_vm_set_register(ctx, 0, VM_REG_GUEST_LDTR, 0);	_vm_set_register(ctx, 0, VM_REG_GUEST_CR0, CR0_PG | CR0_PE | CR0_NE);	_vm_set_register(ctx, 0, VM_REG_GUEST_CR3, ADDR_PT4);	_vm_set_register(ctx, 0, VM_REG_GUEST_CR4, CR4_PAE | CR4_VMXE);	_vm_set_register(ctx, 0, VM_REG_GUEST_EFER, EFER_LMA | EFER_LME);	_vm_set_register(ctx, 0, VM_REG_GUEST_RFLAGS, 0x2);	_vm_set_register(ctx, 0, VM_REG_GUEST_RSP, ADDR_STACK);	return self;}

static VALUE allocate(VALUE klass){  alpm_handle_t* p_alpm = NULL;  VALUE obj = Data_Wrap_Struct(klass, 0, deallocate, p_alpm);  return obj;}

static VALUEfdbm_alloc(VALUE klass){    return Data_Wrap_Struct(klass, 0, free_dbm, 0);}

static VALUE ra_sound_allocate(VALUE klass) {    RA_SOUND *snd = ALLOC(RA_SOUND);    memset(snd, 0, sizeof(RA_SOUND));    VALUE self = Data_Wrap_Struct(klass, ra_sound_mark, ra_sound_free, snd);    return self;}

static VALUE rxml_xpath_context_alloc(VALUE klass){  return Data_Wrap_Struct(cXMLXPathContext, rxml_xpath_context_mark, rxml_xpath_context_free, NULL);}

VALUErb_binding_new_from_binding(rb_vm_binding_t *bind){    return Data_Wrap_Struct(rb_cBinding, NULL, NULL, bind);}

VALUErb_allocate(VALUE klass){  CvMemStorage *storage = cvCreateMemStorage();  return Data_Wrap_Struct(klass, 0, free, storage);}

static VALUEmatch_alloc( VALUE klass ) {  struct ofp_match *match = xmalloc( sizeof( struct ofp_match ) );  return Data_Wrap_Struct( klass, NULL, xfree, match );}

static VALUE allocate(VALUE klass){  JohnsonRuntime* runtime = calloc(1L, sizeof(JohnsonRuntime));  return Data_Wrap_Struct(klass, 0, deallocate, runtime);}

/** WkHtml::ToPdf::ObjectSettings*/VALUE wkhtml_topdf_objectsettings_alloc(VALUE self) {  wkhtmltopdf_object_settings* settings = wkhtmltopdf_create_object_settings();  return Data_Wrap_Struct(self, NULL, wkhtmltopdf_destroy_object_settings, settings);}

static VALUEcr_font_face_allocate (VALUE klass){  return Data_Wrap_Struct (klass, NULL, cr_font_face_free, NULL);}

VALUE wkhtml_toimage_globalsettings_alloc(VALUE self) {  wkhtmltoimage_global_settings* settings = wkhtmltoimage_create_global_settings();  return Data_Wrap_Struct(self, NULL, wkhtml_toimage_globalsettings_free, settings); }

VALUE rugged_index_new(VALUE klass, VALUE owner, git_index *index){	VALUE rb_index = Data_Wrap_Struct(klass, NULL, &rb_git_index__free, index);	rugged_set_owner(rb_index, owner);	return rb_index;}

static VALUEUnpacker_alloc(VALUE klass){	unpacker_t *ptr = ALLOC(unpacker_t);	return Data_Wrap_Struct(klass, unpacker_mark, -1, ptr);}

static VALUEruby_xslt_stylesheet_alloc(VALUE klass) {  return Data_Wrap_Struct(cXSLTStylesheet,                          NULL, ruby_xslt_stylesheet_free,                          NULL);}

//.........这里部分代码省略.........  const char *search_path = data_objects_get_uri_option(r_query, "search_path");  db = PQsetdbLogin(    host,    port,    NULL,    NULL,    database,    user,    password  );  if (PQstatus(db) == CONNECTION_BAD) {    rb_raise(eDO_ConnectionError, "%s", PQerrorMessage(db));  }  PGresult *result;  if (search_path) {    char *search_path_query;    if (!(search_path_query = calloc(256, sizeof(char)))) {      rb_memerror();    }    snprintf(search_path_query, 256, "set search_path to %s;", search_path);    r_query = rb_str_new2(search_path_query);    result = do_postgres_cCommand_execute(Qnil, self, db, r_query);    if (PQresultStatus(result) != PGRES_COMMAND_OK) {      free(search_path_query);      do_postgres_raise_error(self, result, r_query);    }    free(search_path_query);  }  const char *backslash_off = "SET backslash_quote = off";  const char *standard_strings_on = "SET standard_conforming_strings = on";  const char *warning_messages = "SET client_min_messages = warning";  const char *date_format = "SET datestyle = ISO";  VALUE r_options;  r_options = rb_str_new2(backslash_off);  result = do_postgres_cCommand_execute(Qnil, self, db, r_options);  if (PQresultStatus(result) != PGRES_COMMAND_OK) {    rb_warn("%s", PQresultErrorMessage(result));  }  r_options = rb_str_new2(standard_strings_on);  result = do_postgres_cCommand_execute(Qnil, self, db, r_options);  if (PQresultStatus(result) != PGRES_COMMAND_OK) {    rb_warn("%s", PQresultErrorMessage(result));  }  r_options = rb_str_new2(warning_messages);  result = do_postgres_cCommand_execute(Qnil, self, db, r_options);  if (PQresultStatus(result) != PGRES_COMMAND_OK) {    rb_warn("%s", PQresultErrorMessage(result));  }  r_options = rb_str_new2(date_format);  result = do_postgres_cCommand_execute(Qnil, self, db, r_options);  if (PQresultStatus(result) != PGRES_COMMAND_OK) {    rb_warn("%s", PQresultErrorMessage(result));  }  VALUE encoding = rb_iv_get(self, "@encoding");#ifdef HAVE_PQSETCLIENTENCODING  VALUE pg_encoding = rb_hash_aref(data_objects_const_get(mDO_PostgresEncoding, "MAP"), encoding);  if (pg_encoding != Qnil) {    if (PQsetClientEncoding(db, rb_str_ptr_readonly(pg_encoding))) {      rb_raise(eDO_ConnectionError, "Couldn't set encoding: %s", rb_str_ptr_readonly(encoding));    }    else {#ifdef HAVE_RUBY_ENCODING_H      rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index(rb_str_ptr_readonly(encoding))));#endif      rb_iv_set(self, "@pg_encoding", pg_encoding);    }  }  else {    rb_warn("Encoding %s is not a known Ruby encoding for PostgreSQL/n", rb_str_ptr_readonly(encoding));    rb_iv_set(self, "@encoding", rb_str_new2("UTF-8"));#ifdef HAVE_RUBY_ENCODING_H    rb_iv_set(self, "@encoding_id", INT2FIX(rb_enc_find_index("UTF-8")));#endif    rb_iv_set(self, "@pg_encoding", rb_str_new2("UTF8"));  }#endif  rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));}

static VALUE helium_rb_allocate(VALUE klass){  return Data_Wrap_Struct(klass, helium_rb_mark, helium_free, helium_alloc());}

// Allocation function for the Kerberos::Krb5::Keytab class.static VALUE rkrb5_princ_allocate(VALUE klass){  RUBY_KRB5_PRINC* ptr = malloc(sizeof(RUBY_KRB5_PRINC));  memset(ptr, 0, sizeof(RUBY_KRB5_PRINC));  return Data_Wrap_Struct(klass, 0, rkrb5_princ_free, ptr);}

VALUE frostbitten_message_allocate (VALUE klass) {	fb_message *msg = ruby_xmalloc(sizeof(fb_message));	return Data_Wrap_Struct(klass, frostbitten_message_mark, frostbitten_message_deallocate, msg);}

static VALUE t_init(VALUE self) {  Clist *st = clist_new();  VALUE stv = Data_Wrap_Struct(cArrayList, 0, free_clist, st);  rb_iv_set(self, "@clist", stv);  return self;}