void phone_book_create(Phone_Book *pb, char *name, char *num) {
if (!is_name(name) || !is_num(num)) {
print_wrong_input_msg();
return;
}
phone_book_init_from_file(pb);
record_set(&pb->v[pb->used++], phone_book_find_free_id(pb), name, num);
phone_book_unload_to_file(pb);
}
struct cog *array_load(iterator iter,int len) {
int i=0;
record r = malloc(sizeof(struct record));
buffer out = buffer_alloc(len);
record buf = out->data;
for(i = 0; i < len ; i++) {
if(iter_has_next(iter)) {
iter_next(iter, r);
record_set(&(buf[i]), r->key, r->value);
}
}
free(r);
return make_array(0, len, out);
}
void phone_book_init_from_file(Phone_Book *pb) {
FILE *input = fopen(file_name, "r");
pb->n = INIT_NUM;
pb->used = 0;
pb->v = calloc(sizeof(Record), (size_t )pb->n);
for (; ;) {
int id;
if (fscanf(input, "%d", &id) != 1) {
break;
}
char *name = get_str(input);
char *num = get_str(input);
record_set(&pb->v[pb->used++], id, name, num);
free(name);
free(num);
if (pb->used == pb->n) {
phone_book_expand(pb);
}
}
fclose(input);
}
double_struct *merge_partitions(cog *c, long low, long high) {
list *list = create_list();
int has_merge_work;
gather_partitions(list, c);
struct cog *right_replacement = NULL;
struct cog *left_replacement = NULL;
struct list *list_iter;
struct iter_list *tail;
struct stack_triple *stack = create_stack();
struct iter_list *head_list = malloc(sizeof(struct iter_list));
tail = head_list;
list_iter = list;
iterator merge_iter;
cog *c1 = malloc(sizeof(struct cog));
while(list_has_next(list_iter)) {
list_iter = get_cog_from_list(list_iter, c1);
struct extracted_components *components = extract_partitions(c1, low, high);
if(components->iter != NULL) {
has_merge_work = 1;
tail = iter_list_add(tail, components->iter);
}
if(components->rhs != NULL) {
if(right_replacement == NULL) {
right_replacement = components->rhs;
} else {
right_replacement = make_concat(right_replacement, components->rhs);
}
}
if(components->lhs != NULL) {
if(left_replacement == NULL) {
left_replacement = components->lhs;
} else {
left_replacement = make_concat(left_replacement, components->lhs);
}
}
free(components);
}
cleanup_list(list);
free(c1);
if(has_merge_work != 0) {
double_struct *ret = create_double_struct();
merge_iter = iter_merge(head_list);
record r = malloc(sizeof(struct record));
while(1) {
int i;
buffer out = buffer_alloc(MERGE_BLOCK_SIZE);
record buf = out->data;
for(i = 0; i < MERGE_BLOCK_SIZE && iter_has_next(merge_iter); i++) {
iter_next(merge_iter, r);
record_set(&buf[i], r->key, r->value);
}
if(i == 0) {
break;
}
struct cog *buffer = make_sortedarray(0, i, out);
fold_append(&stack, buffer, cog_min(buffer));
if(i < MERGE_BLOCK_SIZE) {
break;
}
}
cog *root = fold(&stack);
if(root == NULL) {
root = make_btree(left_replacement, right_replacement, high);
} else {
ret->iter = scan(root, low, high);
if(left_replacement != NULL && cog_length(left_replacement) != 0) {
root = make_btree(left_replacement, root, cog_min(root));
}
if(right_replacement != NULL && cog_length(right_replacement) != 0) {
root = make_btree(root, right_replacement, cog_min(right_replacement));
}
}
free(r);
cleanup_stack(stack);
iter_list_cleanup(head_list);
iter_cleanup(merge_iter);
ret->cog = root;
return ret;
} else {
double_struct *ret;
ret = amerge(list->cog, low, high);
if(left_replacement != NULL) {
ret->cog = make_concat(ret->cog, left_replacement);
}
if(right_replacement != NULL) {
ret->cog = make_concat(ret->cog, right_replacement);
}
return ret;
}
}
