int ffindex_sort_index(char *index_filename, FILE *index_file) {
int ret = FAILURE;
rewind(index_file);
ffindex_index_t* index = ffindex_index_parse(index_file, 0);
if(index == NULL)
{
return FAILURE;
}
if(index->n_entries != 0) {
ffindex_sort_index_file(index);
if (ftruncate(fileno(index_file), 0) == 0) {
if (ffindex_write(index, index_file) == FFINDEX_OK) {
ret = SUCCESS;
}
}
}
ffindex_index_free(index);
return ret;
}
int main(int argn, char **argv)
{
int sort = 0, unlink = 0, version = 0;
int err = EXIT_SUCCESS;
char* list_filenames[MAX_FILENAME_LIST_FILES];
size_t list_filenames_index = 0;
static struct option long_options[] =
{
{ "file", required_argument, NULL, 'f' },
{ "sort", no_argument, NULL, 's' },
{ "unlink", no_argument, NULL, 'u' },
{ "version", no_argument, NULL, 'v' },
{ NULL, 0, NULL, 0 }
};
int opt;
while (1)
{
int option_index = 0;
opt = getopt_long(argn, argv, "suvf:", long_options, &option_index);
if (opt == -1)
break;
switch (opt)
{
case 'f':
list_filenames[list_filenames_index++] = optarg;
break;
case 's':
sort = 1;
break;
case 'u':
unlink = 1;
break;
case 'v':
version = 1;
break;
default:
usage(argv[0]);
return EXIT_FAILURE;
}
}
if(version == 1)
{
/* Don't you dare running it on a platform where byte != 8 bits */
printf("%s version %.2f, off_t = %zd bits\n", argv[0], FFINDEX_VERSION, sizeof(off_t) * 8);
return EXIT_SUCCESS;
}
if(optind >= argn)
{
usage(argv[0]);
return EXIT_FAILURE;
}
char *index_filename = argv[optind++];
FILE *index_file;
index_file = fopen(index_filename, "r+");
if(index_file == NULL) { perror(index_filename); return EXIT_FAILURE; }
size_t entries = ffcount_lines(index_filename);
ffindex_index_t* index = ffindex_index_parse(index_file, entries);
if(index == NULL) { perror("ffindex_index_parse failed"); return (EXIT_FAILURE); }
fclose(index_file);
/* Unlink entries */
if(unlink)
{
/* For each list_file unlink all entries */
for(int i = 0; i < list_filenames_index; i++) {
printf("Unlinking entries from '%s'\n", list_filenames[i]);
FILE *list_file = fopen(list_filenames[i], "r");
if (list_file == NULL) {
perror(list_filenames[i]);
return EXIT_FAILURE;
}
/* unlink entries in file, one per line */
char path[PATH_MAX];
while(fgets(path, PATH_MAX, list_file) != NULL) {
index = ffindex_unlink(index, ffnchomp(path, strlen(path)));
}
}
/* unlink entries specified by args */
for(int i = optind; i < argn; i++) {
index = ffindex_unlink(index, argv[i]);
}
/* Sort the index entries and write back */
if(sort) {
ffindex_sort_index_file(index);
index_file = fopen(index_filename, "w");
if(index_file == NULL) {
perror(index_filename);
return EXIT_FAILURE;
}
err += ffindex_write(index, index_file);
}
}
/* Write index back */
index_file = fopen(index_filename, "w");
if(index_file == NULL) {
perror(index_filename);
return EXIT_FAILURE;
}
err += ffindex_write(index, index_file);
return err;
}
int main(int argn, char **argv)
{
int sort = 0, version = 0;
int opt, err = EXIT_SUCCESS;
int user_selected_field_index = 1;
while ((opt = getopt(argn, argv, "svk:")) != -1)
{
switch (opt)
{
case 'k':
user_selected_field_index = optind;
break;
case 's':
sort = 1;
break;
case 'v':
version = 1;
break;
default:
usage(argv[0]);
return EXIT_FAILURE;
}
}
if(version == 1)
{
/* Don't you dare running it on a platform where byte != 8 bits */
printf("%s version %.2f, off_t = %zd bits\n", argv[0], FFINDEX_VERSION, sizeof(off_t) * 8);
return EXIT_SUCCESS;
}
if(argn - optind < 3)
{
usage(argv[0]);
return EXIT_FAILURE;
}
char *data_filename = argv[optind++];
char *index_filename = argv[optind++];
char *tsv_filename = argv[optind++];
FILE *data_file, *index_file;
size_t offset = 0;
/* open ffindex */
err = ffindex_index_open(data_filename, index_filename, "w", &data_file, &index_file, &offset);
if(err != EXIT_SUCCESS)
return err;
FILE* tsv_file = fopen(tsv_filename, "r");
if(tsv_file == NULL) { perror(tsv_filename); return EXIT_FAILURE; }
size_t tsv_size;
char* tsv_data = ffindex_mmap_data(tsv_file, &tsv_size);
char* tsv_current = tsv_data;
char* tsv_part_begin = tsv_data;
char* tsv_last = tsv_data + tsv_size;
char field_current[FFINDEX_MAX_ENTRY_NAME_LENTH + 1]; // + seperator
size_t field_current_length = 0; // + seperator
char* tsv_selected_field_start = NULL;
size_t tsv_selected_field_length = 0;
tsv_current = tsv_scan_line_for_field(tsv_current, user_selected_field_index, &tsv_selected_field_start, &tsv_selected_field_length);
strncpy(field_current, tsv_selected_field_start, tsv_selected_field_length); //XXX
field_current_length = tsv_selected_field_length;
field_current[field_current_length] = '\0';
while(tsv_current < tsv_last)
{
char* tsv_next;
tsv_next = tsv_scan_line_for_field(tsv_current, user_selected_field_index, &tsv_selected_field_start, &tsv_selected_field_length);
if((tsv_selected_field_length != field_current_length ||
strncmp(field_current, tsv_selected_field_start, tsv_selected_field_length) != 0)) // XXX got a new field value
{
ffindex_insert_memory(data_file, index_file, &offset, tsv_part_begin, tsv_current - tsv_part_begin, field_current);
strncpy(field_current, tsv_selected_field_start, tsv_selected_field_length); //XXX
field_current_length = tsv_selected_field_length;
field_current[field_current_length] = '\0';
tsv_part_begin = tsv_current;
}
tsv_current = tsv_next;
}
ffindex_insert_memory(data_file, index_file, &offset, tsv_part_begin, tsv_current - tsv_part_begin, field_current);
strncpy(field_current, tsv_selected_field_start, tsv_selected_field_length); //XXX
field_current_length = tsv_selected_field_length;
field_current[field_current_length] = '\0';
fclose(data_file);
/* Sort the index entries and write back */
if(sort)
{
rewind(index_file);
ffindex_index_t* index = ffindex_index_parse(index_file, 0);
if(index == NULL)
{
perror("ffindex_index_parse failed");
exit(EXIT_FAILURE);
}
fclose(index_file);
ffindex_sort_index_file(index);
index_file = fopen(index_filename, "w");
if(index_file == NULL) { perror(index_filename); return EXIT_FAILURE; }
err += ffindex_write(index, index_file);
}
return err;
}
int main(int argn, char **argv)
{
int sort = 0, version = 0;
int opt, err = EXIT_SUCCESS;
while ((opt = getopt(argn, argv, "sv")) != -1)
{
switch (opt)
{
case 's':
sort = 1;
break;
case 'v':
version = 1;
break;
default:
usage(argv[0]);
return EXIT_FAILURE;
}
}
if(version == 1)
{
/* Don't you dare running it on a platform where byte != 8 bits */
printf("%s version %.2f, off_t = %zd bits\n", argv[0], FFINDEX_VERSION, sizeof(off_t) * 8);
return EXIT_SUCCESS;
}
if(argn - optind < 3)
{
usage(argv[0]);
return EXIT_FAILURE;
}
char *data_filename = argv[optind++];
char *index_filename = argv[optind++];
char *fasta_filename = argv[optind++];
FILE *data_file, *index_file, *fasta_file;
struct stat st;
if(stat(data_filename, &st) == 0) { errno = EEXIST; perror(data_filename); return EXIT_FAILURE; }
data_file = fopen(data_filename, "w");
if( data_file == NULL) { perror(data_filename); return EXIT_FAILURE; }
if(stat(index_filename, &st) == 0) { errno = EEXIST; perror(index_filename); return EXIT_FAILURE; }
index_file = fopen(index_filename, "w+");
if(index_file == NULL) { perror(index_filename); return EXIT_FAILURE; }
fasta_file = fopen(fasta_filename, "r");
if(fasta_file == NULL) { perror(fasta_filename); return EXIT_FAILURE; }
size_t fasta_size;
char *fasta_data = ffindex_mmap_data(fasta_file, &fasta_size);
size_t offset = 0;
size_t from_length = 0;
char name[FFINDEX_MAX_ENTRY_NAME_LENTH];
int seq_id = 1;
for(size_t fasta_offset = 1; fasta_offset < fasta_size; fasta_offset++) // position after first ">"
{
from_length = 1;
while(fasta_offset < fasta_size && !(*(fasta_data + fasta_offset) == '>' && *(fasta_data + fasta_offset - 1) == '\n'))
{
fasta_offset++;
from_length++;
}
sprintf(name, "%d", seq_id++);
ffindex_insert_memory(data_file, index_file, &offset, fasta_data + (fasta_offset - from_length), from_length, name);
}
fclose(data_file);
/* Sort the index entries and write back */
if(sort)
{
rewind(index_file);
ffindex_index_t* index = ffindex_index_parse(index_file, 0);
if(index == NULL)
{
perror("ffindex_index_parse failed");
exit(EXIT_FAILURE);
}
fclose(index_file);
ffindex_sort_index_file(index);
index_file = fopen(index_filename, "w");
if(index_file == NULL) { perror(index_filename); return EXIT_FAILURE; }
err += ffindex_write(index, index_file);
}
return err;
}
int main(int argn, char **argv)
{
int sort = 0, unlink = 0, version = 0, use_tree = 1;
int opt, err = EXIT_SUCCESS;
char* list_filenames[MAX_FILENAME_LIST_FILES];
size_t list_filenames_index = 0;
while ((opt = getopt(argn, argv, "stuvf:")) != -1)
{
switch (opt)
{
case 'f':
list_filenames[list_filenames_index++] = optarg;
break;
case 's':
sort = 1;
break;
case 't':
use_tree = 1;
break;
case 'u':
unlink = 1;
break;
case 'v':
version = 1;
break;
default:
fprintf(stderr, "Option %c not recognized\n", opt);
usage(argv[0]);
return EXIT_FAILURE;
}
}
if(version == 1)
{
/* Don't you dare running it on a platform where byte != 8 bits */
printf("%s version %.2f, off_t = %zd bits\n", argv[0], FFINDEX_VERSION, sizeof(off_t) * 8);
return EXIT_SUCCESS;
}
if(optind >= argn)
{
usage(argv[0]);
return EXIT_FAILURE;
}
char *index_filename = argv[optind++];
FILE *index_file;
index_file = fopen(index_filename, "r+");
if(index_file == NULL) { perror(index_filename); return EXIT_FAILURE; }
ffindex_index_t* index = ffindex_index_parse(index_file, 0);
if(index == NULL) { perror("ffindex_index_parse failed"); return (EXIT_FAILURE); }
fclose(index_file);
/* Unlink entries */
if(unlink)
{
if(use_tree)
{
/* Build tree */
index = ffindex_index_as_tree(index);
/* For each list_file unlink all entries */
if(list_filenames_index > 0)
for(int i = 0; i < list_filenames_index; i++)
{
printf("Unlinking entries from '%s'\n", list_filenames[i]);
FILE *list_file = fopen(list_filenames[i], "r");
if( list_file == NULL) { perror(list_filenames[i]); return EXIT_FAILURE; }
/* unlink entries in file, one per line */
char path[PATH_MAX];
while(fgets(path, PATH_MAX, list_file) != NULL)
index = ffindex_unlink(index, ffnchomp(path, strlen(path)));
}
/* unlink entries specified by args */
for(int i = optind; i < argn; i++)
index = ffindex_unlink(index, argv[i]);
}
else
{
char** sorted_names_to_unlink = malloc(FFINDEX_MAX_INDEX_ENTRIES_DEFAULT * sizeof(char *));
if(sorted_names_to_unlink == NULL)
fferror_print(__FILE__, __LINE__, __func__, "malloc failed");
/* For each list_file unlink all entries */
if(list_filenames_index > 0)
for(int i = 0; i < list_filenames_index; i++)
{
printf("Unlinking entries from '%s'\n", list_filenames[i]);
FILE *list_file = fopen(list_filenames[i], "r");
if( list_file == NULL) { perror(list_filenames[i]); return EXIT_FAILURE; }
/* unlink entries in file, one per line */
char path[PATH_MAX];
while(fgets(path, PATH_MAX, list_file) != NULL)
sorted_names_to_unlink[i++] = ffnchomp(strdup(path), strlen(path));
ffindex_unlink_entries(index, sorted_names_to_unlink, i);
}
/* unlink entries specified by args */
int y = 0;
for(int i = optind; i < argn; i++, y++)
sorted_names_to_unlink[y] = argv[i];
ffindex_unlink_entries(index, sorted_names_to_unlink, y);
/* Sort the index entries and write back */
if(sort)
{
ffindex_sort_index_file(index);
index_file = fopen(index_filename, "w");
if(index_file == NULL) { perror(index_filename); return EXIT_FAILURE; }
err += ffindex_write(index, index_file);
}
}
}
/* Write index back */
index_file = fopen(index_filename, "w");
if(index_file == NULL) { perror(index_filename); return EXIT_FAILURE; }
err += ffindex_write(index, index_file);
return err;
}
