GtNodeVisitor* gt_cds_check_visitor_new(void)
{
GtNodeVisitor *nv = gt_node_visitor_create(gt_cds_check_visitor_class());
GtCDSCheckVisitor *v = cds_check_visitor_cast(nv);
v->cds_features = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
v->cds_features_to_split = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
return nv;
}
static void fa_init(void)
{
gt_assert(!fa);
fa = gt_calloc(1, sizeof (FA));
fa->file_pointer = gt_hashmap_new(HASH_DIRECT, NULL,
(GtFree) free_FAFileInfo);
fa->memory_maps = gt_hashmap_new(HASH_DIRECT, NULL,
(GtFree) free_FAMapInfo);
}
GtFeatureInfo* gt_feature_info_new(void)
{
GtFeatureInfo *fi = gt_malloc(sizeof *fi);
fi->id_to_genome_node = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_genome_node_delete);
fi->id_to_pseudo_parent = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_genome_node_delete);
return fi;
}
GtTypeGraph* gt_type_graph_new(void)
{
GtTypeGraph *type_graph = gt_malloc(sizeof (GtTypeGraph));
type_graph->name2id = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
type_graph->nodemap = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
type_graph->nodes = gt_array_new(sizeof (GtTypeNode*));
type_graph->part_of_out_edges = gt_bool_matrix_new();
type_graph->part_of_in_edges = gt_bool_matrix_new();
type_graph->ready = false;
return type_graph;
}
static void gt_gff3_visitor_init(GtGFF3Visitor *gff3_visitor)
{
gff3_visitor->version_string_shown = false;
gff3_visitor->fasta_directive_shown = false;
gff3_visitor->id_counter = gt_string_distri_new();
gff3_visitor->feature_node_to_id_array =
gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_array_delete);
gff3_visitor->feature_node_to_unique_id_str =
gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_str_delete);
gff3_visitor->fasta_width = 0;
gff3_visitor->used_ids = gt_cstr_table_new();
/* XXX */
gff3_visitor->retain_ids = getenv("GT_RETAINIDS") ? true : false;
gff3_visitor->allow_nonunique_ids = false;
}
GtToolbox* gt_toolbox_new(void)
{
GtToolbox *tb;
tb = gt_malloc(sizeof (GtToolbox));
tb->tools = gt_hashmap_new(GT_HASH_STRING, NULL, (GtFree) gt_toolinfo_delete);
return tb;
}
GtXRFChecker* gt_xrf_checker_new(const char *file_path, GtError *err)
{
GtXRFChecker *xrc;
GtUword i;
gt_error_check(err);
gt_assert(file_path);
xrc = gt_calloc(1UL, sizeof (GtXRFChecker));
xrc->xpt = gt_xrf_abbr_parse_tree_new(file_path, err);
if (!xrc->xpt) {
gt_xrf_checker_delete(xrc);
return NULL;
}
xrc->abbrvs = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
for (i = 0; i < gt_xrf_abbr_parse_tree_num_of_entries(xrc->xpt); i++) {
const GtXRFAbbrEntry *e = gt_xrf_abbr_parse_tree_get_entry(xrc->xpt, i);
const char *synonym;
gt_hashmap_add(xrc->abbrvs,
(void*) gt_xrf_abbr_entry_get_value(e, "abbreviation"),
(void*) e);
if ((synonym = gt_xrf_abbr_entry_get_value(e, "synonym"))) {
gt_hashmap_add(xrc->abbrvs, (void*) synonym, (void*) e);
}
}
xrc->splitter = gt_splitter_new();
return xrc;
}
GtLayout* gt_layout_new_with_twc(GtDiagram *diagram,
unsigned int width,
GtStyle *style,
GtTextWidthCalculator *twc,
GtError *err)
{
GtLayout *layout;
GtLayoutTraverseInfo lti;
gt_assert(diagram && style && twc && err);
if (check_width(width, style, err) < 0)
return NULL;
layout = gt_calloc(1, sizeof (GtLayout));
layout->twc = twc;
layout->style = style;
layout->width = width;
layout->viewrange = gt_diagram_get_range(diagram);
layout->nof_tracks = 0;
lti.layout = layout;
lti.twc = twc;
layout->own_twc = false;
(void) gt_diagram_build(diagram);
layout->custom_tracks = gt_array_ref(gt_diagram_get_custom_tracks(diagram));
/* XXX: use other container type here! */
layout->tracks = gt_hashmap_new(HASH_STRING, gt_free_func,
(GtFree) gt_track_delete);
(void) gt_hashmap_foreach(gt_diagram_get_blocks(diagram),
layout_tracks,
<i,
NULL);
return layout;
}
void gth_region_factory_save(GthRegionFactory *rf, GtArray *nodes,
GthInput *input)
{
GtHashmap *sequence_regions;
GtUword i, j;
GtStr *sequenceid;
GT_UNUSED int had_err;
gt_assert(rf && nodes && input);
gt_assert(!rf->factory_was_used);
rf->seqid_store = seqid_store_new(input);
sequence_regions = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
sequenceid = gt_str_new();
for (i = 0; i < gth_input_num_of_gen_files(input); i++) {
gth_input_load_genomic_file(input, i, false);
for (j = 0; j < gth_input_num_of_gen_seqs(input, i); j++) {
gt_str_reset(sequenceid);
gth_input_save_gen_identifier(input, sequenceid, i, j);
make_sequence_region(sequence_regions, sequenceid, rf, input, i, j);
}
}
gt_str_delete(sequenceid);
had_err = gt_hashmap_foreach_in_key_order(sequence_regions,
save_sequence_region, nodes, NULL);
gt_assert(!had_err); /* should not happen */
gt_hashmap_delete(sequence_regions);
rf->factory_was_used = true;
}
GtNodeVisitor* gt_snp_annotator_visitor_new(GtFeatureNode *gene,
GtTransTable *trans_table,
GtRegionMapping *rmap,
GtError *err)
{
GtNodeVisitor *nv;
GtSNPAnnotatorVisitor *sav;
gt_assert(gene && gt_feature_node_get_type(gene) == gt_symbol(gt_ft_gene));
nv = gt_node_visitor_create(gt_snp_annotator_visitor_class());
sav = snp_annotator_visitor_cast(nv);
sav->gene = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) gene);
sav->rmap = gt_region_mapping_ref(rmap);
sav->mRNA_type = gt_symbol(gt_ft_mRNA);
sav->CDS_type = gt_symbol(gt_ft_CDS);
sav->SNV_type = gt_symbol(gt_ft_SNV);
sav->SNP_type = gt_symbol(gt_ft_SNP);
sav->rnaseqs = gt_hashmap_new(GT_HASH_DIRECT, NULL, gt_free_func);
if (trans_table) {
sav->tt = trans_table;
sav->own_tt = false;
} else {
sav->tt = gt_trans_table_new_standard(err);
sav->own_tt = true;
}
if (!sav->tt || gt_snp_annotator_visitor_prepare_gene(sav, err) != 0) {
gt_node_visitor_delete(nv);
return NULL;
}
return nv;
}
GtFeatureIndex *agn_import_simple(int numfiles, const char **filenames,
char *type, AgnLogger *logger)
{
GtFeatureIndex *features = gt_feature_index_memory_new();
GtNodeStream *gff3 = gt_gff3_in_stream_new_unsorted(numfiles, filenames);
gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)gff3);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)gff3);
GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
gt_hashmap_add(typestokeep, type, type);
GtNodeStream *filterstream = agn_filter_stream_new(gff3, typestokeep);
GtNodeStream *featstream = gt_feature_out_stream_new(filterstream, features);
GtError *error = gt_error_new();
int result = gt_node_stream_pull(featstream, error);
if(result == -1)
{
agn_logger_log_error(logger, "error processing node stream: %s",
gt_error_get(error));
}
gt_error_delete(error);
if(agn_logger_has_error(logger))
{
gt_feature_index_delete(features);
features = NULL;
}
gt_node_stream_delete(gff3);
gt_node_stream_delete(filterstream);
gt_node_stream_delete(featstream);
return features;
}
GtNodeVisitor* gt_gff3_visitor_new(GtFile *outfp)
{
GtNodeVisitor *nv = gt_node_visitor_create(gt_gff3_visitor_class());
GtGFF3Visitor *gff3_visitor = gff3_visitor_cast(nv);
gff3_visitor->version_string_shown = false;
gff3_visitor->fasta_directive_shown = false;
gff3_visitor->id_counter = gt_string_distri_new();
gff3_visitor->feature_node_to_id_array =
gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_array_delete);
gff3_visitor->feature_node_to_unique_id_str =
gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_str_delete);
gff3_visitor->fasta_width = 0;
gff3_visitor->outfp = outfp;
gff3_visitor->used_ids = gt_cstr_table_new();
gff3_visitor->retain_ids = false;
return nv;
}
GtGTFParser* gt_gtf_parser_new(GtTypeChecker *type_checker)
{
GtGTFParser *parser = gt_malloc(sizeof (GtGTFParser));
parser->gene_id_hash = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_hashmap_delete);
parser->seqid_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL,
(GtFree) gt_str_delete);
parser->source_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL,
(GtFree) gt_str_delete);
parser->gene_id_to_name_mapping = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
gt_free_func);
parser->transcript_id_to_name_mapping = gt_hashmap_new(GT_HASH_STRING,
gt_free_func,
gt_free_func);
parser->region_node_builder = gt_region_node_builder_new();
parser->type_checker = type_checker;
return parser;
}
GtNodeVisitor* gt_regioncov_visitor_new(GtUword max_feature_dist)
{
GtNodeVisitor *nv = gt_node_visitor_create(gt_regioncov_visitor_class());
GtRegionCovVisitor *regioncov_visitor = gt_regioncov_visitor_cast(nv);
regioncov_visitor->max_feature_dist = max_feature_dist;
regioncov_visitor->region2rangelist =
gt_hashmap_new(GT_HASH_STRING, gt_free_func, (GtFree) gt_array_delete);
return nv;
}
static GtHMMERParseStatus* gt_hmmer_parse_status_new(void)
{
GtHMMERParseStatus *s;
s = gt_calloc((size_t) 1, sizeof (GtHMMERParseStatus));
s->cur_model = gt_str_new();
s->models = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_hmmer_model_hit_delete);
return s;
}
static void gv_test_calc_integrity(AgnUnitTest *test)
{
const char *filename = "data/gff3/gaeval-stream-unit-test-2.gff3";
GtNodeStream *align_in = gt_gff3_in_stream_new_unsorted(1, &filename);
AgnGaevalParams params = { 0.6, 0.3, 0.05, 0.05, 400, 200, 100 };
GtNodeVisitor *nv = agn_gaeval_visitor_new(align_in, params);
AgnGaevalVisitor *gv = gaeval_visitor_cast(nv);
gt_node_stream_delete(align_in);
GtNodeStream *gff3in = gt_gff3_in_stream_new_unsorted(1, &filename);
GtHashmap *typestokeep = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
gt_hashmap_add(typestokeep, "mRNA", "mRNA");
GtNodeStream *filtstream = agn_filter_stream_new(gff3in, typestokeep);
GtLogger *logger = gt_logger_new(true, "", stderr);
GtNodeStream *ics = agn_infer_cds_stream_new(filtstream, NULL, logger);
GtNodeStream *ies = agn_infer_exons_stream_new(ics, NULL, logger);
GtError *error = gt_error_new();
GtArray *feats = gt_array_new( sizeof(GtFeatureNode *) );
GtNodeStream *featstream = gt_array_out_stream_new(ies, feats, error);
int result = gt_node_stream_pull(featstream, error);
if(result == -1)
{
fprintf(stderr, "[AgnGaevalVisitor::gv_test_calc_integrity] error "
"processing GFF3: %s\n", gt_error_get(error));
return;
}
gt_node_stream_delete(gff3in);
gt_node_stream_delete(filtstream);
gt_node_stream_delete(featstream);
gt_node_stream_delete(ics);
gt_node_stream_delete(ies);
gt_logger_delete(logger);
gt_hashmap_delete(typestokeep);
agn_assert(gt_array_size(feats) == 2);
GtFeatureNode *g1 = *(GtFeatureNode **)gt_array_get(feats, 0);
GtFeatureNode *g2 = *(GtFeatureNode **)gt_array_get(feats, 1);
double cov1 = gaeval_visitor_calculate_coverage(gv, g1, error);
double cov2 = gaeval_visitor_calculate_coverage(gv, g2, error);
double int1 = gaeval_visitor_calculate_integrity(gv, g1, cov1, NULL, error);
double int2 = gaeval_visitor_calculate_integrity(gv, g2, cov2, NULL, error);
bool test1 = fabs(cov1 - 1.000) < 0.001 &&
fabs(cov2 - 0.997) < 0.001 &&
fabs(int1 - 0.850) < 0.001 &&
fabs(int2 - 0.863) < 0.001;
agn_unit_test_result(test, "calculate integrity", test1);
gt_error_delete(error);
gt_array_delete(feats);
gt_genome_node_delete((GtGenomeNode *)g1);
gt_genome_node_delete((GtGenomeNode *)g2);
gt_node_visitor_delete(nv);
}
static void build_md5map(GtMD5Tab *md5_tab)
{
GtUword i;
gt_assert(md5_tab);
md5_tab->md5map = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
for (i = 0; i < md5_tab->num_of_md5s; i++) {
gt_hashmap_add(md5_tab->md5map, (void*) gt_md5_tab_get(md5_tab, i),
(void*) (i + 1));
}
}
GtXRFAbbrEntry* gt_xrf_abbr_entry_new(GtUword line,
GtStr *filename)
{
GtXRFAbbrEntry *abbr_entry = gt_malloc(sizeof *abbr_entry);
abbr_entry->content = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) gt_str_delete);
abbr_entry->line = line;
abbr_entry->filename = gt_str_ref(filename);
return abbr_entry;
}
GtLineBreaker* gt_line_breaker_bases_new()
{
GtLineBreakerBases *lbb;
GtLineBreaker *lb;
lb = gt_line_breaker_create(gt_line_breaker_bases_class());
lbb = gt_line_breaker_bases_cast(lb);
lbb->itrees = gt_hashmap_new(HASH_DIRECT, NULL,
(GtFree) gt_interval_tree_delete);
return lb;
}
void gt_hpol_processor_enable_sorted_segments_output(GtHpolProcessor *hpp,
unsigned long nfiles, GtSeqIterator **reads_iters, GtFile **outfiles)
{
gt_assert(hpp != NULL);
gt_aligned_segments_pile_disable_segment_deletion(hpp->asp);
hpp->processed_segments = gt_hashmap_new(GT_HASH_STRING, NULL,
(GtFree)gt_aligned_segment_delete);
hpp->reads_iters = reads_iters;
hpp->outfiles = outfiles;
hpp->nfiles = nfiles;
}
GtBEDParser* gt_bed_parser_new(void)
{
GtBEDParser *bed_parser = gt_calloc(1, sizeof *bed_parser);
bed_parser->region_node_builder = gt_region_node_builder_new();
bed_parser->feature_nodes = gt_queue_new();
bed_parser->seqid_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL,
(GtFree) gt_str_delete);
bed_parser->word = gt_str_new();
bed_parser->another_word = gt_str_new();
return bed_parser;
}
static NodeInfoElement* nodeinfo_get(GtDiagram *d, GtFeatureNode *node)
{
NodeInfoElement *ni;
gt_assert(d && node);
if (!(ni = gt_hashmap_get(d->nodeinfo, node))) {
ni = gt_calloc(1, sizeof (NodeInfoElement));
ni->type_index = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
ni->types = gt_str_array_new();
gt_hashmap_add(d->nodeinfo, node, ni);
}
return ni;
}
GtNodeVisitor* gt_add_ids_visitor_new(bool ensure_sorting)
{
GtNodeVisitor *nv = gt_node_visitor_create(gt_add_ids_visitor_class());
GtAddIDsVisitor *add_ids_visitor = add_ids_visitor_cast(nv);
add_ids_visitor->node_buffer = gt_queue_new();
add_ids_visitor->defined_seqids = gt_cstr_table_new();
add_ids_visitor->undefined_sequence_regions =
gt_hashmap_new(GT_HASH_STRING, NULL,
(GtFree) automatic_sequence_region_delete);
add_ids_visitor->ensure_sorting = ensure_sorting;
return nv;
}
int main(int argc, char **argv)
{
if(argc != 2)
{
fputs("usage: vang schema.file\n", stderr);
return 1;
}
gt_lib_init();
char *schemafile = argv[1];
FILE *schema = fopen(schemafile, "r");
if(schema == NULL)
{
fprintf(stderr, "error: unable to open schema file '%s'\n", schemafile);
return 1;
}
GtArray *entry_datatypes = gt_array_new( sizeof(char *) );
GtHashmap *entries = gt_hashmap_new( GT_HASH_STRING, NULL,
(GtFree)vang_schema_entry_delete );
VangSchemaEntry *entry;
while( (entry = vang_schema_entry_next(schema)) != NULL )
{
char *datatype = (char *)vang_schema_entry_get_datatype(entry);
VangSchemaEntry *testentry = gt_hashmap_get(entries, datatype);
if(testentry != NULL)
{
fprintf( stderr, "warning: already have an entry for data type '%s'; "
"replacing\n", datatype );
vang_schema_entry_delete(testentry);
}
gt_hashmap_add(entries, datatype, entry);
gt_array_add(entry_datatypes, datatype);
}
unsigned long i;
for(i = 0; i < gt_array_size(entry_datatypes); i++)
{
const char *type = *(const char **)gt_array_get(entry_datatypes, i);
VangSchemaEntry *entry = gt_hashmap_get(entries, type);
vang_schema_entry_to_string(entry, stdout);
puts("");
}
gt_array_delete(entry_datatypes);
gt_hashmap_delete(entries);
gt_lib_clean();
return 0;
}
GtNodeStream* gt_targetbest_filter_stream_new(GtNodeStream *in_stream)
{
GtTargetbestFilterStream *tfs;
GtNodeStream *gs;
gt_assert(in_stream);
gs = gt_node_stream_create(gt_targetbest_filter_stream_class(),
gt_node_stream_is_sorted(in_stream));
tfs = targetbest_filter_stream_cast(gs);
tfs->in_stream = gt_node_stream_ref(in_stream);
tfs->in_stream_processed = false;
tfs->trees = gt_dlist_new(NULL);
tfs->target_to_elem = gt_hashmap_new(HASH_STRING, gt_free_func, NULL);
return gs;
}
static void nodeinfo_add_block(NodeInfoElement *ni, const char *gft,
GtFeatureNode *rep, GtBlock *block)
{
GtBlockTuple *bt;
PerTypeInfo *type_struc = NULL;
gt_assert(ni);
bt = blocktuple_new(gft, rep, block);
if (!(ni->type_index))
{
ni->type_index = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
}
if (!(type_struc = gt_hashmap_get(ni->type_index, gft)))
{
type_struc = gt_calloc(1, sizeof (PerTypeInfo));
type_struc->rep_index = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
type_struc->blocktuples = gt_array_new(sizeof (GtBlockTuple*));
gt_hashmap_add(ni->type_index, (char*) gft, type_struc);
gt_str_array_add_cstr(ni->types, gft);
}
gt_hashmap_add(type_struc->rep_index, rep, bt);
if (rep != GT_UNDEF_REPR)
type_struc->must_merge = true;
gt_array_add(type_struc->blocktuples, bt);
}
static GtDiagram* gt_diagram_new_generic(GtArray *features,
const GtRange *range,
GtStyle *style,
bool ref_features)
{
GtDiagram *diagram;
diagram = gt_calloc(1, sizeof (GtDiagram));
diagram->nodeinfo = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
diagram->style = style;
diagram->lock = gt_rwlock_new();
diagram->range = *range;
if (ref_features)
diagram->features = gt_array_ref(features);
else
diagram->features = features;
diagram->select_func = default_track_selector;
diagram->custom_tracks = gt_array_new(sizeof (GtCustomTrack*));
/* init caches */
diagram->collapsingtypes = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
diagram->groupedtypes = gt_hashmap_new(GT_HASH_STRING, NULL, gt_free_func);
diagram->caption_display_status = gt_hashmap_new(GT_HASH_DIRECT, NULL,
gt_free_func);
return diagram;
}
static int check_cds_phases_if_necessary(GtFeatureNode *fn,
GtCDSCheckVisitor *v,
bool second_pass, GtError *err)
{
GtFeatureNodeIterator *fni;
GtFeatureNode *node;
GtArray *cds_features = NULL;
GtHashmap *multi_features = NULL;
int had_err = 0;
gt_error_check(err);
gt_assert(fn);
fni = gt_feature_node_iterator_new_direct(fn);
while ((node = gt_feature_node_iterator_next(fni))) {
if (gt_feature_node_has_type(node, gt_ft_CDS)) {
if (gt_feature_node_is_multi(node)) {
GtArray *features;
if (!multi_features)
multi_features = gt_hashmap_new(GT_HASH_DIRECT, NULL,
(GtFree) gt_array_delete);
if ((features =
gt_hashmap_get(multi_features,
gt_feature_node_get_multi_representative(node)))) {
gt_array_add(features, node);
}
else {
GtFeatureNode *representative;
features = gt_array_new(sizeof (GtFeatureNode*));
representative = gt_feature_node_get_multi_representative(node);
gt_array_add(features, representative);
gt_hashmap_add(multi_features, representative, features);
}
}
else {
if (!cds_features)
cds_features = gt_array_new(sizeof (GtFeatureNode*));
gt_array_add(cds_features, node);
}
}
}
if (cds_features)
had_err = check_cds_phases(cds_features, v, false, second_pass, err);
if (!had_err && multi_features)
had_err = gt_hashmap_foreach(multi_features, check_cds_phases_hm, v, err);
gt_array_delete(cds_features);
gt_hashmap_delete(multi_features);
gt_feature_node_iterator_delete(fni);
return had_err;
}
GtSeqid2SeqnumMapping* gt_seqid2seqnum_mapping_new_seqcol(GtSeqCol *seqcol,
GtError *err)
{
GtSeqid2SeqnumMapping *mapping;
gt_error_check(err);
gt_assert(seqcol);
mapping = gt_malloc(sizeof *mapping);
mapping->filename = NULL;
mapping->map = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) seqid_info_delete);
if (fill_mapping(mapping, NULL, seqcol, err)) {
gt_seqid2seqnum_mapping_delete(mapping);
return NULL;
}
mapping->cached_seqid = NULL;
return mapping;
}
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;
}
