inline void SequentialHybridStrategy::initialize_iterator(int job_index)
{
if (seqCount) { // else default initialization is used
VariablesArray partial_param_sets;
extract_parameter_sets(job_index, partial_param_sets);
initialize_iterator(partial_param_sets);
}
}
inline void SequentialHybridStrategy::
unpack_parameters_buffer(MPIUnpackBuffer& recv_buffer)
{
if (seqCount) { // else default initialization is used
VariablesArray param_sets;
recv_buffer >> param_sets;
initialize_iterator(param_sets);
}
}
iterator_state* iterate(parameter_struct* parameters) {
if (parameters == 0 ||
parameters->callback == 0 ||
parameters->strings == 0)
return 0;
iterator_state* state;
switch (parameters->iterate_type) {
case MUM: //do the same as for mem
case MEM:
//initialize iterator state for using double iterate
state = initialize_iterator(parameters->strings, 2);
state->threshold = parameters->threshold;
/*parameters->ret_data = */double_iterate(state, parameters->callback, parameters->ret_data);
//free all resources
/*free_wavelet_tree(&state->bwts[0]);
free_wavelet_tree(&state->bwts[1]);
free_wavelet_tree(&state->reverse_bwts[0]);
free_wavelet_tree(&state->reverse_bwts[1]);
free_bit_vector(&state->runs_vectors[0]);
free_bit_vector(&state->runs_vectors[1]);
free_stack(&state->stacks[0]);
free_stack(&state->stacks[1]);
free(state->normals);
free(state->reverses);
free(state->current);
free(state->prev);
free(state->alpha_datas[0]->alphabet);
free(state->alpha_datas[1]->alphabet);
free(state->alpha_datas[0]);
free(state->alpha_datas[1]);
free(state->c_arrays[0]);
free(state->c_arrays[1]);
free(state->c_arrays);
free(state->common_alphabets[0]);
free(state->common_alphabets);*/
break;
case DOT_TREE: //do the same as for max repeats
case MAX_REPEATS: //do the same as default
default:
//initialize iterator state for using single iterate
state = initialize_iterator(parameters->strings, 1);
state->threshold = parameters->threshold;
/*parameters->ret_data = */single_iterate(state, parameters->callback, parameters->ret_data);
//free all resources
/*free_wavelet_tree(state->bwts);
free_wavelet_tree(state->reverse_bwts);
free_bit_vector(state->runs_vectors);
free_stack(state->stacks);
free(state->normals);
free(state->reverses);
free(state->current);
free(state->prev);
free(state->c_arrays);
free(state->alpha_datas->alphabet);
free(state->alpha_datas);*/
break;
}
//free(state);
return state;
}
void ui()
{
int choice, len = 0;
char* input = malloc(sizeof(char)*MAX_INPUT_STRING_LENGTH);
char* res = malloc(sizeof(char));
int* array = calloc(20, sizeof(int));
print_choices();
printf("Write the number of the operation you want to do:\n");
scanf("%d", &choice);
printf("Give the input string: (max size %d) ", MAX_INPUT_STRING_LENGTH);
print_instructions(choice);
scanf("%s", input);
wavelet_tree* root = create_wavelet_tree(input);
wavelet_tree* res_root;
if (choice == 1) {
char** strings = malloc(sizeof(char*));
strings[0] = input;
iterator_state* state = initialize_iterator(strings, 1);
single_iterate(state, &print_node, 0);
free_iterator_state(state);
free(strings);
} else if (choice == 2) {
res_root = s_to_bwt(input);
print_wavelet_tree(res_root);
} else if (choice == 3) {
res = bwt_to_s(root);
printf("%s\n", res);
} else if (choice == 4) {
res_root = reverse_bwt(input);
print_wavelet_tree(res_root);
} else if (choice == 5) {
array = create_c_array(root,0,0,0,0);
int len = strlen(determine_alphabet(input));
print_int_array(array, len);
} else if (choice == 6) {
bit_vector* runs = create_runs_vector(root,0);
print_runs_vector(runs, strlen(input)+1);
free_bit_vector(runs);
} else if (choice == 7) {
printf("Give the second input string: ");
char* input2 = malloc(sizeof(char)*MAX_INPUT_STRING_LENGTH);
scanf("%s", input2);
char** strings = malloc(2 * sizeof(char*));
strings[0] = input;
strings[1] = input2;
parameter_struct* params = initialize_for_mums(strings, 0);
iterator_state* state = iterate(params);
mum_results* results = (mum_results*) params->ret_data;
triplet* nodes = results->data;
print_mums(input, results, state);
mum_print_bit_vectors(input,input2, results, state);
free(strings);
free(results->data);
free_iterator_state(state);
} else if (choice == 8) {
printf("Not supported yet\n");
} else if (choice == 9) {
printf("%d\n", distinct_substrings(input));
} else if (choice == 10) {
parameter_struct* params = initialize_for_max_repeats(input, 0);
iterator_state* state = iterate(params);
max_repeat_results* results = (max_repeat_results*) params->ret_data;
//maximals_print_nodes(input);
print_maximal_repeat_substrings(input, results, state);
//compare_quick_sort()
} else if (choice == 11) {
printf("Give the second input string: ");
char* input2 = malloc(sizeof(char)*MAX_INPUT_STRING_LENGTH);
scanf("%s", input2);
char** strings = malloc(2 * sizeof(char*));
strings[0] = input;
strings[1] = input2;
parameter_struct* params = initialize_for_mems(strings, 0);
iterator_state* state = iterate(params);
mem_results* results = (mem_results*) params->ret_data;
triplet* nodes = results->data;
print_mems(input, results, state);
free(strings);
free(results->data);
free_iterator_state(state);
}else {
printf("Invalid choice\n");
}
}
