void insert_rec_adjust(int node_idx, long *parents, int parent_cnt, int *parent_is, int parent_i_cnt) { int i; node_t node; node.idx = node_idx; load_node(&node); if (node.rec_cnt <= ORDER_2) return; rec_t mid_rec = node.recs[ORDER]; node_t left; for (i=0;i<ORDER;i++) left.recs[i] = node.recs[i]; left.rec_cnt = ORDER; for (i=0;i<node.child_cnt/2;i++) left.childs[i] = node.childs[i]; left.child_cnt = node.child_cnt/2; add_node(&left); node_t right; for (i=ORDER+1;i<node.rec_cnt;i++) right.recs[i-(ORDER+1)] = node.recs[i]; right.rec_cnt = ORDER; for (i=node.child_cnt/2;i<node.child_cnt;i++) right.childs[i-(node.child_cnt/2)] = node.childs[i]; right.child_cnt = node.child_cnt/2; add_node(&right); node.childs[0] = left.idx; node.childs[1] = right.idx; node.child_cnt = 2; if (parent_cnt) { node_t parent; parent.idx = parents[0]; load_node(&parent); int parent_i = parent_is[0]; for (i=parent.rec_cnt-1;i>=parent_i;i--) parent.recs[i+1] = parent.recs[i]; parent.rec_cnt++; parent.recs[parent_i] = mid_rec; for (i=parent.child_cnt-1;i>=(parent_i+1);i--) parent.childs[i+1] = parent.childs[i]; parent.child_cnt++; parent.childs[parent_i] = left.idx; parent.childs[parent_i+1] = right.idx; save_node(&parent); insert_rec_adjust(parent.idx, parents+1, parent_cnt-1, parent_is+1, parent_i_cnt-1); } else { node.recs[0] = mid_rec; node.rec_cnt = 1; save_node(&node); } }
void save( IndexIterator first,IndexIterator last,Archive& ar, const unsigned int)const { /* calculate ordered positions */ alg.execute(first,last); /* Given a consecutive subsequence of displaced elements * x1,...,xn, the following information is serialized: * * p0,p1,...,pn,0 * * where pi is a pointer to xi and p0 is a pointer to the element * preceding x1. Crealy, from this information is possible to * restore the original order on loading time. If x1 is the first * element in the sequence, the following is serialized instead: * * p1,p1,...,pn,0 * * For each subsequence of n elements, n+2 pointers are serialized. * An optimization policy is applied: consider for instance the * sequence * * a,B,c,D * * where B and D are displaced, but c is in its correct position. * Applying the schema described above we would serialize 6 pointers: * * p(a),p(B),0 * p(c),p(D),0 * * but this can be reduced to 5 pointers by treating c as a displaced * element: * * p(a),p(B),p(c),p(D),0 */ std::size_t last_saved=3; /* distance to last pointer saved */ for(IndexIterator it=first,prev=first;it!=last;prev=it++,++last_saved){ if(!alg.is_ordered(get_node(it))){ if(last_saved>1)save_node(get_node(prev),ar); save_node(get_node(it),ar); last_saved=0; } else if(last_saved==2)save_node(null_node(),ar); } if(last_saved<=2)save_node(null_node(),ar); /* marks the end of the serialization info for [first,last) */ save_node(null_node(),ar); }
int main (void) { PageManager* pm = new_page_manager("."); printf("I Made my pm\n"); printf("My index path is: %s\n", pm->index_path); RawPage* new_page = new_data_page(pm); printf("new page fd is %d at memory addr %p\n", new_page->fd, new_page->page); // Save some strings PageRef* str_1 = save_string(new_page, "Hello There"); PageRef* str_2 = save_string(new_page, "I am a second string"); printf("Before unload page\n"); unload_page(new_page); printf("After unloda page\n"); // load some strings load_string(pm, str_1); load_string(pm, str_2); //make our tree page RawPage* t_page = new_tree_page(pm); TreeNode* test_node = malloc(sizeof(TreeNode)); memset(test_node, 0, sizeof(TreeNode)); test_node->size = 0; test_node->order = 2; test_node->num_leaves = 0; test_node->parent.page_type = 0xDE110; test_node->parent.page_num = 31337; test_node->parent.node_offset = 31337; PageRef* node1 = save_node(t_page, test_node); unload_page(t_page); load_node(pm, node1); }
void save_node(std::ofstream& out, QT_TRI_NODE* current_node) { current_node->get_data()->save(out); // save the children recursively for (int i=0; i<4; i++) if (current_node->get_child(i) != NULL) save_node(out, current_node->get_child(i)); }
error_flag save_map(map_s *map, char *file_name, node_s *default_values, int number_of_defaults) { FILE *map_file; bool overwrite; int i; if(map == NULL || default_values == NULL) return BAD_FUNCTION_ARGUMENT; map_file = fopen(file_name, "wx"); if(map_file == NULL) { overwrite = overwrite_file_message(file_name); if(overwrite == true) { map_file = fopen(file_name, "w"); if(map_file == NULL) return FILE_ERROR; } else return ABORTED_BY_USER; } YAML_START_OF_FILE(map_file); fprintf(map_file, "Name: %s\n" "Description: %s\n\n", map->name, map->description); fputs("Map settings:\n", map_file); fprintf(map_file, " min players: %d\n" " max players: %d\n" " modes:", map->settings.min_players, map->settings.max_players); YAML_print_inlined_list(map_file, map->modes, map->number_of_modes); fputs("\n", map_file); for(i = 0; i < map->number_of_nodes; i++) { save_node(map_file, map, &(map->nodes[i]), default_values, number_of_defaults); } YAML_END_OF_FILE(map_file); fclose(map_file); return SUCCESS; }
void tri_grid::save(std::string filename) { std::cout << "# Saving mesh" << std::endl; std::ofstream out; out.open(filename.c_str(), std::ios::out | std::ios::binary); if (!out) throw(std::string("Saving mesh. File could not be opened or written to: " + filename)); // write out the meta data write_meta_data(out, meta_data); // write out the point cloud point_cloud_instance.save(out); // write out number of triangle roots write_int(out, triangles.size()); // write out all the triangles for (unsigned int tri=0; tri<triangles.size(); tri++) save_node(out, triangles[tri]->get_root()); out.close(); }
int remove_rec_2(long node_idx, rec_t *rec, long *parents, int parent_cnt, int *parent_is, int parent_i_cnt) { int i, j; node_t node; node.idx = node_idx; load_node(&node); for (i=0;i<node.rec_cnt;i++) { int cmped = rec_cmp(&node.recs[i], rec); if (cmped > 0) { if (node.child_cnt) { parents[-1] = node.idx; parent_is[-1] = i; return remove_rec_2(node.childs[i], rec, parents-1, parent_cnt+1, parent_is-1, parent_i_cnt+1); } else { return -1; } } else if (cmped == 0) { if (!node.child_cnt) { for (j=i+1;j<node.rec_cnt;j++) node.recs[j-1] = node.recs[j]; node.rec_cnt--; save_node(&node); remove_rec_adjust(node.idx, parents, parent_cnt, parent_is, parent_i_cnt); return 0; } else { int prev_i = i+1; long prev_suc = node.idx; node_t suc; suc.idx = node.childs[prev_i]; load_node(&suc); int new_parent_cnt = 0; int new_parent_i_cnt = 0; parents[--new_parent_cnt] = prev_suc; parent_is[--new_parent_i_cnt] = prev_i; while (suc.child_cnt) { prev_suc = suc.idx; prev_i = 0; suc.idx = suc.childs[prev_i]; load_node(&suc); parents[--new_parent_cnt] = prev_suc; parent_is[--new_parent_i_cnt] = prev_i; } rec_t _rec = suc.recs[0]; node.recs[i] = _rec; save_node(&node); return remove_rec_2(suc.idx, &_rec, parents+new_parent_cnt, parent_cnt-new_parent_cnt, parent_is+new_parent_i_cnt, parent_i_cnt-new_parent_i_cnt); } } } if (node.child_cnt) { parents[-1] = node.idx; parent_is[-1] = node.child_cnt-1; return remove_rec_2(node.childs[node.child_cnt-1], rec, parents-1, parent_cnt+1, parent_is-1, parent_i_cnt+1); } else return -1; }
void remove_rec_adjust(long node_idx, long *parents, int parent_cnt, int *parent_is, int parent_i_cnt) { int i; node_t node; node.idx = node_idx; load_node(&node); node_t parent; parent.idx = parents[0]; load_node(&parent); int parent_i = parent_is[0]; if (!parent_cnt) { if (!node.rec_cnt && node.child_cnt) { root_idx = node.childs[0]; set_node_unoccupied(node.idx); } return; } if (node.rec_cnt >= ORDER) return; if (parent_i+1 < parent.child_cnt) { node_t parent_child; parent_child.idx = parent.childs[parent_i+1]; load_node(&parent_child); if (parent_child.rec_cnt > ORDER) { node.recs[node.rec_cnt++] = parent.recs[parent_i]; if (parent_child.child_cnt) { node.childs[node.child_cnt++] = parent_child.childs[0]; for (i=1;i<parent_child.child_cnt;i++) parent_child.childs[i-1] = parent_child.childs[i]; parent_child.child_cnt--; } parent.recs[parent_i] = parent_child.recs[0]; for (i=1;i<parent_child.rec_cnt;i++) parent_child.recs[i-1] = parent_child.recs[i]; parent_child.rec_cnt--; save_node(&node); save_node(&parent); save_node(&parent_child); return; } } if (parent_i-1 >= 0) { node_t parent_child; parent_child.idx = parent.childs[parent_i-1]; load_node(&parent_child); if (parent_child.rec_cnt > ORDER) { for (i=node.rec_cnt-1;i>=0;i--) node.recs[i+1] = node.recs[i]; node.rec_cnt++; node.recs[0] = parent.recs[parent_i-1]; if (parent_child.child_cnt) { for (i=node.child_cnt-1;i>=0;i--) node.childs[i+1] = node.childs[i]; node.child_cnt++; node.childs[0] = parent_child.childs[parent_child.child_cnt-1]; parent_child.child_cnt--; } parent.recs[parent_i-1] = parent_child.recs[parent_child.rec_cnt-1]; parent_child.rec_cnt--; save_node(&node); save_node(&parent); save_node(&parent_child); return; } } if (parent_i+1 < parent.child_cnt) { node_t parent_child; parent_child.idx = parent.childs[parent_i+1]; load_node(&parent_child); node.recs[node.rec_cnt++] = parent.recs[parent_i]; for (i=0;i<parent_child.rec_cnt;i++) node.recs[node.rec_cnt++] = parent_child.recs[i]; for (i=0;i<parent_child.child_cnt;i++) node.childs[node.child_cnt++] = parent_child.childs[i]; for (i=parent_i+1;i<parent.rec_cnt;i++) parent.recs[i-1] = parent.recs[i]; parent.rec_cnt--; set_node_unoccupied(parent.childs[parent_i+1]); for (i=parent_i+2;i<parent.child_cnt;i++) parent.childs[i-1] = parent.childs[i]; parent.child_cnt--; save_node(&node); save_node(&parent); remove_rec_adjust(parent.idx, parents+1, parent_cnt-1, parent_is+1, parent_i_cnt-1); return; } if (parent_i-1 >= 0) { node_t parent_child; parent_child.idx = parent.childs[parent_i-1]; load_node(&parent_child); for (i=0;i<node.rec_cnt;i++) node.recs[i+(parent_child.rec_cnt+1)] = node.recs[i]; node.rec_cnt += (parent_child.rec_cnt+1); for (i=0;i<parent_child.rec_cnt;i++) node.recs[i] = parent_child.recs[i]; node.recs[parent_child.rec_cnt] = parent.recs[parent_i-1]; for (i=0;i<node.child_cnt;i++) node.childs[i+parent_child.child_cnt] = node.childs[i]; node.child_cnt += parent_child.child_cnt; for (i=0;i<parent_child.child_cnt;i++) node.childs[i] = parent_child.childs[i]; for (i=parent_i;i<parent.rec_cnt;i++) parent.recs[i-1] = parent.recs[i]; parent.rec_cnt--; set_node_unoccupied(parent.childs[parent_i-1]); for (i=parent_i;i<parent.child_cnt;i++) parent.childs[i-1] = parent.childs[i]; parent.child_cnt--; save_node(&node); save_node(&parent); remove_rec_adjust(parent.idx, parents+1, parent_cnt-1, parent_is+1, parent_i_cnt-1); return; } }
FilerSave::~FilerSave() { save_page(true); m_valid = false; if (m_node_p) save_node(0); }