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);
}
