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

void ruby_write_node_bool_to_float(node_t*n, state_t*s){    strf(s, "(");    write_node(s, n->child[0]);    strf(s, " ? 1.0 : 0.0");    strf(s, ")");}

void c_write_node_sqr(node_t*n, state_t*s){    strf(s, "sqr");    if(n->child[0]->type!=&node_brackets) strf(s, "(");    write_node(s, n->child[0]);    if(n->child[0]->type!=&node_brackets) strf(s, ")");}

static voidwrite_pred(SerdWriter* writer, SerdStatementFlags flags, const SerdNode* pred){	write_node(writer, pred, NULL, NULL, FIELD_PREDICATE, flags);	write_sep(writer, SEP_P_O);	copy_node(&writer->context.predicate, pred);}

void FileAllocator::remove_node(FileOffset head_offset, list_node *head,                                FileOffset node_offset, const list_node *node){    list_node tmp;    FileOffset tmp_offset;    if (head->next == node_offset)    {   // first node; make head skip it        head->bytes -= node->bytes;        head->next = node->next;        if (head->next == 0) // list now empty?            head->prev = 0;        else        {   // correct 'prev' ptr of what's now the first node            read_node(head->next, &tmp);            tmp.prev = 0;            write_node(head->next, &tmp);        }        write_node(head_offset, head);    }    else    {   // locate a node that's not the first        tmp_offset = head->next;        read_node(tmp_offset, &tmp);        while (tmp.next != node_offset)        {            tmp_offset = tmp.next;            if (!tmp_offset)                throw GenericException(__FILE__, __LINE__,                                       "node not found");            read_node(tmp_offset, &tmp);        }        // tmp/tmp_offset == node before the one to be removed        tmp.next = node->next;        write_node(tmp_offset, &tmp);        if (node->next)        {   // adjust prev pointer of node->next            read_node(node->next, &tmp);            tmp.prev = tmp_offset;            write_node(node->next, &tmp);        }        head->bytes -= node->bytes;        if (head->prev == node_offset)            head->prev = node->prev;        write_node(head_offset, head);    }}

void ruby_write_node_sub(node_t*n, state_t*s){    int t;    for(t=0;t<n->num_children;t++) {        if(t && !node_has_minus_prefix(n->child[t])) strf(s, "-");        write_node(s, n->child[t]);    }}

bool FileAllocator::attach(FILE *f, FileOffset reserved_space, bool init){#ifdef DEBUG_FA    printf("FileAllocator::attach()/n");#endif    LOG_ASSERT(f != 0);    this->f = f;    this->reserved_space = reserved_space;    if (fseek(this->f, 0, SEEK_END))        throw GenericException(__FILE__, __LINE__, "fseek error");    file_size = ftell(this->f);    if (file_size < 0)        throw GenericException(__FILE__, __LINE__, "ftell error");    // File size should be    // 0 for new file or at least reserved_space + list headers    if (file_size == 0)    {        if (init == false)            throw GenericException(__FILE__, __LINE__,                                   "FileAllocator in read-only mode found empty file");        // create empty list headers        memset(&allocated_head, 0, list_node_size);        memset(&free_head, 0, list_node_size);        write_node(this->reserved_space, &allocated_head);        write_node(this->reserved_space+list_node_size, &free_head);        file_size = ftell(this->f);        FileOffset expected = reserved_space + 2*list_node_size;        if (file_size != expected)             throw GenericException(__FILE__, __LINE__,                                    "Initialization error: "                                    "Expected file size %ld, found %ld",                                    (long) expected, (long) file_size);        return true;     }    FileOffset expected = this->reserved_space + 2*list_node_size;    if (file_size < expected)        throw GenericException(__FILE__, __LINE__,                               "FileAllocator: Broken file header,"                               "expected at least %ld bytes",                               (long) expected);    // read existing list headers    read_node(this->reserved_space, &allocated_head);    read_node(this->reserved_space+list_node_size, &free_head);    return false; // Didn't initialize the file}

static voidwrite_nodes(FILE *fp, const NSegment *tree){   if (tree == NULL) return;   write_node(fp, tree);   write_nodes(fp, tree->left);   write_nodes(fp, tree->right);}

void ruby_write_node_block(node_t*n, state_t*s){    int t;    for(t=0;t<n->num_children;t++) {        if(t)            strf(s, "/n");        write_node(s, n->child[t]);    }}

static void ruby_write_node_arg_min_or_max(node_t*n, state_t*s, char*min_or_max){    strf(s, "([");    int t;    for(t=0;t<n->num_children;t++) {        if(t) strf(s, ",");        write_node(s, n->child[t]);    }    strf(s, "].each_with_index.map.%s)[1]", min_or_max);}

int ps3_repository_write_highmem_size(unsigned int region_index,	u64 highmem_size){	return write_node(		make_first_field("highmem", 0),		make_field("region", region_index),		make_field("size", 0),		0,		highmem_size, 0);}

bool MemoryDump::draw_tree(Node &node, std::ofstream &ofile, const cmd_opt &opt, std::set<uintptr_t> &declared_nodes, int level){    if (node.visited >= 0 && node.visited <= level) return true;    if (opt.critical_only && !node.critical) return true;    if (opt.depth > 0 && level >= opt.depth) return true;    node.visited = level;    std::vector<ChildNode*> edges;    for (auto &&c : node.children) {        if (c.node->subtree_size >= min_size            && (!opt.critical_only || c.node->critical)) {            edges.push_back(&c);        }    }        std::sort(edges.begin(), edges.end(),        [](const ChildNode *a, const ChildNode *b) {        return a->node->subtree_size > b->node->subtree_size;    }    );    if (opt.max_subnodes > 0 && edges.size() > opt.max_subnodes) { //too many nodes, only write nodes with big sizes;        edges.resize(opt.max_subnodes);    }    bool tail_written = false;    for (const auto & c : edges) {        if (!tail_written && declared_nodes.find(node.label) == declared_nodes.end()) {            write_node(node, ofile, opt);            declared_nodes.insert(node.label);            tail_written = true;        }        if (declared_nodes.find(c->node->label) == declared_nodes.end()) {            write_node(*c->node, ofile, opt);            declared_nodes.insert(c->node->label);        }        exporter->write_edge(node, *c->node, ofile, c->edge.str());        draw_tree(*c->node, ofile, opt, declared_nodes, level + 1);    }    return true;}

/* *  Tree walking with acending key order */void walk_tree(int fd_in, int fd_out, compact_header_t * tree){    if (tree->left != NULL) {        walk_tree(fd_in, fd_out, tree->left);    }    write_node(fd_in, fd_out, tree, io_buf, IO_BUFFER_SZ);    if (tree->right != NULL) {        walk_tree(fd_in, fd_out, tree->right);    }    free(tree);}

intset_t*set_new() {  intset_t *set;  node_t *min, *max;  if ((set = (intset_t *) malloc(sizeof (intset_t))) == NULL)     {      perror("malloc");      EXIT(1);    }  node_t** nodes = (node_t**) pgas_app_alloc_rr(2, sizeof(node_t));  min = nodes[0];  max = nodes[1];  write_node(max, VAL_MAX, 0, 0);  write_node(min, VAL_MIN, OF(max), 0);  set->head = min;  return set;}

void c_write_node_arg_min_i(node_t*n, state_t*s){    strf(s, "arg_min_i(%d, ", n->num_children);    int t;    for(t=0;t<n->num_children;t++) {        if(t)            strf(s, ", ");        strf(s, "(int)");        write_node(s, n->child[t]);    }    strf(s, ")");}

int ps3_repository_write_highmem_region_count(unsigned int region_count){	int result;	u64 v1 = (u64)region_count;	result = write_node(		make_first_field("highmem", 0),		make_field("region", 0),		make_field("count", 0),		0,		v1, 0);	return result;}

/** When this method is called, the writer must handle all nodes contained in the 	library nodes.	@return The writer should return true, if writing succeeded, false otherwise.*/bool DocumentImporter::writeLibraryNodes ( const COLLADAFW::LibraryNodes* libraryNodes ) {	if(mImportStage!=General)		return true;			Scene *sce = CTX_data_scene(mContext);	const COLLADAFW::NodePointerArray& nodes = libraryNodes->getNodes();	for (unsigned int i = 0; i < nodes.getCount(); i++) {		write_node(nodes[i], NULL, sce, NULL, true);	}	return true;}

/*========================================== * write_nodes -- Write NODEs to GEDCOM file *========================================*/voidwrite_nodes (INT levl,       /* level */             FILE *fp,       /* file */             XLAT ttm,   /* char map */             NODE node,      /* root */             BOOLEAN indent, /* indent? */             BOOLEAN kids,   /* output kids? */             BOOLEAN sibs)   /* output sibs? */{	if (!node) return;	write_node(levl, fp, ttm, node, indent);	if (kids)		write_nodes(levl+1, fp, ttm, nchild(node), indent, TRUE, TRUE);	if (sibs)		write_nodes(levl, fp, ttm, nsibling(node), indent, kids, TRUE);}

static voiddump_nodes (CTaskList  * self,	    FILE       * file,	    GtkTreeIter* iter){	GtkTreeIter  iter2;	gboolean     result;	for (result = gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (self), &iter2, iter, 0);	     result;	     result = gtk_tree_model_iter_next (GTK_TREE_MODEL (self), &iter2))	{		write_node (GTK_TREE_MODEL (self),			    &iter2,			    file);	}}

void c_write_node_block(node_t*n, state_t*s){    int t;    if(n->parent) {        strf(s, "{/n");        indent(s);    }    for(t=0;t<n->num_children;t++) {        if(t)            strf(s, "/n");        write_node(s, n->child[t]);        strf(s, ";");    }    if(n->parent) {        dedent(s);        strf(s, "/n}/n");    }}

static boolwrite_list_obj(SerdWriter*        writer,               SerdStatementFlags flags,               const SerdNode*    predicate,               const SerdNode*    object,               const SerdNode*    datatype,               const SerdNode*    lang){	if (!strcmp((const char*)object->buf, NS_RDF "nil")) {		--writer->indent;		write_sep(writer, SEP_LIST_END);		return true;	} else if (!strcmp((const char*)predicate->buf, NS_RDF "first")) {		write_sep(writer, SEP_LIST_SEP);		write_node(writer, object, datatype, lang, FIELD_OBJECT, flags);	}	return false;}

static int write_nodes(Agraph_t * g, GVJ_t * job, int top, int has_subgs, state_t* sp){    Agnode_t* n;    int not_first = 0;    n = agfstnode(g);    if (!n) {	if (has_subgs && top) {	    sp->Level--;	    gvputs(job, "/n");	    indent(job, sp->Level);	    gvputs(job, "]");	}	return 0;    }    gvputs(job, ",/n");    if (top) {	if (!has_subgs) {            indent(job, sp->Level++);            gvputs(job, "/"objects/": [/n");        }    }    else {        indent(job, sp->Level++);	gvputs(job, "/"nodes/": [/n");	indent(job, sp->Level);    }    for (; n; n = agnxtnode(g, n)) {	if (IS_CLUSTER(n)) continue;	if (not_first)             if (top)	        gvputs(job, ",/n");            else	        gvputs(job, ",");	else	    not_first = 1;	write_node (n, job, top, sp);    }    sp->Level--;    gvputs(job, "/n");    indent(job, sp->Level);    gvputs(job, "]");    return 1;}

void c_write_node_if(node_t*n, state_t*s){    if(!node_terminates(n) && node_has_consumer_parent(n)) {        strf(s, "(");        write_node(s, n->child[0]);        strf(s, ")?(");        write_node(s, n->child[1]);        strf(s, "):(");        write_node(s, n->child[2]);        strf(s, ")");    } else {        strf(s, "if(");        write_node(s, n->child[0]);        strf(s, ")/n");        indent(s);write_node(s, n->child[1]);        if(!node_is_missing(n->child[2])) {            strf(s, ";");dedent(s);            strf(s, "/nelse/n");            indent(s);write_node(s, n->child[2]);        }        dedent(s);    }}

void ruby_write_node_if(node_t*n, state_t*s){    if(!node_terminates(n) && node_has_consumer_parent(n)) {        strf(s, "if ");        write_node(s, n->child[0]);        strf(s, " then ");        indent(s);write_node(s, n->child[1]);dedent(s);        if(!node_is_missing(n->child[2])) {            strf(s, " else ");            indent(s);write_node(s, n->child[2]);dedent(s);        }        strf(s, " end");    } else {        strf(s, "if ");        write_node(s, n->child[0]);        strf(s, " then/n");        indent(s);write_node(s, n->child[1]);dedent(s);        if(!node_is_missing(n->child[2])) {            strf(s, "/nelse/n");            indent(s);write_node(s, n->child[2]);dedent(s);        }        strf(s, "/nend");    }}

voidmexFunction(int nlhs, mxArray *plhs[],            int nrhs, const mxArray *prhs[]){   FILE *fob;   mxArray *internal;   element_t *pe;   double *pd;   int compound;   double uu_to_dbu;   /* check argument number */   if (nrhs != 4) {      mexErrMsgTxt("gds_write_element :  4 input arguments expected.");   }      /* get file handle argument */   fob = get_file_ptr((mxArray *)prhs[0]);   /* get unit conversion factor user units --> database units */   pd = (double *)mxGetData(prhs[2]);   uu_to_dbu = pd[0];   /* decide what to do */   if ( !get_field_ptr((mxArray *)prhs[1], "internal", &internal) )      mexErrMsgTxt("gds_write_element :  missing internal data field.");   pe = (element_t *)mxGetData(internal);   switch (pe->kind) {           case GDS_BOUNDARY:	 pd = (double *)mxGetData(prhs[3]); /* compound */	 compound = (int)pd[0];	 if ( compound )	    write_compound_boundary(fob, (mxArray *)prhs[1], uu_to_dbu);	 else	    write_boundary(fob, (mxArray *)prhs[1], uu_to_dbu);	 break;      case GDS_PATH:	 pd = (double *)mxGetData(prhs[3]); /* compound */	 compound = (int)pd[0];	 if ( compound )	    write_compound_path(fob, (mxArray *)prhs[1], uu_to_dbu);	 else	    write_path(fob, (mxArray *)prhs[1], uu_to_dbu);	 break;      case GDS_SREF:	 pd = (double *)mxGetData(prhs[3]); /* compound */	 compound = (int)pd[0];	 if ( compound )	    write_compound_sref(fob, (mxArray *)prhs[1], uu_to_dbu);	 else	    write_sref(fob, (mxArray *)prhs[1], uu_to_dbu);	 break;      case GDS_AREF:	 write_aref(fob, (mxArray *)prhs[1], uu_to_dbu);	 break;      case GDS_TEXT:	 write_text(fob, (mxArray *)prhs[1], uu_to_dbu);	 break;      case GDS_NODE:	 write_node(fob, (mxArray *)prhs[1], uu_to_dbu);	 break;      case GDS_BOX:	 write_box(fob, (mxArray *)prhs[1], uu_to_dbu);	 break;      default:	 mexErrMsgTxt("gds_write_element :  unknown element type.");   }}

//.........这里部分代码省略.........		}		free(strmatched);		free(str);		free(devstr);		unlock_node(wpid, FALSE, OFS_LOCKSTATUS_OK);		nfree(minf->dinf, dir_base_node);		return build_response_msg(thread->command.command, STDFSSERR_FILE_EXISTS);	}	if(!dir_exists)	{		// worng path		if(thread->lastdir_parsed_node != NULL)		{			nfree(minf->dinf, thread->lastdir_parsed_node);			thread->lastdir_parsed_node = NULL;		}		free(strmatched);		free(str);		free(devstr);		return build_response_msg(thread->command.command, STDFSSERR_FILE_DOESNOTEXIST);	}	dir_base_node = nref(minf->dinf, thread->lastdir_parsed_node->nodeid);		free(strmatched);	// Create device file	if(!create_file(dir_base_node, str, last_index_of(str, '/') + 1, OFS_DEVICE_FILE, TRUE, minf, wpid, thread->command.command, &nodeid, &device_base_node, OFS_NOFLAGS , &ret))	{		nfree(minf->dinf, thread->lastdir_parsed_node);		nfree(minf->dinf, dir_base_node);		thread->lastdir_parsed_node = NULL;				free(str);		free(devstr);		return ret;	}		nfree(minf->dinf, thread->lastdir_parsed_node);	nfree(minf->dinf, dir_base_node);	thread->lastdir_parsed_node = NULL;		// get a free block 	block = get_free_blocks(1, TRUE, minf, thread->command.command, wpid, &ret);	if(ret != NULL)	{		free(str);		free(devstr);		unlock_node(wpid, FALSE, OFS_LOCKSTATUS_OK);		nfree(minf->dinf, device_base_node);		return ret;	}	free(str);	clear_dir_buffer(thread->directory_buffer.buffer);	// write buffer	/*		int LOGIC DEVICE ID: internal ID on the service (4 BYTES)		int service name size; (4 BYTES)		char SERVICE NAME[]: name of the device driver (zero terminated devstring) 	*/	*((unsigned int *)thread->directory_buffer.buffer) = (unsigned int)mkdevice_cmd->logic_deviceid;	*((unsigned int *)(thread->directory_buffer.buffer + 4)) = len(devstr);	mem_copy((unsigned char *)devstr, ((unsigned char *)thread->directory_buffer.buffer + 8), len(devstr) + 1);	free(devstr);	write_buffer((char *)thread->directory_buffer.buffer, OFS_DIR_BUFFERSIZE, *block, thread->command.command, wpid, minf, &ret);	if(ret != NULL)	{		free_block(TRUE, TRUE, *block, minf, thread->command.command, wpid, &ret);		free(block);		unlock_node(wpid, FALSE, OFS_LOCKSTATUS_OK);		nfree(minf->dinf, device_base_node);		return ret;	}	// update node	device_base_node->n.file_size = 8 + len(devstr) + 1;	device_base_node->n.blocks[0] = *block;	if(!write_node(device_base_node, minf, wpid, thread->command.command, &ret) || ret != NULL)	{		free_block(TRUE, TRUE, *block, minf, thread->command.command, wpid, &ret);		free(block);		unlock_node(wpid, FALSE, OFS_LOCKSTATUS_OK);		nfree(minf->dinf, device_base_node);		return ret;	}	nfree(minf->dinf, device_base_node);	// unlock device node	unlock_node(wpid, FALSE, OFS_LOCKSTATUS_OK);		return build_response_msg(thread->command.command, STDFSSERR_OK);}

int main(int argc, char **argv){    // time the program    struct timeval sysTimeStart, sysTimeEnd;    gettimeofday(&sysTimeStart, NULL);        mkdir("bplus", 0777);        int i;    // open file count information    file_count_t *fc = read_file_count();        // keep track of roots    bplus_roots_t bpr;        // users    {        printf("/n");        printf("Making user B+ tree with %d users/n", fc->users);                // time this section        struct timeval startSysTimeSub, endSysTimeSub;        gettimeofday(&startSysTimeSub, NULL);                // create root        int_node_t root;        root.next = -1;        root.previous = -1;        root.tableType = TABLE_TYPE_USER;        root.nodeType = NODE_TYPE_LEAF;        root.count = 0;        root.firstFile = -1;        write_node(0, &root);                int rootFileNum = 0;                for (i = 0; i < fc->users; i++)        {            user_t *user = read_user(i);            rootFileNum = insert_node(rootFileNum, TABLE_TYPE_USER, user->stateId, i);            free_user(user);        }                bpr.user = rootFileNum;                // end timing this section        gettimeofday(&endSysTimeSub, NULL);        float totalTime = (endSysTimeSub.tv_sec - startSysTimeSub.tv_sec)        + (endSysTimeSub.tv_usec - startSysTimeSub.tv_usec) / 1000000.0f;        printf("B+ tree creation time:  %f seconds/n", totalTime);    }        // cities    {        printf("/n");        printf("Making city B+ tree with %d cities/n", fc->cities);                // time this section        struct timeval startSysTimeSub, endSysTimeSub;        gettimeofday(&startSysTimeSub, NULL);                // create root        int_node_t root;        root.next = -1;        root.previous = -1;        root.tableType = TABLE_TYPE_CITY;        root.nodeType = NODE_TYPE_LEAF;        root.count = 0;        root.firstFile = -1;        write_node(0, &root);                int rootFileNum = 0;                for (i = 0; i < fc->cities; i++)        {            city_t *city = read_city(i);            rootFileNum = insert_node(rootFileNum, TABLE_TYPE_CITY, city->stateId, i);            free_city(city);        }                bpr.city = rootFileNum;                // end timing this section        gettimeofday(&endSysTimeSub, NULL);        float totalTime = (endSysTimeSub.tv_sec - startSysTimeSub.tv_sec)        + (endSysTimeSub.tv_usec - startSysTimeSub.tv_usec) / 1000000.0f;        printf("B+ tree creation time:  %f seconds/n", totalTime);    }        //states    {        printf("/n");        printf("Making state B+ tree with %d states/n", fc->states);                // time this section        struct timeval startSysTimeSub, endSysTimeSub;        gettimeofday(&startSysTimeSub, NULL);                // create root        int_node_t root;//.........这里部分代码省略.........

std::vector<Object *> *DocumentImporter::write_node(COLLADAFW::Node *node, COLLADAFW::Node *parent_node, Scene *sce, Object *par, bool is_library_node){	Object *ob = NULL;	bool is_joint = node->getType() == COLLADAFW::Node::JOINT;	bool read_transform = true;	std::string id   = node->getOriginalId();	std::string name = node->getName();	// if node has child nodes write them	COLLADAFW::NodePointerArray &child_nodes = node->getChildNodes();	std::vector<Object *> *objects_done = new std::vector<Object *>();	std::vector<Object *> *root_objects = new std::vector<Object *>();	fprintf(stderr,			"Writing node id='%s', name='%s'/n",			id.c_str(),			name.c_str());	if (is_joint) {		if (parent_node == NULL) {			// A Joint on root level is a skeleton without root node.			// Here we add the armature "on the fly":			par = bc_add_object(sce, OB_ARMATURE, std::string("Armature").c_str());			objects_done->push_back(par);			root_objects->push_back(par);			object_map.insert(std::pair<COLLADAFW::UniqueId, Object *>(node->getUniqueId(), par));			node_map[node->getUniqueId()] = node;		}		if (parent_node == NULL || parent_node->getType() != COLLADAFW::Node::JOINT) {			armature_importer.add_root_joint(node, par);		}		if (parent_node == NULL) {			// for skeletons without root node all has been done above.			// Skeletons with root node are handled further down.			goto finally;		}	}	else {		COLLADAFW::InstanceGeometryPointerArray &geom = node->getInstanceGeometries();		COLLADAFW::InstanceCameraPointerArray &camera = node->getInstanceCameras();		COLLADAFW::InstanceLightPointerArray &lamp = node->getInstanceLights();		COLLADAFW::InstanceControllerPointerArray &controller = node->getInstanceControllers();		COLLADAFW::InstanceNodePointerArray &inst_node = node->getInstanceNodes();		size_t geom_done = 0;		size_t camera_done = 0;		size_t lamp_done = 0;		size_t controller_done = 0;		size_t inst_done = 0;		// XXX linking object with the first <instance_geometry>, though a node may have more of them...		// maybe join multiple <instance_...> meshes into 1, and link object with it? not sure...		// <instance_geometry>		while (geom_done < geom.getCount()) {			ob = mesh_importer.create_mesh_object(node, geom[geom_done], false, uid_material_map,			                                      material_texture_mapping_map);			if (ob == NULL) {				report_unknown_reference(*node, "instance_mesh");			}			else {				objects_done->push_back(ob);				if (parent_node == NULL) {					root_objects->push_back(ob);				}			}			++geom_done;		}		while (camera_done < camera.getCount()) {			ob = create_camera_object(camera[camera_done], sce);			if (ob == NULL) {				report_unknown_reference(*node, "instance_camera");			}			else {				objects_done->push_back(ob);				if (parent_node == NULL) {					root_objects->push_back(ob);				}			}			++camera_done;		}		while (lamp_done < lamp.getCount()) {			ob = create_lamp_object(lamp[lamp_done], sce);			if (ob == NULL) {				report_unknown_reference(*node, "instance_lamp");			}			else {				objects_done->push_back(ob);				if (parent_node == NULL) {					root_objects->push_back(ob);				}			}			++lamp_done;		}		while (controller_done < controller.getCount()) {			COLLADAFW::InstanceGeometry *geom = (COLLADAFW::InstanceGeometry *)controller[controller_done];			ob = mesh_importer.create_mesh_object(node, geom, true, uid_material_map, material_texture_mapping_map);			if (ob == NULL) {				report_unknown_reference(*node, "instance_controller");			}//.........这里部分代码省略.........

void DocumentImporter::finish(){	if (mImportStage != General)		return;	Main *bmain = CTX_data_main(mContext);	// TODO: create a new scene except the selected <visual_scene> - use current blender scene for it	Scene *sce = CTX_data_scene(mContext);	unit_converter.calculate_scale(*sce);	std::vector<Object *> *objects_to_scale = new std::vector<Object *>();	/** TODO Break up and put into 2-pass parsing of DAE */	std::vector<const COLLADAFW::VisualScene *>::iterator it;	for (it = vscenes.begin(); it != vscenes.end(); it++) {		PointerRNA sceneptr, unit_settings;		PropertyRNA *system, *scale;				// for scene unit settings: system, scale_length		RNA_id_pointer_create(&sce->id, &sceneptr);		unit_settings = RNA_pointer_get(&sceneptr, "unit_settings");		system = RNA_struct_find_property(&unit_settings, "system");		scale = RNA_struct_find_property(&unit_settings, "scale_length");		if (this->import_settings->import_units) {						switch (unit_converter.isMetricSystem()) {				case UnitConverter::Metric:					RNA_property_enum_set(&unit_settings, system, USER_UNIT_METRIC);					break;				case UnitConverter::Imperial:					RNA_property_enum_set(&unit_settings, system, USER_UNIT_IMPERIAL);					break;				default:					RNA_property_enum_set(&unit_settings, system, USER_UNIT_NONE);					break;			}			float unit_factor = unit_converter.getLinearMeter();			RNA_property_float_set(&unit_settings, scale, unit_factor);			fprintf(stdout, "Collada: Adjusting Blender units to Importset units: %f./n", unit_factor);		}		// Write nodes to scene		const COLLADAFW::NodePointerArray& roots = (*it)->getRootNodes();		for (unsigned int i = 0; i < roots.getCount(); i++) {			std::vector<Object *> *objects_done = write_node(roots[i], NULL, sce, NULL, false);			objects_to_scale->insert(objects_to_scale->end(), objects_done->begin(), objects_done->end());			delete objects_done;		}		// update scene		DAG_relations_tag_update(bmain);		WM_event_add_notifier(mContext, NC_OBJECT | ND_TRANSFORM, NULL);	}	mesh_importer.optimize_material_assignements();	armature_importer.set_tags_map(this->uid_tags_map);	armature_importer.make_armatures(mContext);	armature_importer.make_shape_keys();	DAG_relations_tag_update(bmain);#if 0	armature_importer.fix_animation();#endif	for (std::vector<const COLLADAFW::VisualScene *>::iterator it = vscenes.begin(); it != vscenes.end(); it++) {		const COLLADAFW::NodePointerArray& roots = (*it)->getRootNodes();		for (unsigned int i = 0; i < roots.getCount(); i++) {			translate_anim_recursive(roots[i], NULL, NULL);		}	}	if (libnode_ob.size()) {		Scene *sce = CTX_data_scene(mContext);		fprintf(stderr, "got %d library nodes to free/n", (int)libnode_ob.size());		// free all library_nodes		std::vector<Object *>::iterator it;		for (it = libnode_ob.begin(); it != libnode_ob.end(); it++) {			Object *ob = *it;			Base *base = BKE_scene_base_find(sce, ob);			if (base) {				BLI_remlink(&sce->base, base);				BKE_libblock_free_us(G.main, base->object);				if (sce->basact == base)					sce->basact = NULL;				MEM_freeN(base);			}		}		libnode_ob.clear();		DAG_relations_tag_update(bmain);	}//.........这里部分代码省略.........

void DocumentImporter::write_node (COLLADAFW::Node *node, COLLADAFW::Node *parent_node, Scene *sce, Object *par, bool is_library_node){	Object *ob = NULL;	bool is_joint = node->getType() == COLLADAFW::Node::JOINT;	if (is_joint) {		if ( par ) {		Object * empty = par;		par = add_object(sce, OB_ARMATURE);		bc_set_parent(par,empty->parent, mContext);		//remove empty : todo		object_map[parent_node->getUniqueId()] = par;		}		armature_importer.add_joint(node, parent_node == NULL || parent_node->getType() != COLLADAFW::Node::JOINT, par, sce);	}	else {		COLLADAFW::InstanceGeometryPointerArray &geom = node->getInstanceGeometries();		COLLADAFW::InstanceCameraPointerArray &camera = node->getInstanceCameras();		COLLADAFW::InstanceLightPointerArray &lamp = node->getInstanceLights();		COLLADAFW::InstanceControllerPointerArray &controller = node->getInstanceControllers();		COLLADAFW::InstanceNodePointerArray &inst_node = node->getInstanceNodes();		size_t geom_done = 0;		size_t camera_done = 0;		size_t lamp_done = 0;		size_t controller_done = 0;		size_t inst_done = 0;		// XXX linking object with the first <instance_geometry>, though a node may have more of them...		// maybe join multiple <instance_...> meshes into 1, and link object with it? not sure...		// <instance_geometry>		while (geom_done < geom.getCount()) {			ob = mesh_importer.create_mesh_object(node, geom[geom_done], false, uid_material_map,												  material_texture_mapping_map);			++geom_done;		}		while (camera_done < camera.getCount()) {			ob = create_camera_object(camera[camera_done], sce);			++camera_done;		}		while (lamp_done < lamp.getCount()) {			ob = create_lamp_object(lamp[lamp_done], sce);			++lamp_done;		}		while (controller_done < controller.getCount()) {			COLLADAFW::InstanceGeometry *geom = (COLLADAFW::InstanceGeometry*)controller[controller_done];			ob = mesh_importer.create_mesh_object(node, geom, true, uid_material_map, material_texture_mapping_map);			++controller_done;		}		// XXX instance_node is not supported yet		while (inst_done < inst_node.getCount()) {			const COLLADAFW::UniqueId& node_id = inst_node[inst_done]->getInstanciatedObjectId();			if (object_map.find(node_id) == object_map.end()) {				fprintf(stderr, "Cannot find node to instanciate./n");				ob = NULL;			}			else {				Object *source_ob = object_map[node_id];				COLLADAFW::Node *source_node = node_map[node_id];				ob = create_instance_node(source_ob, source_node, node, sce, par, is_library_node);			}			++inst_done;		}		// if node is empty - create empty object		// XXX empty node may not mean it is empty object, not sure about this		if ( (geom_done + camera_done + lamp_done + controller_done + inst_done) < 1) {			ob = add_object(sce, OB_EMPTY);		}				// check if object is not NULL		if (!ob) return;				std::string nodename = node->getName().size() ? node->getName() : node->getOriginalId();		rename_id(&ob->id, (char*)nodename.c_str());		object_map[node->getUniqueId()] = ob;		node_map[node->getUniqueId()] = node;		if (is_library_node)			libnode_ob.push_back(ob);	}	anim_importer.read_node_transform(node, ob); // overwrites location set earlier	if (!is_joint) {		// if par was given make this object child of the previous 		if (par && ob)			bc_set_parent(ob, par, mContext);	}	// if node has child nodes write them	COLLADAFW::NodePointerArray &child_nodes = node->getChildNodes();	for (unsigned int i = 0; i < child_nodes.getCount(); i++) {			write_node(child_nodes[i], node, sce, ob, is_library_node);	}}