static int select_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn, GT_UNUSED GtError *err) { GtSelectVisitor *select_visitor; gt_error_check(err); select_visitor = select_visitor_cast(nv); if (!gt_str_length(select_visitor->seqid) || /* no seqid was specified */ !gt_str_cmp(select_visitor->seqid, /* or seqids are equal */ gt_genome_node_get_seqid((GtGenomeNode*) rn))) { if (select_visitor->contain_range.start != GT_UNDEF_ULONG) { GtRange range = gt_genome_node_get_range((GtGenomeNode*) rn); if (gt_range_overlap(&range, &select_visitor->contain_range)) { /* an overlapping contain range was defined -> update range */ range.start = MAX(range.start, select_visitor->contain_range.start); range.end = MIN(range.end, select_visitor->contain_range.end); gt_genome_node_set_range((GtGenomeNode*) rn, &range); gt_queue_add(select_visitor->node_buffer, rn); } else /* contain range does not overlap with <rn> range -> delete <rn> */ gt_genome_node_delete((GtGenomeNode*) rn); } else gt_queue_add(select_visitor->node_buffer, rn); } else gt_genome_node_delete((GtGenomeNode*) rn); return 0; }
static int gt_sort_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err) { GtSortStream *sort_stream; GtGenomeNode *node, *eofn; int had_err = 0; gt_error_check(err); sort_stream = gt_sort_stream_cast(ns); if (!sort_stream->sorted) { while (!(had_err = gt_node_stream_next(sort_stream->in_stream, &node, err)) && node) { if ((eofn = gt_eof_node_try_cast(node))) gt_genome_node_delete(eofn); /* get rid of EOF nodes */ else gt_array_add(sort_stream->nodes, node); } if (!had_err) { gt_genome_nodes_sort_stable(sort_stream->nodes); sort_stream->sorted = true; } } if (!had_err) { gt_assert(sort_stream->sorted); if (sort_stream->idx < gt_array_size(sort_stream->nodes)) { *gn = *(GtGenomeNode**) gt_array_get(sort_stream->nodes, sort_stream->idx); sort_stream->idx++; /* join region nodes with the same sequence ID */ if (gt_region_node_try_cast(*gn)) { GtRange range_a, range_b; while (sort_stream->idx < gt_array_size(sort_stream->nodes)) { node = *(GtGenomeNode**) gt_array_get(sort_stream->nodes, sort_stream->idx); if (!gt_region_node_try_cast(node) || gt_str_cmp(gt_genome_node_get_seqid(*gn), gt_genome_node_get_seqid(node))) { /* the next node is not a region node with the same ID */ break; } range_a = gt_genome_node_get_range(*gn); range_b = gt_genome_node_get_range(node); range_a = gt_range_join(&range_a, &range_b); gt_genome_node_set_range(*gn, &range_a); gt_genome_node_delete(node); sort_stream->idx++; } } return 0; } } if (!had_err) { gt_array_reset(sort_stream->nodes); *gn = NULL; } return had_err; }
static void snp_annotator_stream_free(GtNodeStream *ns) { GtUword i; GtSNPAnnotatorStream *sas; if (!ns) return; sas = gt_snp_annotator_stream_cast(ns); gt_region_mapping_delete(sas->rmap); while (gt_queue_size(sas->snps) > 0) { gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->snps)); } while (gt_queue_size(sas->outqueue) > 0) { gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->outqueue)); } for (i = 0; i < gt_array_size(sas->instreams); i++) { gt_node_stream_delete(*(GtNodeStream**) gt_array_get(sas->instreams, i)); } for (i = 0; i < gt_array_size(sas->cur_gene_set); i++) { gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(sas->cur_gene_set, i)); } gt_array_delete(sas->cur_gene_set); gt_node_stream_delete(sas->merge_stream); gt_array_delete(sas->instreams); gt_queue_delete(sas->snps); gt_queue_delete(sas->outqueue); }
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 automatic_sequence_region_delete(AutomaticSequenceRegion *auto_sr) { GtUword i; if (!auto_sr) return; gt_genome_node_delete(auto_sr->sequence_region); for (i = 0; i < gt_array_size(auto_sr->feature_nodes); i++) { gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(auto_sr->feature_nodes, i)); } gt_array_delete(auto_sr->feature_nodes); gt_free(auto_sr); }
static void gv_test_introns_confirmed(AgnUnitTest *test) { GtGenomeNode *intron, *gap; GtStr *seqid = gt_str_new_cstr("chr"); GtArray *introns = gt_array_new( sizeof(GtGenomeNode *) ); intron = gt_feature_node_new(seqid, "intron", 1000, 1170, GT_STRAND_REVERSE); gt_array_add(introns, intron); intron = gt_feature_node_new(seqid, "intron", 1225, 1305, GT_STRAND_REVERSE); gt_array_add(introns, intron); intron = gt_feature_node_new(seqid, "intron", 1950, 2110, GT_STRAND_REVERSE); gt_array_add(introns, intron); intron = gt_feature_node_new(seqid, "intron", 2545, 2655, GT_STRAND_REVERSE); gt_array_add(introns, intron); intron = gt_feature_node_new(seqid, "intron", 2800, 2950, GT_STRAND_REVERSE); gt_array_add(introns, intron); GtArray *gaps = gt_array_new( sizeof(GtGenomeNode *) ); double intcon = gaeval_visitor_introns_confirmed(introns, gaps); bool test1 = fabs(intcon - 0.0) < 0.0001; agn_unit_test_result(test, "introns confirmed (no gaps)", test1); gap = gt_feature_node_new(seqid, "match_gap", 1000, 1170, GT_STRAND_REVERSE); gt_array_add(gaps, gap); gap = gt_feature_node_new(seqid, "match_gap", 1225, 1302, GT_STRAND_REVERSE); gt_array_add(gaps, gap); gap = gt_feature_node_new(seqid, "match_gap", 1950, 2110, GT_STRAND_REVERSE); gt_array_add(gaps, gap); gap = gt_feature_node_new(seqid, "match_gap", 2575, 2655, GT_STRAND_REVERSE); gt_array_add(gaps, gap); gap = gt_feature_node_new(seqid, "match_gap", 2800, 2950, GT_STRAND_REVERSE); gt_array_add(gaps, gap); intcon = gaeval_visitor_introns_confirmed(introns, gaps); bool test2 = fabs(intcon - 0.6) < 0.0001; agn_unit_test_result(test, "introns confirmed (gaps)", test2); while(gt_array_size(introns) > 0) { intron = *(GtGenomeNode **)gt_array_pop(introns); gt_genome_node_delete(intron); } gt_array_delete(introns); while(gt_array_size(gaps) > 0) { gap = *(GtGenomeNode **)gt_array_pop(gaps); gt_genome_node_delete(gap); } gt_array_delete(gaps); gt_str_delete(seqid); }
static int select_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err) { GtSelectStream *fs; int had_err; gt_error_check(err); fs = gt_select_stream_cast(ns); /* we still have nodes in the buffer */ if (gt_select_visitor_node_buffer_size(fs->select_visitor)) { /* return one of them */ *gn = gt_select_visitor_get_node(fs->select_visitor); return 0; } /* no nodes in the buffer -> get new nodes */ while (!(had_err = gt_node_stream_next(fs->in_stream, gn, err)) && *gn) { gt_assert(*gn && !had_err); had_err = gt_genome_node_accept(*gn, fs->select_visitor, err); if (had_err) { /* we own the node -> delete it */ gt_genome_node_delete(*gn); *gn = NULL; break; } if (gt_select_visitor_node_buffer_size(fs->select_visitor)) { *gn = gt_select_visitor_get_node(fs->select_visitor); return 0; } } /* either we have an error or no new node */ gt_assert(had_err || !*gn); return had_err; }
int gt_feature_index_add_gff3file(GtFeatureIndex *feature_index, const char *gff3file, GtError *err) { GtNodeStream *gff3_in_stream; GtGenomeNode *gn; GtArray *tmp; int had_err = 0; GtUword i; gt_error_check(err); gt_assert(feature_index && gff3file); tmp = gt_array_new(sizeof (GtGenomeNode*)); gff3_in_stream = gt_gff3_in_stream_new_unsorted(1, &gff3file); while (!(had_err = gt_node_stream_next(gff3_in_stream, &gn, err)) && gn) gt_array_add(tmp, gn); if (!had_err) { GtNodeVisitor *feature_visitor = gt_feature_visitor_new(feature_index); for (i=0;i<gt_array_size(tmp);i++) { gn = *(GtGenomeNode**) gt_array_get(tmp, i); /* no need to lock, add_*_node() is synchronized */ had_err = gt_genome_node_accept(gn, feature_visitor, NULL); gt_assert(!had_err); /* cannot happen */ } gt_node_visitor_delete(feature_visitor); } gt_node_stream_delete(gff3_in_stream); for (i=0;i<gt_array_size(tmp);i++) gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(tmp, i)); gt_array_delete(tmp); return had_err; }
void gt_feature_node_iterator_delete(GtFeatureNodeIterator *fni) { if (!fni) return; gt_genome_node_delete((GtGenomeNode*) fni->fn); gt_array_delete(fni->feature_stack); gt_free(fni); }
int gt_diagram_unit_test(GtError *err) { int had_err = 0; GtGenomeNode *gn; GtDiagramTestShared sh; GtRange testrng = {100, 10000}; gt_error_check(err); gn = gt_feature_node_new_standard_gene(); sh.fi = gt_feature_index_memory_new(); sh.sty = gt_style_new(err); sh.err = err; sh.errstatus = 0; gt_feature_index_add_feature_node(sh.fi, gt_feature_node_cast(gn), err); gt_genome_node_delete(gn); sh.d = gt_diagram_new(sh.fi, "ctg123", &testrng, sh.sty, err); /* removed the multithreading test for now until it is fixed */ gt_diagram_unit_test_sketch_func(&sh); gt_ensure(sh.errstatus == 0); gt_style_delete(sh.sty); gt_diagram_delete(sh.d); gt_feature_index_delete(sh.fi); return had_err; }
static int genome_node_lua_delete(lua_State *L) { GtGenomeNode **gn; gn = check_genome_node(L, 1); gt_genome_node_delete(*gn); return 0; }
static void split_cds_feature(GtFeatureNode *cds_feature, GtFeatureNode *fn) { GtArray *parents; unsigned long i; gt_assert(cds_feature && fn); /* find parents */ parents = find_cds_parents(cds_feature, fn); /* remove CDS feature */ gt_feature_node_remove_leaf(fn, cds_feature); /* add CDS feature to all parents */ for (i = 0; i < gt_array_size(parents); i++) { GtFeatureNode *parent = *(GtFeatureNode**) gt_array_get(parents, i); const char *id = gt_feature_node_get_attribute(parent, GT_GFF_ID); if (!i) { gt_feature_node_set_attribute(cds_feature, GT_GFF_PARENT, id); gt_feature_node_add_child(parent, cds_feature); } else { GtFeatureNode *new_cds = gt_feature_node_clone(cds_feature); gt_feature_node_set_attribute(new_cds, GT_GFF_PARENT, id); gt_feature_node_add_child(parent, new_cds); gt_genome_node_delete((GtGenomeNode*) cds_feature); } } gt_array_delete(parents); }
static int snp_annotator_stream_process_current_gene(GtSNPAnnotatorStream *sas, GtError *err) { int had_err = 0; GtUword i; GtUword nof_genes = gt_array_size(sas->cur_gene_set); gt_error_check(err); if (gt_queue_size(sas->snps) > 0) { /* we need to process SNPs for a gene cluster*/ gt_assert(gt_queue_size(sas->outqueue) == 0); for (i = 0; !had_err && i < nof_genes; i++) { GtNodeVisitor *sav; GtFeatureNode *gene; gene = *(GtFeatureNode**) gt_array_get(sas->cur_gene_set, i); sav = gt_snp_annotator_visitor_new(gene, sas->tt, sas->rmap, err); if (!sav) had_err = -1; if (!had_err) { if (i < nof_genes-1) { had_err = gt_queue_iterate(sas->snps, snp_annotator_stream_process_snp, sav, err); } else { while (!had_err && gt_queue_size(sas->snps) > 0) { GtFeatureNode *snp = (GtFeatureNode*) gt_queue_get(sas->snps); had_err = gt_genome_node_accept((GtGenomeNode*) snp, sav, err); gt_queue_add(sas->outqueue, snp); gt_genome_node_delete((GtGenomeNode*) snp); } } gt_node_visitor_delete(sav); } gt_genome_node_delete((GtGenomeNode*) gene); } } else { /* no SNPs for this gene cluster, delete it */ for (i = 0; !had_err && i < nof_genes; i++) { gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(sas->cur_gene_set, i)); } } gt_assert(gt_queue_size(sas->snps) == 0); gt_array_reset(sas->cur_gene_set); return had_err; }
static void remove_elem(GtDlistelem *elem, GtDlist *trees, GtHashmap *target_to_elem, GtStr *key) { GtGenomeNode *node = gt_dlistelem_get_data(elem); gt_genome_node_delete(node); gt_dlist_remove(trees, elem); gt_hashmap_remove(target_to_elem, gt_str_get(key)); }
void gt_orphanage_reset(GtOrphanage *o) { gt_assert(o); while (gt_queue_size(o->orphans)) gt_genome_node_delete(gt_queue_get(o->orphans)); gt_cstr_table_reset(o->missing_parents); gt_cstr_table_reset(o->orphan_ids); }
static void buffer_stream_free(GtNodeStream *ns) { GtBufferStream *bs = buffer_stream_cast(ns); while (gt_queue_size(bs->node_buffer)) gt_genome_node_delete(gt_queue_get(bs->node_buffer)); gt_queue_delete(bs->node_buffer); gt_node_stream_delete(bs->in_stream); }
static void targetbest_filter_stream_free(GtNodeStream *gs) { GtTargetbestFilterStream *tfs = targetbest_filter_stream_cast(gs); for (; tfs->next != NULL; tfs->next = gt_dlistelem_next(tfs->next)) gt_genome_node_delete(gt_dlistelem_get_data(tfs->next)); gt_dlist_delete(tfs->trees); gt_hashmap_delete(tfs->target_to_elem); gt_node_stream_delete(tfs->in_stream); }
static void gtf_in_stream_free(GtNodeStream *ns) { GtGTFInStream *gtf_in_stream = gtf_in_stream_cast(ns); gt_free(gtf_in_stream->filename); gt_type_checker_delete(gtf_in_stream->type_checker); while (gt_queue_size(gtf_in_stream->genome_node_buffer)) gt_genome_node_delete(gt_queue_get(gtf_in_stream->genome_node_buffer)); gt_queue_delete(gtf_in_stream->genome_node_buffer); }
void gt_orphanage_delete(GtOrphanage *o) { if (!o) return; gt_cstr_table_delete(o->orphan_ids); gt_cstr_table_delete(o->missing_parents); while (gt_queue_size(o->orphans)) gt_genome_node_delete(gt_queue_get(o->orphans)); gt_queue_delete(o->orphans); gt_free(o); }
void gt_rec_map_delete(GtRecMap *rm) { if (!rm) return; if (rm->reference_count) { rm->reference_count--; return; } gt_genome_node_delete((GtGenomeNode*) rm->fn); gt_free(rm); }
static int filter_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *error) { AgnFilterStream *stream; GtFeatureNode *fn; int had_err; gt_error_check(error); stream = filter_stream_cast(ns); if(gt_queue_size(stream->cache) > 0) { *gn = gt_queue_get(stream->cache); return 0; } while(1) { had_err = gt_node_stream_next(stream->in_stream, gn, error); if(had_err) return had_err; if(!*gn) return 0; fn = gt_feature_node_try_cast(*gn); if(!fn) return 0; GtFeatureNode *current; GtFeatureNodeIterator *iter = gt_feature_node_iterator_new(fn); for(current = gt_feature_node_iterator_next(iter); current != NULL; current = gt_feature_node_iterator_next(iter)) { const char *type = gt_feature_node_get_type(current); bool keepfeature = false; if(gt_hashmap_get(stream->typestokeep, type) != NULL) keepfeature = true; if(keepfeature) { gt_genome_node_ref((GtGenomeNode *)current); gt_queue_add(stream->cache, current); } } gt_feature_node_iterator_delete(iter); gt_genome_node_delete((GtGenomeNode *)fn); if(gt_queue_size(stream->cache) > 0) { *gn = gt_queue_get(stream->cache); return 0; } } return 0; }
static void gt_load_stream_free(GtNodeStream *ns) { unsigned long i; GtLoadStream *load_stream = gt_load_stream_cast(ns); for (i = load_stream->idx; i < gt_array_size(load_stream->nodes); i++) { gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(load_stream->nodes, i)); } gt_array_delete(load_stream->nodes); gt_node_stream_delete(load_stream->in_stream); }
static int gt_ltr_cluster_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err) { GtLTRClusterStream *lcs; GtGenomeNode *ref_gn; int had_err = 0; unsigned long i = 0; gt_error_check(err); lcs = gt_ltr_cluster_stream_cast(ns); if (lcs->first_next) { while (!(had_err = gt_node_stream_next(lcs->in_stream, gn, err)) && *gn) { gt_assert(*gn && !had_err); ref_gn = gt_genome_node_ref(*gn); gt_array_add(lcs->nodes, ref_gn); had_err = gt_genome_node_accept(*gn, (GtNodeVisitor*) lcs->lcv, err); if (had_err) { gt_genome_node_delete(*gn); *gn = NULL; break; } } lcs->feat_to_encseq = gt_ltr_cluster_prepare_seq_visitor_get_encseqs(lcs->lcv); lcs->feat_to_encseq_keys = gt_ltr_cluster_prepare_seq_visitor_get_features(lcs->lcv); if (!had_err) { for (i = 0; i < gt_str_array_size(lcs->feat_to_encseq_keys); i++) { had_err = process_feature(lcs, gt_str_array_get(lcs->feat_to_encseq_keys, i), err); if (had_err) break; } } if (!had_err) { *gn = *(GtGenomeNode**) gt_array_get(lcs->nodes, lcs->next_index); lcs->next_index++; lcs->first_next = false; return 0; } } else { if (lcs->next_index >= gt_array_size(lcs->nodes)) *gn = NULL; else { *gn = *(GtGenomeNode**) gt_array_get(lcs->nodes, lcs->next_index); lcs->next_index++; } return 0; } return had_err; }
static void snp_annotator_visitor_free(GtNodeVisitor *nv) { GtSNPAnnotatorVisitor *sav; if (!nv) return; sav = snp_annotator_visitor_cast(nv); gt_genome_node_delete((GtGenomeNode*) sav->gene); if (sav->own_tt) gt_trans_table_delete(sav->tt); gt_region_mapping_delete(sav->rmap); gt_hashmap_delete(sav->rnaseqs); }
static void feature_in_stream_free(GtNodeStream *ns) { GtFeatureInStream *stream = feature_in_stream_cast(ns); gt_str_array_delete(stream->seqids); while (gt_queue_size(stream->regioncache) > 0) { GtGenomeNode *gn = gt_queue_get(stream->regioncache); gt_genome_node_delete(gn); } gt_queue_delete(stream->regioncache); }
static void gt_ltr_cluster_stream_free(GtNodeStream *ns) { unsigned long i; GtLTRClusterStream *lcs = gt_ltr_cluster_stream_cast(ns); gt_node_visitor_delete((GtNodeVisitor*) lcs->lcv); gt_hashmap_delete(lcs->feat_to_encseq); gt_str_array_delete(lcs->feat_to_encseq_keys); for (i = 0; i < gt_array_size(lcs->nodes); i++) gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(lcs->nodes, i)); gt_array_delete(lcs->nodes); gt_node_stream_delete(lcs->in_stream); }
static void gff3_in_stream_plain_free(GtNodeStream *ns) { GtGFF3InStreamPlain *gff3_in_stream_plain = gff3_in_stream_plain_cast(ns); gt_str_array_delete(gff3_in_stream_plain->files); gt_str_delete(gff3_in_stream_plain->stdinstr); while (gt_queue_size(gff3_in_stream_plain->genome_node_buffer)) { gt_genome_node_delete(gt_queue_get(gff3_in_stream_plain ->genome_node_buffer)); } gt_queue_delete(gff3_in_stream_plain->genome_node_buffer); gt_gff3_parser_delete(gff3_in_stream_plain->gff3_parser); gt_cstr_table_delete(gff3_in_stream_plain->used_types); gt_file_delete(gff3_in_stream_plain->fpin); }
static int feature_node_lua_remove_leaf(lua_State *L) { GtGenomeNode **parent, **leaf; GtFeatureNode *pf, *lf; parent = check_genome_node(L, 1); leaf = check_genome_node(L, 2); pf = gt_feature_node_try_cast(*parent); luaL_argcheck(L, pf, 1, "not a feature node"); lf = gt_feature_node_try_cast(*leaf); luaL_argcheck(L, lf, 2, "not a feature node"); gt_feature_node_remove_leaf(pf, lf); gt_genome_node_delete((GtGenomeNode*) lf); return 0; }
static int delete_mRNAs(GT_UNUSED void *key, void *value, GT_UNUSED void *data, GT_UNUSED GtError *err) { GtArray *gt_genome_node_array = (GtArray*) value; GtUword i; gt_assert(key && value); for (i = 0; i < gt_array_size(gt_genome_node_array); i++) { GtGenomeNode *gn = *(GtGenomeNode**) gt_array_get(gt_genome_node_array, i); gt_genome_node_delete(gn); } return 0; }
static void chseqids_stream_free(GtNodeStream *gs) { GtChseqidsStream *cs; unsigned long i; cs = chseqids_stream_cast(gs); gt_mapping_delete(cs->chseqids_mapping); for (i = cs->buffer_index; i < gt_array_size(cs->gt_genome_node_buffer); i++) { gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(cs->gt_genome_node_buffer, i)); } gt_array_delete(cs->gt_genome_node_buffer); gt_node_stream_delete(cs->in_stream); }