static int cds_check_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
GtError *err)
{
GtCDSCheckVisitor *v = cds_check_visitor_cast(nv);
GtFeatureNodeIterator *fni;
GtFeatureNode *node;
int had_err = 0;
gt_error_check(err);
gt_assert(v && fn);
fni = gt_feature_node_iterator_new(fn);
while (!had_err && (node = gt_feature_node_iterator_next(fni)))
had_err = check_cds_phases_if_necessary(node, v, false, err);
gt_feature_node_iterator_delete(fni);
gt_hashmap_reset(v->cds_features);
while (v->splitting_is_necessary) {
split_cds_features(v->cds_features_to_split, fn);
gt_hashmap_reset(v->cds_features_to_split);
v->splitting_is_necessary = false;
/* perform second pass to correct phases */
fni = gt_feature_node_iterator_new(fn);
while (!had_err && (node = gt_feature_node_iterator_next(fni)))
had_err = check_cds_phases_if_necessary(node, v, false, err);
gt_feature_node_iterator_delete(fni);
gt_hashmap_reset(v->cds_features);
}
return had_err;
}
static int gff3_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
GtError *err)
{
GtGFF3Visitor *gff3_visitor;
int had_err;
gt_error_check(err);
gff3_visitor = gff3_visitor_cast(nv);
gff3_version_string(nv);
had_err = gt_feature_node_traverse_children(fn, gff3_visitor, store_ids, true,
err);
if (!had_err) {
if (gt_feature_node_is_tree(fn)) {
had_err = gt_feature_node_traverse_children(fn, gff3_visitor,
gff3_show_feature_node, true,
err);
}
else {
/* got a DAG -> traverse in topologically sorted depth first fashion to
make sure that the 'Parent' attributes are shown in correct order */
had_err =
gt_feature_node_traverse_children_top(fn, gff3_visitor,
gff3_show_feature_node, err);
}
}
/* reset hashmaps */
gt_hashmap_reset(gff3_visitor->feature_node_to_id_array);
gt_hashmap_reset(gff3_visitor->feature_node_to_unique_id_str);
/* show terminator, if the feature has children (otherwise it is clear that
the feature is complete, because no ID attribute has been shown) */
if (gt_feature_node_has_children(fn) ||
(gff3_visitor->retain_ids && gt_feature_node_get_attribute(fn, "ID"))) {
if (!gff3_visitor->outstr)
gt_file_xprintf(gff3_visitor->outfp, "%s\n", GT_GFF_TERMINATOR);
else {
gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_TERMINATOR);
gt_str_append_char(gff3_visitor->outstr, '\n');
}
}
return had_err;
}
void gt_add_ids_visitor_finalize(GtNodeVisitor *nv)
{
GT_UNUSED int had_err;
GtAddIDsVisitor *add_ids_visitor = add_ids_visitor_cast(nv);
had_err = gt_hashmap_foreach(add_ids_visitor->undefined_sequence_regions,
add_auto_sr_to_queue,
add_ids_visitor->node_buffer, NULL);
gt_assert(!had_err); /* add_auto_sr_to_queue() is sane */
gt_hashmap_reset(add_ids_visitor->undefined_sequence_regions);
}
static int gt_diagram_build(GtDiagram *diagram, GtError *err)
{
GtUword i = 0;
int had_err = 0;
NodeTraverseInfo nti;
gt_assert(diagram);
nti.diagram = diagram;
nti.err = err;
/* clear caches */
gt_hashmap_reset(diagram->collapsingtypes);
gt_hashmap_reset(diagram->groupedtypes);
gt_hashmap_reset(diagram->caption_display_status);
if (!diagram->blocks)
{
gt_hashmap_reset(diagram->nodeinfo);
/* do node traversal for each root feature */
for (i = 0; i < gt_array_size(diagram->features); i++)
{
GtFeatureNode *current_root;
current_root = *(GtFeatureNode**) gt_array_get(diagram->features,i);
had_err = traverse_genome_nodes(current_root, &nti);
if (had_err)
return -1;
}
diagram->blocks = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
(GtFree) blocklist_delete);
/* collect blocks from nodeinfo structures */
had_err = gt_hashmap_foreach_ordered(diagram->nodeinfo,
collect_blocks,
diagram,
(GtCompare) gt_genome_node_cmp,
NULL);
gt_assert(!had_err); /* collect_blocks() is sane */
}
return had_err;
}
static int cds_check_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
GtError *err)
{
GtCDSCheckVisitor *v = cds_check_visitor_cast(nv);
GtFeatureNodeIterator *fni;
GtFeatureNode *node;
int had_err = 0;
gt_error_check(err);
gt_assert(v && fn);
fni = gt_feature_node_iterator_new(fn);
while (!had_err && (node = gt_feature_node_iterator_next(fni)))
had_err = check_cds_phases_if_necessary(node, v, err);
gt_feature_node_iterator_delete(fni);
gt_hashmap_reset(v->cds_features);
return had_err;
}
void gt_feature_info_reset(GtFeatureInfo *fi)
{
gt_assert(fi);
gt_hashmap_reset(fi->id_to_genome_node);
gt_hashmap_reset(fi->id_to_pseudo_parent);
}
static int
gt_hashmap_test(GtHashType hash_type)
{
char *s1 = "foo", *s2 = "bar";
GT_UNUSED unsigned long ul1 = 1UL, ul2 = 2UL;
GT_UNUSED unsigned long long ull1 = 3ULL, ull2 = 4ULL, *sptr = NULL,
*tptr = NULL;
GtHashmap *hm;
GtHashtable *ht;
int had_err = 0;
do {
/* empty hash */
hm = gt_hashmap_new(hash_type, NULL, NULL);
gt_hashmap_delete(hm);
/* empty hash with reset */
hm = gt_hashmap_new(hash_type, NULL, NULL);
gt_hashmap_reset(hm);
gt_hashmap_delete(hm);
/* hashes containing one element */
hm = gt_hashmap_new(hash_type, NULL, NULL);
gt_hashmap_add(hm, s1, s2);
my_ensure(had_err, gt_hashmap_get(hm, s1) == s2);
my_ensure(had_err, !gt_hashmap_get(hm, s2));
gt_hashmap_delete(hm);
/* hashes containing two elements */
hm = gt_hashmap_new(hash_type, NULL, NULL);
gt_hashmap_add(hm, s1, s2);
gt_hashmap_add(hm, s2, s1);
my_ensure(had_err, gt_hashmap_get(hm, s1) == s2);
my_ensure(had_err, gt_hashmap_get(hm, s2) == s1);
/* remove element A and ensure it's no longer present */
gt_hashmap_remove(hm, s1);
my_ensure(had_err, !gt_hashmap_get(hm, s1));
my_ensure(had_err, gt_hashmap_get(hm, s2) == s1);
gt_hashmap_delete(hm);
/* hashes containing two elements (store key and value in
* hashmap) where simple free is the correct way to get rid of them
*/
if (hash_type == GT_HASH_STRING)
{
hm = gt_hashmap_new(hash_type, gt_free_func, gt_free_func);
gt_hashmap_add(hm, gt_cstr_dup(s1), gt_cstr_dup(s2));
gt_hashmap_add(hm, gt_cstr_dup(s2), gt_cstr_dup(s1));
my_ensure(had_err, !strcmp(gt_hashmap_get(hm, s1), s2));
my_ensure(had_err, !strcmp(gt_hashmap_get(hm, s2), s1));
gt_hashmap_remove(hm, s1); /* remove first element */
my_ensure(had_err, !gt_hashmap_get(hm, s1));
my_ensure(had_err, !strcmp(gt_hashmap_get(hm, s2), s1));
gt_hashmap_delete(hm);
}
/* test direct modification of hash contents */
ht = testul_testull_gt_hashmap_new();
my_ensure(had_err, !sptr);
sptr = testul_testull_gt_hashmap_add_and_return_storage(ht, ul1, ull1);
my_ensure(had_err, *sptr == ull1);
sptr = testul_testull_gt_hashmap_add_and_return_storage(ht, ul1, ull2);
my_ensure(had_err, *sptr == ull2);
(*sptr)++;
tptr = testul_testull_gt_hashmap_get(ht, ul1);
my_ensure(had_err, tptr == sptr);
my_ensure(had_err, *tptr == ull2+1);
gt_hashtable_delete(ht);
} while (0);
return had_err;
}
