static void include_feature(GtDlist *trees, GtHashmap *target_to_elem,
GtFeatureNode *feature, GtStr *key)
{
gt_dlist_add(trees, feature);
gt_hashmap_add(target_to_elem, gt_cstr_dup(gt_str_get(key)),
gt_dlist_last(trees));
}
void gt_timer_show_progress_va(GtTimer *t, FILE *fp, const char *desc,
va_list ap)
{
#ifndef _WIN32
char buf[BUFSIZ];
struct timeval elapsed_tv, elapsed_user_tv, elapsed_sys_tv;
gt_assert(t && desc);
gettimeofday(&t->stop_tv, NULL);
gt_xgetrusage(RUSAGE_SELF, &t->stop_ru);
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->start_tv);
timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
&t->start_ru.ru_utime);
timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
&t->start_ru.ru_stime);
gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
&elapsed_sys_tv, t->statedesc, fp);
if (t->statedesc)
gt_free(t->statedesc);
(void) vsnprintf(buf, BUFSIZ, desc, ap);
t->statedesc = gt_cstr_dup(buf);
gettimeofday(&t->start_tv, NULL);
gt_xgetrusage(RUSAGE_SELF, &t->start_ru);
#else
/* XXX */
fprintf(stderr, "gt_timer_show_progress_va() not implemented\n");
exit(EXIT_FAILURE);
#endif
}
GtTimer* gt_timer_new_with_progress_description(const char* desc)
{
GtTimer *t = gt_timer_new();
t->statedesc = gt_cstr_dup(desc);
t->has_desc = true;
return t;
}
static int list_tools(GtR *gtr)
{
GtToolIterator *ti;
GtOptionParser *op;
const char *name;
char fulltoolname[BUFSIZ],
*utoolname;
GtTool *tool;
GtStr *prefix = gt_str_new();
gt_assert(gtr);
/* list 'gt' itself */
printf("\n"),
printf("- link:tools/gt.html[gt]\n");
op = gtr_option_parser_new(gtr);
printf(" %s\n", gt_option_parser_one_liner(op));
gt_option_parser_delete(op);
/* list all tools in 'gt' */
ti = gt_tool_iterator_new(gtr->tools);
gt_tool_iterator_set_prefix_target(ti, prefix, ' ');
while (gt_tool_iterator_next(ti, &name, &tool)) {
op = gt_tool_get_option_parser(tool);
(void) snprintf(fulltoolname, BUFSIZ, "gt%c%s%s", ' ',
gt_str_get(prefix), name);
utoolname = gt_cstr_dup(fulltoolname);
gt_cstr_rep(utoolname, ' ', '_');
printf("\n"),
printf("- link:tools/%s.html[%s]\n", utoolname, fulltoolname);
printf(" %s\n", gt_option_parser_one_liner(op));
gt_free(utoolname);
}
gt_tool_iterator_delete(ti);
gt_str_delete(prefix);
return EXIT_SUCCESS;
}
static int fill_mapping(GtSeqid2SeqnumMapping *mapping, GtBioseq *bioseq,
GtSeqCol *seqcol, GT_UNUSED GtError *err)
{
GtUword i, j, nof_sequences, nof_files;
int had_err = 0;
gt_error_check(err);
gt_assert(mapping && (bioseq || seqcol) && !(bioseq && seqcol));
if (bioseq) {
nof_files = 1;
} else {
gt_assert(seqcol);
nof_files = gt_seq_col_num_of_files(seqcol);
}
for (j = 0; !had_err && j < nof_files; j++) {
if (bioseq)
nof_sequences = gt_bioseq_number_of_sequences(bioseq);
else {
gt_assert(seqcol);
nof_sequences = gt_seq_col_num_of_seqs(seqcol, j);
}
for (i = 0; !had_err && i < nof_sequences; i++) {
char *desc;
if (bioseq)
desc = gt_cstr_dup(gt_bioseq_get_description(bioseq, i));
else
desc = gt_seq_col_get_description(seqcol, j, i);
had_err = handle_description(mapping, desc, i, j, err);
gt_free(desc);
}
}
return had_err;
}
static int create_manpage(const char *outdir, const char *toolname,
GtOptionParser *option_parser, GtError *err)
{
GtFile *outfile = NULL;
GtStr *man, *pathbuf;
char *utoolname;
int had_err = 0;
gt_error_check(err);
gt_assert(outdir && toolname && option_parser);
man = gt_str_new();
pathbuf = gt_str_new_cstr(outdir);
utoolname = gt_cstr_dup(toolname);
gt_cstr_rep(utoolname, ' ', '_');
if (!gt_file_exists(gt_str_get(pathbuf)))
gt_xmkdir(gt_str_get(pathbuf));
gt_str_append_char(pathbuf, GT_PATH_SEPARATOR);
gt_str_append_cstr(pathbuf, utoolname);
gt_str_append_cstr(pathbuf, ".mansrc");
gt_free(utoolname);
if (!(outfile = gt_file_new(gt_str_get(pathbuf), "w+", err)))
had_err = -1;
if (!had_err)
had_err = gt_option_parser_manpage(option_parser, toolname, man, err);
if (!had_err)
gt_file_xprintf(outfile, "%s", gt_str_get(man));
gt_file_delete(outfile);
gt_str_delete(pathbuf);
gt_str_delete(man);
return had_err;
}
static void proc_env_options(void)
{
int argc;
char *env_options, **argv;
GtSplitter *splitter;
GtError *err;
/* construct argument vector from $GT_ENV_OPTIONS */
env_options = getenv("GT_ENV_OPTIONS");
if (!env_options)
return;
env_options = gt_cstr_dup(env_options); /* make writeable copy */
splitter = gt_splitter_new();
gt_splitter_split(splitter, env_options, strlen(env_options), ' ');
argc = gt_splitter_size(splitter);
argv = gt_cstr_array_preprend((const char**) gt_splitter_get_tokens(splitter),
"env");
argc++;
/* parse options contained in $GT_ENV_OPTIONS */
err = gt_error_new();
switch (parse_env_options(argc, (const char**) argv, err)) {
case GT_OPTION_PARSER_OK: break;
case GT_OPTION_PARSER_ERROR:
fprintf(stderr, "error parsing $GT_ENV_OPTIONS: %s\n", gt_error_get(err));
gt_error_unset(err);
break;
case GT_OPTION_PARSER_REQUESTS_EXIT: break;
}
gt_error_delete(err);
gt_free(env_options);
gt_splitter_delete(splitter);
gt_cstr_array_delete(argv);
}
int gt_parse_description_range(const char *description, GtRange *range)
{
unsigned long i, desclen;
char *desc, *descptr;
gt_assert(description && range);
desc = gt_cstr_dup(description);
desclen = strlen(desc);
descptr = desc;
/* ignore terminal '\n' */
if (desclen && desc[desclen-1] == '\n') {
desc[desclen-1] = '\0';
desclen--;
}
/* ignore terminal '\r' */
if (desclen && desc[desclen-1] == '\r') {
desc[desclen-1] = '\0';
desclen--;
}
/* find ':' */
for (i = 0; i < desclen; i++) {
if (desc[i] == ':')
break;
}
if (i == desclen) {
/* no ':' found */
gt_free(descptr);
return -1;
}
desc += i + 1;
/* find '..' */
i = 0;
while (desc[i] != '\0') {
if (desc[i-1] == '.' && desc[i] == '.')
break;
i++;
}
if (desc[i] == '\0') {
/* no '..' found */
gt_free(descptr);
return -1;
}
/* parse range start */
gt_assert(desc[i-1] == '.' && desc[i] == '.');
desc[i-1] = '\0';
if (gt_parse_ulong(&range->start, desc)) {
/* parsing failed */
gt_free(descptr);
return -1;
}
/* parse range end */
desc += i + 1;
if (gt_parse_ulong(&range->end, desc)) {
/* parsing failed */
gt_free(descptr);
return -1;
}
gt_free(descptr);
return 0;
}
void gt_feature_info_add_pseudo_parent(GtFeatureInfo *fi, const char *id,
GtFeatureNode *pseudo_parent)
{
gt_assert(fi && id && pseudo_parent);
gt_assert(gt_feature_node_is_pseudo((GtFeatureNode*) pseudo_parent));
gt_hashmap_add(fi->id_to_pseudo_parent, gt_cstr_dup(id),
gt_genome_node_ref((GtGenomeNode*) pseudo_parent));
}
void agn_unit_test_result(AgnUnitTest *test, const char *label, bool success)
{
UnitTestResult result;
agn_assert(test);
result.label = gt_cstr_dup(label);
result.success = success;
gt_array_add(test->results, result);
}
static char* gt_bioseq_col_get_description(const GtSeqCol *sc,
GtUword filenum,
GtUword seqnum)
{
GtBioseqCol *bsc;
bsc = gt_bioseq_col_cast(sc);
gt_assert(bsc && filenum < bsc->num_of_seqfiles);
return gt_cstr_dup(gt_bioseq_get_description(bsc->bioseqs[filenum], seqnum));
}
GtFile* gt_file_open(GtFileMode file_mode, const char *path, const char *mode,
GtError *err)
{
GtFile *file;
gt_error_check(err);
gt_assert(mode);
file = gt_calloc(1, sizeof (GtFile));
file->mode = file_mode;
file->reference_count = 0;
if (path) {
switch (file_mode) {
case GT_FILE_MODE_UNCOMPRESSED:
file->fileptr.file = gt_fa_fopen(path, mode, err);
if (!file->fileptr.file) {
gt_file_delete_without_handle(file);
return NULL;
}
break;
case GT_FILE_MODE_GZIP:
file->fileptr.gzfile = gt_fa_gzopen(path, mode, err);
if (!file->fileptr.gzfile) {
gt_file_delete_without_handle(file);
return NULL;
}
break;
case GT_FILE_MODE_BZIP2:
file->fileptr.bzfile = gt_fa_bzopen(path, mode, err);
if (!file->fileptr.bzfile) {
gt_file_delete_without_handle(file);
return NULL;
}
file->orig_path = gt_cstr_dup(path);
file->orig_mode = gt_cstr_dup(path);
break;
default: gt_assert(0);
}
}
else {
gt_assert(file_mode == GT_FILE_MODE_UNCOMPRESSED);
file->fileptr.file = stdin;
file->is_stdin = true;
}
return file;
}
static int file_find_in_env_generic(GtStr *path, const char *file,
const char *env, FileExistsFunc file_exists,
GtError *err)
{
char *pathvariable, *pathcomponent = NULL;
GtSplitter *splitter = NULL;
GtUword i;
int had_err = 0;
gt_error_check(err);
gt_assert(file);
gt_assert(file_exists);
/* check if 'file' has dirname */
gt_file_dirname(path, file);
if (gt_str_length(path))
return had_err;
/* 'file' has no dirname -> scan $env */
pathvariable = getenv(env);
if (pathvariable != NULL)
pathvariable = gt_cstr_dup(pathvariable); /* make writeable copy */
else {
gt_error_set(err, "environment variable $%s is not defined", env);
had_err = -1;
}
if (!had_err) {
splitter = gt_splitter_new();
gt_splitter_split(splitter, pathvariable,
(GtUword) strlen(pathvariable), GT_PATH_VAR_SEPARATOR);
for (i = 0; i < gt_splitter_size(splitter); i++) {
pathcomponent = gt_splitter_get_token(splitter, i);
gt_str_reset(path);
gt_str_append_cstr(path, pathcomponent);
gt_str_append_char(path, GT_PATH_SEPARATOR);
gt_str_append_cstr(path, file);
if (file_exists(gt_str_get(path)))
break;
}
if (i < gt_splitter_size(splitter)) {
/* file found in path */
gt_str_reset(path);
gt_str_append_cstr(path, pathcomponent);
}
else {
/* file not found in path */
gt_str_reset(path);
}
}
/* free */
gt_free(pathvariable);
gt_splitter_delete(splitter);
return had_err;
}
AgnUnitTest *agn_unit_test_new(const char *label,
bool (*testfunc)(AgnUnitTest *))
{
AgnUnitTest *test = gt_malloc( sizeof(AgnUnitTest) );
test->label = gt_cstr_dup(label);
test->testfunc = testfunc;
test->results = gt_array_new( sizeof(UnitTestResult) );
test->passed = false;
return test;
}
GtNodeStream* gt_gtf_in_stream_new(const char *filename)
{
GtGTFInStream *gtf_in_stream;
GtNodeStream *ns = gt_node_stream_create(gt_gtf_in_stream_class(), false);
gtf_in_stream = gtf_in_stream_cast(ns);
gtf_in_stream->genome_node_buffer = gt_queue_new();
gtf_in_stream->type_checker = gt_type_checker_builtin_new();
gtf_in_stream->filename = filename ? gt_cstr_dup(filename) : NULL;
return ns;
}
//----------------------------------------------------------------------------//
// Method implementations
//----------------------------------------------------------------------------//
VangRelation *vang_relation_new(const char *id, const char *nodetype)
{
VangRelation *rel = gt_malloc( sizeof(VangRelation) );
rel->id = gt_cstr_dup(id);
rel->nodetype = gt_cstr_dup(nodetype);
// Apply default degree constraint: indegree == 1; see VangRelation.h for a
// more detailed explanation
rel->dc.context = DEGREE_IN;
rel->dc.operator = EQUALS;
rel->dc.degree = 1;
// Apply default key (Parent), spatial constraint (none), and note (undefined)
rel->key = gt_cstr_dup("Parent");
rel->spatial = SC_NONE;
rel->note = NULL;
return rel;
};
void gt_xrf_abbr_entry_add(GtXRFAbbrEntry *abbr_entry, const char *tag,
const char *value)
{
GtStr *s;
gt_assert(abbr_entry && tag && value);
if (!(s = gt_hashmap_get(abbr_entry->content, tag))) {
s = gt_str_new_cstr(value);
gt_hashmap_add(abbr_entry->content, gt_cstr_dup(tag), s);
}
}
void gt_seq_info_cache_add(GtSeqInfoCache *sic, const char *key,
const GtSeqInfo *si)
{
GtSeqInfo *si_dup;
gt_assert(sic && key && si);
gt_assert(!gt_seq_info_cache_get(sic, key));
si_dup = gt_malloc(sizeof *si_dup);
si_dup->filenum = si->filenum;
si_dup->seqnum = si->seqnum;
gt_hashmap_add(sic->cache, gt_cstr_dup(key), si_dup);
}
void gt_lua_export_metatable(lua_State *L, const char *metatable_desc)
{
char *dot, *mt;
gt_assert(L && metatable_desc);
mt = gt_cstr_dup(metatable_desc);
dot = strchr(mt, '.');
gt_assert(dot);
*dot = '_';
lua_setglobal(L, mt);
gt_free(mt);
}
static int extracttarget_from_seqfiles(const char *target,
GtStrArray *seqfiles,
GtError *err)
{
GtStr *unescaped_target;
char *escaped_target;
GtSplitter *splitter;
unsigned long i;
int had_err = 0;
gt_error_check(err);
gt_assert(target && seqfiles);
splitter = gt_splitter_new();
unescaped_target = gt_str_new();
escaped_target = gt_cstr_dup(target);
gt_splitter_split(splitter, escaped_target, strlen(escaped_target), ',');
for (i = 0; !had_err && i < gt_splitter_size(splitter); i++) {
GtSplitter *blank_splitter;
char *token = gt_splitter_get_token(splitter, i);
blank_splitter = gt_splitter_new();
gt_splitter_split(blank_splitter, token, strlen(token), ' ');
had_err = gt_gff3_unescape(unescaped_target,
gt_splitter_get_token(blank_splitter, 0),
strlen(gt_splitter_get_token(blank_splitter, 0)),
err);
if (!had_err) {
unsigned long j;
for (j = 0; j < gt_str_array_size(seqfiles); j++) {
unsigned long k;
GtBioseq *bioseq;
if (!(bioseq = gt_bioseq_new(gt_str_array_get(seqfiles, j), err))) {
had_err = -1;
break;
}
for (k = 0; k < gt_bioseq_number_of_sequences(bioseq); k++) {
TargetInfo target_info;
const char *desc = gt_bioseq_get_description(bioseq, k);
target_info.bioseq = bioseq;
target_info.seqnum = k;
gt_string_matching_bmh(desc, strlen(desc),
gt_str_get(unescaped_target),
gt_str_length(unescaped_target), show_target,
&target_info);
}
gt_bioseq_delete(bioseq);
}
}
gt_splitter_delete(blank_splitter);
}
gt_free(escaped_target);
gt_str_delete(unescaped_target);
gt_splitter_delete(splitter);
return had_err;
}
static int gt_regioncov_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
GT_UNUSED GtError *err)
{
GtRegionCovVisitor *regioncov_visitor;
GtArray *rangelist;
gt_error_check(err);
regioncov_visitor = gt_regioncov_visitor_cast(nv);
rangelist = gt_array_new(sizeof (GtRange));
gt_hashmap_add(regioncov_visitor->region2rangelist,
gt_cstr_dup(gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*)
rn))),
rangelist);
return 0;
}
static int hmmsearch_call_fine_search(GtStr *table_filename,
char *fine_fasta_filename,
char *hmmsearch_path,
char *hmm_filename,
GtLogger *logger,
GtError *err) {
int had_err = 0;
GtSafePipe *pipe = NULL;
char **hmmargs = NULL,
*hmmenv[] = { NULL };
size_t hmmargc = (size_t) 4;
unsigned int hmmidx = 0;
if (table_filename != NULL) {
hmmargc += (size_t) 2;
}
hmmargs = gt_calloc(hmmargc, sizeof (*hmmargs));
hmmargs[hmmidx++] = hmmsearch_path;
if (table_filename != NULL) {
hmmargs[hmmidx++] = gt_cstr_dup("--tblout");
hmmargs[hmmidx++] = gt_str_get(table_filename);
}
hmmargs[hmmidx++] = hmm_filename;
hmmargs[hmmidx++] = fine_fasta_filename;
gt_assert(hmmargs[hmmidx] == NULL);
gt_logger_log(logger, "calling: %s", hmmsearch_path);
pipe = gt_safe_popen(hmmsearch_path, hmmargs, hmmenv, err);
if (table_filename != NULL)
gt_free(hmmargs[1]);
gt_free(hmmargs);
if (pipe == NULL)
had_err = -1;
if (!had_err) {
GtStr *line = gt_str_new();
gt_assert(pipe != NULL); /* shut up splint */
while (gt_str_read_next_line(line, pipe->read_fd) == 0) {
printf("%s\n", gt_str_get(line));
gt_str_reset(line);
}
gt_str_delete(line);
(void) gt_safe_pclose(pipe);
}
return had_err;
}
GtSeqid2SeqnumMapping* gt_seqid2seqnum_mapping_new_bioseq(GtBioseq *bioseq,
GtError *err)
{
GtSeqid2SeqnumMapping *mapping;
gt_error_check(err);
gt_assert(bioseq);
mapping = gt_malloc(sizeof *mapping);
mapping->filename = gt_cstr_dup(gt_bioseq_filename(bioseq));
mapping->map = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) seqid_info_delete);
if (fill_mapping(mapping, bioseq, NULL, err)) {
gt_seqid2seqnum_mapping_delete(mapping);
return NULL;
}
mapping->cached_seqid = NULL;
return mapping;
}
static int layout_tracks(void *key, void *value, void *data,
GT_UNUSED GtError *err)
{
unsigned long i, max;
GtTrack *track;
GtLayoutTraverseInfo *lti = (GtLayoutTraverseInfo*) data;
GtArray *list = (GtArray*) value;
GtStr *gt_track_key;
const char *type = key;
GtBlock *block;
bool split;
double tmp;
gt_assert(type && list);
/* to get a deterministic layout, we sort the GtBlocks for each type */
gt_array_sort_stable(list, blocklist_block_compare);
block = *(GtBlock**) gt_array_get(list, 0);
gt_track_key = gt_str_new_cstr((char*) key);
if (!gt_style_get_bool(lti->layout->style, "format", "split_lines", &split,
NULL))
split = true;
if (split)
if (!gt_style_get_bool(lti->layout->style, type, "split_lines", &split,
NULL))
split = true;
if (gt_style_get_num(lti->layout->style, type, "max_num_lines", &tmp, NULL))
max = tmp;
else
max = 50;
track = gt_track_new(gt_track_key, max, split,
gt_line_breaker_captions_new(lti->layout,
lti->layout->width,
lti->layout->style));
lti->layout->nof_tracks++;
for (i = 0; i < gt_array_size(list); i++) {
block = *(GtBlock**) gt_array_get(list, i);
gt_track_insert_block(track, block);
}
gt_hashmap_add(lti->layout->tracks, gt_cstr_dup(gt_str_get(gt_track_key)),
track);
gt_str_delete(gt_track_key);
return 0;
}
static int handle_description(GtSeqid2SeqnumMapping *mapping, const char *desc,
GtUword seqnum, GtUword filenum,
GtError *err)
{
GtRange descrange;
GtUword j;
int had_err = 0;
SeqidInfo *seqid_info;
if (gt_parse_description_range(desc, &descrange)) {
/* no offset could be parsed -> store description as sequence id */
descrange.start = 1;
descrange.end = GT_UNDEF_UWORD;
if ((seqid_info = gt_hashmap_get(mapping->map, desc))) {
had_err = seqid_info_add(seqid_info, seqnum, filenum,
&descrange, mapping->filename, desc, err);
gt_assert(had_err); /* adding a seqid without range should fail */
}
else {
seqid_info = seqid_info_new(seqnum, filenum, &descrange);
gt_hashmap_add(mapping->map, gt_cstr_dup(desc), seqid_info);
}
} else {
char *dup;
/* offset could be parsed -> store description up to ':' as sequence id */
j = 0;
while (desc[j] != ':')
j++;
dup = gt_malloc((j + 1) * sizeof *dup);
strncpy(dup, desc, j);
dup[j] = '\0';
if ((seqid_info = gt_hashmap_get(mapping->map, dup))) {
had_err = seqid_info_add(seqid_info, seqnum, filenum, &descrange,
mapping->filename, dup, err);
gt_free(dup);
}
else {
seqid_info = seqid_info_new(seqnum, filenum, &descrange);
gt_hashmap_add(mapping->map, dup, seqid_info);
}
}
return had_err;
}
void gt_timer_show_progress_va(GtTimer *t, FILE *fp, const char *desc,
va_list ap)
{
char buf[BUFSIZ];
struct timeval elapsed_tv, elapsed_user_tv, elapsed_sys_tv;
gt_assert(t && desc);
gettimeofday(&t->stop_tv, NULL);
gt_xgetrusage(RUSAGE_SELF, &t->stop_ru);
timeval_subtract(&elapsed_tv, &t->stop_tv, &t->start_tv);
timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
&t->start_ru.ru_utime);
timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
&t->start_ru.ru_stime);
gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
&elapsed_sys_tv, t->statedesc, fp);
if (t->statedesc)
gt_free(t->statedesc);
(void) vsnprintf(buf, BUFSIZ, desc, ap);
t->statedesc = gt_cstr_dup(buf);
gettimeofday(&t->start_tv, NULL);
gt_xgetrusage(RUSAGE_SELF, &t->start_ru);
}
static void gt_hmmer_parse_status_add_hit(GtHMMERParseStatus *s,
GtHMMERSingleHit *hit)
{
GtHMMERModelHit *mh;
gt_assert(s);
if (!(mh = gt_hashmap_get(s->models, gt_str_get(s->cur_model)))) {
mh = gt_calloc((size_t) 1, sizeof (*mh));
mh->fwd_hits = gt_array_new(sizeof (GtHMMERSingleHit*));
mh->rev_hits = gt_array_new(sizeof (GtHMMERSingleHit*));
mh->best_rev = mh->best_fwd = DBL_MAX;
mh->modelname = gt_cstr_dup(gt_str_get(s->cur_model));
gt_hashmap_add(s->models, mh->modelname, mh);
}
gt_assert(mh && mh->fwd_hits &&mh->rev_hits);
if (hit->strand == GT_STRAND_FORWARD) {
if (gt_double_compare(mh->best_fwd, hit->evalue) > 0)
mh->best_fwd = hit->evalue;
gt_array_add(mh->fwd_hits, hit);
} else {
if (gt_double_compare(mh->best_rev, hit->evalue) > 0)
mh->best_rev = hit->evalue;
gt_array_add(mh->rev_hits, hit);
}
}
/*read condenseq data structure from file*/
GtCondenseq *gt_condenseq_new_from_file(const char *indexname,
GtLogger *logger, GtError *err)
{
int had_err = 0;
FILE* fp;
GtEncseqLoader *esl;
GtEncseq *unique_es;
GtCondenseq *condenseq = NULL;
/*load unique_es*/
esl = gt_encseq_loader_new();
unique_es = gt_encseq_loader_load(esl, indexname, err);
if (!unique_es)
had_err = -1;
if (!had_err) {
gt_encseq_loader_delete(esl);
condenseq = condenseq_new_empty(gt_encseq_alphabet(unique_es));
condenseq->filename = gt_cstr_dup(indexname);
condenseq->unique_es = unique_es;
fp = gt_fa_fopen_with_suffix(indexname, GT_CONDENSEQ_FILE_SUFFIX,
"rb", err);
if (fp == NULL) {
had_err = -1;
}
else {
had_err = condenseq_io(condenseq, fp, gt_io_error_fread, err);
if (!had_err) {
GtUword i;
gt_assert(condenseq->uniques);
gt_assert(condenseq->links);
gt_fa_fclose(fp);
/*create link array for each unique entry*/
for (i = 0; i < condenseq->udb_nelems; i++) {
GT_INITARRAY(&(condenseq->uniques[i].links),uint32_t);
}
/* check for overflows */
if (condenseq->ldb_nelems > (GtUword) ((uint32_t) 0 - (uint32_t) 1)) {
gt_error_set(err, "Overflow, to many link-elements. Can't be stored");
had_err = -1;
}
/* iterate through link entrys and store ids in corresponding unique
entry array */
for (i = 0; !had_err && (GtUword) i < condenseq->ldb_nelems; i++) {
GtUword uid = condenseq->links[i].unique_id;
gt_assert(uid < condenseq->udb_nelems);
GT_STOREINARRAY(&(condenseq->uniques[uid].links),
uint32_t,
10,
(uint32_t) i);
}
}
}
}
if (!had_err) {
gt_assert(condenseq != NULL);
if (condenseq->id_len != GT_UNDEF_UWORD)
gt_logger_log(logger, "IDs const len: " GT_WU, condenseq->id_len);
else
gt_logger_log(logger, "using sdstab to access IDs");
}
if (had_err) {
gt_condenseq_delete(condenseq);
condenseq = NULL;
}
return (condenseq);
}
void vang_relation_set_note(VangRelation *rel, const char *note)
{
if(rel->note != NULL)
gt_free(rel->note);
rel->note = gt_cstr_dup(note);
}
void vang_relation_set_key(VangRelation *rel, const char *key)
{
gt_free(rel->key);
rel->key = gt_cstr_dup(key);
}
