void gth_backtrace_path_add_mismatch_with_2_gaps(GthBacktracePath *bp) { Editoperation mismatch_with_2_gaps_eop = MISMATCH_WITH_2_GAPS_EOP; gt_assert(bp); gt_assert(bp->alphatype == PROTEIN_ALPHA); gt_assert(bp->max_identical_length == MAXIDENTICALLENGTH_PROTEIN); gt_array_add(bp->editoperations, mismatch_with_2_gaps_eop); }
void gth_backtrace_path_add_deletion_with_1_gap(GthBacktracePath *bp) { Editoperation deletion_with_1_gap_eop = DELETION_WITH_1_GAP_EOP; gt_assert(bp); gt_assert(bp->alphatype == PROTEIN_ALPHA); gt_assert(bp->max_identical_length == MAXIDENTICALLENGTH_PROTEIN); gt_array_add(bp->editoperations, deletion_with_1_gap_eop); }
void* gt_class_alloc(size_t size) { void *c_class; if (!c_classes) c_classes = gt_array_new(sizeof (void*)); c_class = gt_calloc(1, size); gt_array_add(c_classes, c_class); return c_class; }
void gth_backtrace_path_add_intron(GthBacktracePath *bp) { Editoperation *eopptr, intron_eop = DELETIONEOP + 1; unsigned long eopid, lenid; gt_assert(bp); gt_assert(bp->alphatype == DNA_ALPHA || bp->alphatype == PROTEIN_ALPHA); if (!gt_array_size(bp->editoperations)) gt_array_add(bp->editoperations, intron_eop); else { eopptr = gt_array_get_last(bp->editoperations); eopid = *eopptr & ~bp->max_identical_length; lenid = *eopptr & bp->max_identical_length; if (eopid == DELETIONEOP && lenid > 0 && lenid < bp->max_identical_length) (*eopptr)++; else gt_array_add(bp->editoperations, intron_eop); } }
static int storemaxmatchself(void *info, GT_UNUSED const GtEncseq *encseq, GtUword len, GtUword pos1, GtUword pos2, GT_UNUSED GtError *err) { Maxmatchselfinfo *maxmatchselfinfo = (Maxmatchselfinfo *) info; GtUword dbstart, querystart; if (pos1 < pos2) { dbstart = pos1; querystart = pos2; } else { dbstart = pos2; querystart = pos1; } if (dbstart < maxmatchselfinfo->dblen && maxmatchselfinfo->dblen < querystart) { Substringmatch subm; GtUword pos; subm.len = len; subm.dbstart = dbstart; pos = querystart - (maxmatchselfinfo->dblen + 1); if (maxmatchselfinfo->querymarkpos == NULL) { subm.queryseqnum = 0; subm.querystart = pos; } else { GtUword queryseqnum = gt_encseq_sep2seqnum(maxmatchselfinfo->querymarkpos, maxmatchselfinfo->numofquerysequences, maxmatchselfinfo->querylen, pos); if (queryseqnum == maxmatchselfinfo->numofquerysequences) { return -1; } if (queryseqnum == 0) { subm.querystart = pos; } else { subm.querystart = pos - (maxmatchselfinfo->querymarkpos[queryseqnum-1] + 1); } subm.queryseqnum = (uint64_t) queryseqnum; } gt_array_add(maxmatchselfinfo->results,subm); } return 0; }
static int save_sequence_region(GT_UNUSED void *key, void *value, void *data, GT_UNUSED GtError *err) { GtGenomeNode *sr = value; GtArray *nodes = data; gt_error_check(err); gt_assert(sr && nodes); gt_array_add(nodes, sr); return 0; }
void gth_backtrace_path_add_match(GthBacktracePath *bp, bool ensure_single_match) { Editoperation *eopptr, match_eop = 1; unsigned long eopid, lenid; gt_assert(bp); gt_assert(bp->alphatype == DNA_ALPHA || bp->alphatype == PROTEIN_ALPHA); if (!gt_array_size(bp->editoperations) || ensure_single_match) gt_array_add(bp->editoperations, match_eop); else { eopptr = gt_array_get_last(bp->editoperations); eopid = *eopptr & ~bp->max_identical_length; lenid = *eopptr & bp->max_identical_length; if (eopid == 0 && lenid > 0 && lenid < bp->max_identical_length) (*eopptr)++; else gt_array_add(bp->editoperations, match_eop); } }
void gth_backtrace_path_add_dummy(GthBacktracePath *bp) { Editoperation dummy_eop = DUMMY_EOP; gt_assert(bp); gt_assert(bp->alphatype == PROTEIN_ALPHA); gt_assert(bp->max_identical_length == MAXIDENTICALLENGTH_PROTEIN); gt_assert(bp->dummy_index == GT_UNDEF_ULONG); gt_array_add(bp->editoperations, dummy_eop); bp->dummy_index = gt_array_size(bp->editoperations) - 1; }
void gt_csa_splice_form_add_sa(GtCSASpliceForm *splice_form, void *spliced_alignment) { gt_assert(splice_form); gt_assert(csa_splice_form_start(splice_form) <= splice_form->get_genomic_range(spliced_alignment).start); gt_assert(gt_csa_splice_form_strand(splice_form) == splice_form->get_strand(spliced_alignment)); gt_array_add(splice_form->spliced_alignments, spliced_alignment); }
static void obo_header_add(OBOHeader *obo_header, const char *tag, const char *value) { OBOHeaderEntry *entry; gt_assert(obo_header && tag && value); entry = gt_malloc(sizeof *entry); entry->tag = gt_cstr_dup(tag); entry->value = gt_cstr_dup(value); gt_array_add(obo_header->content, entry); }
static void add_tool_to_stack(const char *name, GtTool *tool, void *data) { ToolIterationInfo *ti_info = data; ToolEntry entry; gt_assert(name && tool && data); entry.name = name; entry.tool = tool; entry.prefix = gt_str_ref(ti_info->str); gt_array_add(ti_info->arr, entry); }
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 GtArray* gaeval_visitor_intersect(GtGenomeNode *genemodel, GtGenomeNode *alignment) { agn_assert(genemodel && alignment); GtFeatureNode *genefn = gt_feature_node_cast(genemodel); GtFeatureNode *algnfn = gt_feature_node_cast(alignment); agn_assert(gt_feature_node_has_type(genefn, "mRNA")); GtStrand genestrand = gt_feature_node_get_strand(genefn); GtStrand algnstrand = gt_feature_node_get_strand(algnfn); if(genestrand != algnstrand) return NULL; GtArray *covered_parts = gt_array_new( sizeof(GtRange) ); GtArray *exons = agn_typecheck_select(genefn, agn_typecheck_exon); GtWord i; for(i = 0; i < gt_array_size(exons); i++) { GtGenomeNode *exon = *(GtGenomeNode **)gt_array_get(exons, i); GtRange exonrange = gt_genome_node_get_range(exon); GtFeatureNodeIterator *aniter = gt_feature_node_iterator_new(algnfn); GtFeatureNode *tempaln; GtRange nullrange = {0, 0}; for(tempaln = gt_feature_node_iterator_next(aniter); tempaln != NULL; tempaln = gt_feature_node_iterator_next(aniter)) { if(gt_feature_node_has_type(tempaln, "match_gap")) continue; GtRange alnrange = gt_genome_node_get_range((GtGenomeNode *) tempaln); GtRange intr = gaeval_visitor_range_intersect(&exonrange, &alnrange); if(gt_range_compare(&intr, &nullrange) != 0) gt_array_add(covered_parts, intr); } gt_feature_node_iterator_delete(aniter); } gt_array_delete(exons); for(i = 0; i < gt_array_size(covered_parts); i++) { GtRange *r1 = gt_array_get(covered_parts, i); GtUword j; for(j = i+1; j < gt_array_size(covered_parts); j++) { GtRange *r2 = gt_array_get(covered_parts, j); agn_assert(gt_range_overlap(r1, r2) == false); } } return covered_parts; }
void agn_transcript_structure_gbk(GtFeatureNode *transcript, FILE *outstream) { gt_assert(transcript && outstream); GtArray *exons = gt_array_new( sizeof(GtFeatureNode *) ); GtFeatureNodeIterator *iter = gt_feature_node_iterator_new_direct(transcript); GtFeatureNode *child; for ( child = gt_feature_node_iterator_next(iter); child != NULL; child = gt_feature_node_iterator_next(iter) ) { if(agn_gt_feature_node_is_exon_feature(child)) gt_array_add(exons, child); } gt_feature_node_iterator_delete(iter); gt_assert(gt_array_size(exons) > 0); gt_array_sort(exons, (GtCompare)agn_gt_genome_node_compare); if(gt_feature_node_get_strand(transcript) == GT_STRAND_REVERSE) fputs("complement(", outstream); if(gt_array_size(exons) == 1) { GtGenomeNode *exon = *(GtGenomeNode **)gt_array_get(exons, 0); GtRange exonrange = gt_genome_node_get_range(exon); fprintf(outstream, "<%lu..>%lu", exonrange.start, exonrange.end); } else { fputs("join(", outstream); GtUword i; for(i = 0; i < gt_array_size(exons); i++) { GtGenomeNode *exon = *(GtGenomeNode **)gt_array_get(exons, i); GtRange exonrange = gt_genome_node_get_range(exon); if(i == 0) fprintf(outstream, "<%lu..%lu", exonrange.start, exonrange.end); else if(i+1 == gt_array_size(exons)) fprintf(outstream, ",%lu..>%lu", exonrange.start, exonrange.end); else fprintf(outstream, ",%lu..%lu", exonrange.start, exonrange.end); } fputs(")", outstream); } if(gt_feature_node_get_strand(transcript) == GT_STRAND_REVERSE) fputs(")", outstream); }
GtFeatureNodeIterator* gt_feature_node_iterator_new(const GtFeatureNode *fn) { GtFeatureNodeIterator *fni; GtFeatureNode *child_feature; GtDlistelem *dlistelem; gt_assert(fn); fni = feature_node_iterator_new_base(fn); if (gt_feature_node_is_pseudo((GtFeatureNode*) fn)) { /* add the children backwards to traverse in order */ for (dlistelem = gt_dlist_last(fn->children); dlistelem != NULL; dlistelem = gt_dlistelem_previous(dlistelem)) { child_feature = (GtFeatureNode*) gt_dlistelem_get_data(dlistelem); gt_array_add(fni->feature_stack, child_feature); } } else gt_array_add(fni->feature_stack, fni->fn); gt_assert(gt_array_size(fni->feature_stack)); fni->direct = false; return fni; }
static GtArray* make_list_of_chain_fragments(GtChain *chain, GtFragment *fragments, unsigned long num_of_fragments, bool enrichchains, const GtRange *genomicrange) { unsigned long i, fragnum; GtArray *chain_fragments; GthJTMatch match; gt_assert(chain && fragments && num_of_fragments); chain_fragments = gt_array_new(sizeof (GthJTMatch)); if (!enrichchains) { /* no chain enrichment used -> store all fragments from chain */ for (i = 0; i < gt_chain_size(chain); i++) { fragnum = gt_chain_get_fragnum(chain, i); match.gen_range.start = fragments[fragnum].startpos2; match.gen_range.end = fragments[fragnum].endpos2; match.ref_range.start = fragments[fragnum].startpos1; match.ref_range.end = fragments[fragnum].endpos1; gt_array_add(chain_fragments, match); } } else { GtRange fragmentrange; /* chain enrichment used -> store all fragments which overlap with genomic range of computed chain */ for (i = 0; i < num_of_fragments; i++) { fragmentrange.start = fragments[i].startpos2; fragmentrange.end = fragments[i].endpos2; if (gt_range_overlap(genomicrange, &fragmentrange)) { match.gen_range.start = fragments[i].startpos2; match.gen_range.end = fragments[i].endpos2; match.ref_range.start = fragments[i].startpos1; match.ref_range.end = fragments[i].endpos1; gt_array_add(chain_fragments, match); } } } return chain_fragments; }
static int gt_ltrdigest_pdom_visitor_process_hit(GT_UNUSED void *key, void *val, void *data, GT_UNUSED GtError *err) { GtHMMERModelHit *mh = (GtHMMERModelHit*) val; GtLTRdigestPdomVisitor *lv = (GtLTRdigestPdomVisitor*) data; const char *mdl = (const char*) key; GtArray *hits = NULL; GtUword nof_hits; GtFragment *frags; if (gt_double_compare(mh->best_fwd, mh->best_rev) <= 0) hits = mh->fwd_hits; else hits = mh->rev_hits; gt_assert(hits); nof_hits = gt_array_size(hits); if (nof_hits == 0) return 0; if (nof_hits > 1UL) { GtUword i, chainno; frags = gt_malloc((size_t) nof_hits * sizeof (GtFragment)); for (i = 0; i < nof_hits; i++) { GtHMMERSingleHit *h = *(GtHMMERSingleHit**) gt_array_get(hits, i); gt_assert(h); frags[i].startpos1 = h->hmmfrom; frags[i].endpos1 = h->hmmto; frags[i].startpos2 = h->alifrom; frags[i].endpos2 = h->alito; frags[i].weight = (GtWord) (h->alito - h->alifrom + 1) * h->score; frags[i].data = h; } qsort(frags, (size_t) nof_hits, sizeof (GtFragment), gt_ltrdigest_pdom_visitor_fragcmp); gt_log_log("%s: chaining "GT_WU" frags", mdl, nof_hits); gt_globalchaining_max(frags, nof_hits, (GtUword) lv->chain_max_gap_length, gt_ltrdigest_pdom_visitor_chainproc, &chainno); gt_free(frags); for (i = 0; i < nof_hits; i++) { GtHMMERSingleHit *h = *(GtHMMERSingleHit**) gt_array_get(hits, i); (void) gt_ltrdigest_pdom_visitor_attach_hit(lv, mh, h); } } else { GtUword chainno = 0UL; GtHMMERSingleHit *h = *(GtHMMERSingleHit**) gt_array_get(hits, 0); gt_array_add(h->chains, chainno); (void) gt_ltrdigest_pdom_visitor_attach_hit(lv, mh, h); } return 0; }
static void infer_cds_visitor_check_stop(AgnInferCDSVisitor *v) { if(gt_array_size(v->cds) == 0) return; const char *mrnaid = gt_feature_node_get_attribute(v->mrna, "ID"); unsigned int ln = gt_genome_node_get_line_number((GtGenomeNode *)v->mrna); GtStrand strand = gt_feature_node_get_strand(v->mrna); GtRange stoprange; GtUword threeprimeindex = gt_array_size(v->cds) - 1; GtGenomeNode **threeprimesegment = gt_array_get(v->cds, threeprimeindex); stoprange = gt_genome_node_get_range(*threeprimesegment); stoprange.start = stoprange.end - 2; if(strand == GT_STRAND_REVERSE) { threeprimesegment = gt_array_get(v->cds, 0); stoprange = gt_genome_node_get_range(*threeprimesegment); stoprange.end = stoprange.start + 2; } if(gt_array_size(v->stops) > 1) { gt_logger_log(v->logger, "mRNA '%s' (line %u) has %lu stop codons", mrnaid, ln, gt_array_size(v->starts)); } else if(gt_array_size(v->stops) == 1) { GtGenomeNode **codon = gt_array_get(v->stops, 0); GtRange testrange = gt_genome_node_get_range(*codon); if(gt_range_compare(&stoprange, &testrange) != 0) { gt_logger_log(v->logger, "stop codon inferred from CDS [%lu, %lu] does " "not match explicitly provided stop codon [%lu, %lu] for " "mRNA '%s'", stoprange.start, stoprange.end, testrange.start, testrange.end, mrnaid); } } else // agn_assert(gt_array_size(v->stops) == 0) { GtStr *seqid = gt_genome_node_get_seqid((GtGenomeNode *)v->mrna); GtGenomeNode *codonfeature = gt_feature_node_new(seqid, "stop_codon", stoprange.start, stoprange.end, strand); if(v->source) gt_feature_node_set_source((GtFeatureNode *)codonfeature, v->source); GtFeatureNode *cf = (GtFeatureNode *)codonfeature; gt_feature_node_add_child(v->mrna, cf); gt_array_add(v->stops, cf); } }
static void infer_cds_visitor_infer_cds(AgnInferCDSVisitor *v) { GtFeatureNode **start_codon = NULL, **stop_codon = NULL; bool exonsexplicit = gt_array_size(v->exons) > 0; bool startcodon_check = gt_array_size(v->starts) == 1 && (start_codon = gt_array_get(v->starts, 0)) != NULL; bool stopcodon_check = gt_array_size(v->stops) == 1 && (stop_codon = gt_array_get(v->stops, 0)) != NULL; if(gt_array_size(v->cds) > 0) { return; } else if(!exonsexplicit || !startcodon_check || !stopcodon_check) { return; } GtRange left_codon_range, right_codon_range; left_codon_range = gt_genome_node_get_range(*(GtGenomeNode **)start_codon); right_codon_range = gt_genome_node_get_range(*(GtGenomeNode **)stop_codon); if(gt_feature_node_get_strand(v->mrna) == GT_STRAND_REVERSE) { left_codon_range = gt_genome_node_get_range(*(GtGenomeNode **)stop_codon); right_codon_range = gt_genome_node_get_range(*(GtGenomeNode **)start_codon); } GtUword i; for(i = 0; i < gt_array_size(v->exons); i++) { GtFeatureNode *exon = *(GtFeatureNode **)gt_array_get(v->exons, i); GtGenomeNode *exon_gn = (GtGenomeNode *)exon; GtRange exon_range = gt_genome_node_get_range(exon_gn); GtStrand exon_strand = gt_feature_node_get_strand(exon); GtRange cdsrange; bool exon_includes_cds = infer_cds_visitor_infer_range(&exon_range, &left_codon_range, &right_codon_range, &cdsrange); if(exon_includes_cds) { GtGenomeNode *cdsfeat; cdsfeat = gt_feature_node_new(gt_genome_node_get_seqid(exon_gn), "CDS", cdsrange.start, cdsrange.end, exon_strand); if(v->source) gt_feature_node_set_source((GtFeatureNode *)cdsfeat, v->source); gt_feature_node_add_child(v->mrna, (GtFeatureNode *)cdsfeat); gt_array_add(v->cds, cdsfeat); } } }
static void add_children_to_stack(GtArray *feature_stack, const GtFeatureNode *fn) { GtFeatureNode *child; GtDlistelem *dlistelem; gt_assert(feature_stack && fn && fn->children); /* add the children backwards to traverse in order */ for (dlistelem = gt_dlist_last(fn->children); dlistelem != NULL; dlistelem = gt_dlistelem_previous(dlistelem)) { child = gt_dlistelem_get_data(dlistelem); gt_array_add(feature_stack, child); } }
void gt_splicedseq_add(Splicedseq *ss, unsigned long start, unsigned long end, const char *original_sequence) { unsigned long i; gt_assert(ss && start <= end && original_sequence); gt_str_append_cstr_nt(ss->splicedseq, original_sequence, end - start + 1); /* make sure elements are added in ascending order */ gt_assert(!gt_array_size(ss->positionmapping) || start > *(unsigned long*) gt_array_get_last(ss->positionmapping)); for (i = start; i <= end; i++) gt_array_add(ss->positionmapping, i); }
static SeqidInfo* seqid_info_new(GtUword seqnum, GtUword filenum, const GtRange *descrange) { SeqidInfoElem seqid_info_elem; GtArray *seqid_info; gt_assert(descrange); seqid_info = gt_array_new(sizeof (SeqidInfoElem)); seqid_info_elem.seqnum = seqnum; seqid_info_elem.filenum = filenum; seqid_info_elem.descrange = *descrange; gt_array_add(seqid_info, seqid_info_elem); return seqid_info; }
int checkspecialrangesfast(const Encodedsequence *encseq) { GtArray *rangesforward, *rangesbackward; bool haserr = false; Specialrangeiterator *sri; Sequencerange range; if (!hasspecialranges(encseq)) { return 0; } rangesforward = gt_array_new(sizeof (Sequencerange)); rangesbackward = gt_array_new(sizeof (Sequencerange)); sri = newspecialrangeiterator(encseq,true); while (nextspecialrangeiterator(&range,sri)) { gt_array_add(rangesforward,range); } freespecialrangeiterator(&sri); sri = newspecialrangeiterator(encseq,false); while (nextspecialrangeiterator(&range,sri)) { gt_array_add(rangesbackward,range); } freespecialrangeiterator(&sri); gt_array_reverse(rangesbackward); if (!haserr) { if (array_compare(rangesforward,rangesbackward, compareSequencerange) != 0) { exit(GT_EXIT_PROGRAMMING_ERROR); } } gt_array_delete(rangesforward); gt_array_delete(rangesbackward); return haserr ? - 1 : 0; }
GtCSASpliceForm* gt_csa_splice_form_new(void *spliced_alignment, GetGenomicRangeFunc get_genomic_range, GetStrandFunc get_strand) { GtCSASpliceForm *splice_form; gt_assert(spliced_alignment && get_strand); splice_form = gt_malloc(sizeof (*splice_form)); splice_form->spliced_alignments = gt_array_new(sizeof (void*)); gt_array_add(splice_form->spliced_alignments, spliced_alignment); splice_form->get_genomic_range = get_genomic_range; splice_form->get_strand = get_strand; return splice_form; }
void gth_backtrace_path_add_intron_with_2_bases_left(GthBacktracePath *bp) { Editoperation *eopptr, intron_with_2_bases_left_eop = DELETION_WITH_2_GAPS_EOP + 1; unsigned long eopid, lenid; gt_assert(bp); gt_assert(bp->alphatype == PROTEIN_ALPHA); gt_assert(bp->max_identical_length == MAXIDENTICALLENGTH_PROTEIN); if (!gt_array_size(bp->editoperations)) gt_array_add(bp->editoperations, intron_with_2_bases_left_eop); else { eopptr = gt_array_get_last(bp->editoperations); eopid = *eopptr & ~bp->max_identical_length; lenid = *eopptr & bp->max_identical_length; if (eopid == DELETION_WITH_2_GAPS_EOP && lenid > 0 && lenid < bp->max_identical_length) { (*eopptr)++; } else gt_array_add(bp->editoperations, intron_with_2_bases_left_eop); } }
GtArray* agn_enumerate_feature_cliques(GtArray *feature_set) { GtArray *cliques = gt_array_new( sizeof(GtArray *) ); if(gt_array_size(feature_set) == 1) { GtFeatureNode *fn = *(GtFeatureNode **)gt_array_get(feature_set, 0); AgnTranscriptClique *clique = agn_transcript_clique_new(); agn_transcript_clique_add(clique, fn); gt_array_add(cliques, clique); } else { // First add each transcript as a clique, even if it is not a maximal clique GtUword i; for(i = 0; i < gt_array_size(feature_set); i++) { GtFeatureNode *fn = *(GtFeatureNode **)gt_array_get(feature_set, i); AgnTranscriptClique *clique = agn_transcript_clique_new(); agn_transcript_clique_add(clique, fn); gt_array_add(cliques, clique); } // Then use the Bron-Kerbosch algorithm to find all maximal cliques // containing >1 transcript GtArray *R = gt_array_new( sizeof(GtGenomeNode *) ); GtArray *P = agn_gt_array_copy(feature_set, sizeof(GtGenomeNode *)); GtArray *X = gt_array_new( sizeof(GtGenomeNode *) ); // Initial call: agn_bron_kerbosch(\emptyset, vertex_set, \emptyset ) agn_bron_kerbosch(R, P, X, cliques, true); gt_array_delete(R); gt_array_delete(P); gt_array_delete(X); } return cliques; }
void gth_sa_get_exons(const GthSA *sa, GtArray *ranges) { Exoninfo *exoninfo; GtUword i; GtRange range; gt_assert(sa && ranges); for (i = 0; i < gt_array_size(sa->exons); i++) { exoninfo = gt_array_get(sa->exons, i); range.start = exoninfo->leftgenomicexonborder; range.end = exoninfo->rightgenomicexonborder; gt_array_add(ranges, range); } }
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; }
void gt_block_insert_element(GtBlock *block, GtFeatureNode *node) { GtElement *element; gt_assert(block && node); if (!block->top_level_feature) { block->top_level_feature = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) node); } element = gt_element_new(node); /* invalidate sortedness flag because insertion of element at the end may break ordering */ block->sorted = false; gt_array_add(block->elements, element); }
void gt_block_merge(GtBlock *b1, GtBlock *b2) { unsigned int GT_UNUSED merged_size, i; gt_assert(b1 && b2); merged_size = gt_block_get_size(b1) + gt_block_get_size(b2); for (i=0;i<gt_array_size(b2->elements);i++) { GtElement *elem; elem = gt_element_ref(*(GtElement**) gt_array_get(b2->elements, i)); gt_assert(elem); gt_array_add(b1->elements, elem); } gt_assert(gt_block_get_size(b1) == merged_size); }