void assemble_cluster(GthPGL *pgl, bool disableclustersas)
{
GthSACluster *sacluster;
GthSA *sa;
GtUword i;
sacluster = gt_malloc(sizeof (GthSACluster));
sacluster->representative = *(GthSA**) gt_array_get_first(pgl->alignments);
sacluster->members = gt_array_new(sizeof (GthSA*));
for (i = 1; i < gt_array_size(pgl->alignments); i++) {
sa = *(GthSA**) gt_array_get(pgl->alignments, i);
if (disableclustersas ||
gth_sa_cmp_genomic_actual(&sacluster->representative, &sa)) {
/* spliced alignments differ -> create a new cluster */
gt_array_add(pgl->saclusters, sacluster);
sacluster = gt_malloc(sizeof (GthSACluster));
sacluster->representative = sa;
sacluster->members = gt_array_new(sizeof (GthSA*));
}
else {
/* spliced alignments are equal -> store new sa also in current cluster */
gt_array_add(sacluster->members, sa);
}
}
/* store last cluster */
gt_array_add(pgl->saclusters, sacluster);
}
GtNodeStream* gt_snp_annotator_stream_new(GtNodeStream *gvf_stream,
GtNodeStream *gff_stream,
GtTransTable *trans_table,
GtRegionMapping *rmap)
{
GtSNPAnnotatorStream *sas;
GtNodeStream *ns;
gt_assert(gvf_stream && gff_stream && rmap);
ns = gt_node_stream_create(gt_snp_annotator_stream_class(), true);
sas = gt_snp_annotator_stream_cast(ns);
sas->instreams = gt_array_new(sizeof (GtNodeStream*));
(void) gt_node_stream_ref(gvf_stream);
gt_array_add(sas->instreams, gvf_stream);
(void) gt_node_stream_ref(gff_stream);
gt_array_add(sas->instreams, gff_stream);
sas->cur_gene_set = gt_array_new(sizeof (GtFeatureNode*));
sas->merge_stream = gt_merge_stream_new(sas->instreams);
sas->rmap = gt_region_mapping_ref(rmap);
sas->cur_gene_range.start =
sas->cur_gene_range.end = GT_UNDEF_UWORD;
sas->snps = gt_queue_new();
sas->outqueue = gt_queue_new();
sas->tt = trans_table;
return ns;
}
GtNodeVisitor* gt_gtf_visitor_new(GtFile *outfp)
{
GtNodeVisitor *nv = gt_node_visitor_create(gt_gtf_visitor_class());
GtGTFVisitor *gtf_visitor = gtf_visitor_cast(nv);
gtf_visitor->gene_id = 0;
gtf_visitor->exon_features = gt_array_new(sizeof (GtGenomeNode*));
gtf_visitor->CDS_features = gt_array_new(sizeof (GtGenomeNode*));
gtf_visitor->outfp = outfp;
return nv;
}
GthChain* gth_chain_new(void)
{
GthChain *chain = gt_calloc(1, sizeof *chain);
chain->gen_file_num = GT_UNDEF_ULONG;
chain->gen_seq_num = GT_UNDEF_ULONG;
chain->ref_file_num = GT_UNDEF_ULONG;
chain->ref_seq_num = GT_UNDEF_ULONG;
chain->forwardranges = gt_array_new(sizeof (GtRange));
chain->reverseranges = gt_array_new(sizeof (GtRange));
return chain;
}
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 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;
}
static GtArray* generic_ranges_uniq(GtArray *out_ranges,
const GtArray *in_ranges, bool count)
{
GtUword i, *ctr_ptr, ctr = 1;
GtArray *count_array = NULL;
GtRange cur = { GT_UNDEF_UWORD, GT_UNDEF_UWORD },
prev = { GT_UNDEF_UWORD, GT_UNDEF_UWORD };
gt_assert(out_ranges && in_ranges);
gt_assert(gt_ranges_are_sorted(in_ranges));
if (count)
count_array = gt_array_new(sizeof (GtUword));
for (i = 0; i < gt_array_size(in_ranges); i++) {
cur = *(GtRange*) gt_array_get(in_ranges, i);
if (!i) {
gt_array_add(out_ranges, cur);
if (count)
gt_array_add(count_array, ctr);
}
else {
if (prev.start == cur.start && prev.end == cur.end) {
if (count) {
ctr_ptr = gt_array_get_last(count_array);
(*ctr_ptr)++;
}
}
else {
gt_array_add(out_ranges, cur);
if (count)
gt_array_add(count_array, ctr);
}
}
prev = cur;
}
return count_array;
}
static GtArray *gaeval_visitor_union(GtArray *cov1, GtArray *cov2)
{
agn_assert(cov1 && cov2);
gt_array_add_array(cov1, cov2);
if(gt_array_size(cov1) > 1)
gt_array_sort(cov1, (GtCompare)gt_range_compare);
GtArray *runion = gt_array_new(sizeof(GtRange));
if(gt_array_size(cov1) == 0)
return runion;
GtRange *rng = gt_array_get(cov1, 0);
gt_array_add(runion, *rng);
GtRange *prev = gt_array_get(runion, 0);
if(gt_array_size(cov1) == 1)
return runion;
GtUword i;
for(i = 1; i < gt_array_size(cov1); i++)
{
rng = gt_array_get(cov1, i);
if(gt_range_overlap(rng, prev))
*prev = gt_range_join(rng, prev);
else
{
gt_array_add(runion, *rng);
prev = gt_array_get(runion, gt_array_size(runion) - 1);
}
}
return runion;
}
static bool chain_is_filled_and_consistent(GthChain *chain,
unsigned long gen_total_length,
unsigned long gen_offset)
{
GtArray *testranges;
/* check of file sequence numbers are defined */
if (chain->gen_file_num == GT_UNDEF_ULONG ||
chain->gen_seq_num == GT_UNDEF_ULONG ||
chain->ref_file_num == GT_UNDEF_ULONG ||
chain->ref_seq_num == GT_UNDEF_ULONG) {
return false;
}
if (!gt_ranges_are_consecutive(chain->forwardranges))
return false;
testranges = gt_array_new(sizeof (GtRange));
gt_ranges_copy_to_opposite_strand(testranges, chain->reverseranges,
gen_total_length, gen_offset);
if (!gt_ranges_are_equal(testranges, chain->forwardranges)) {
gt_array_delete(testranges);
return false;
}
gt_array_delete(testranges);
return true;
}
void gt_type_node_add_is_a_vertex(GtTypeNode *src, const GtTypeNode *dst)
{
gt_assert(src && dst);
if (!src->is_a_out_edges)
src->is_a_out_edges = gt_array_new(sizeof (GtTypeNode*));
gt_array_add(src->is_a_out_edges, dst);
}
void gt_type_node_part_of_add(GtTypeNode *type_node, const char *id)
{
gt_assert(type_node && id);
if (!type_node->part_of_list)
type_node->part_of_list = gt_array_new(sizeof (const char*));
gt_array_add(type_node->part_of_list, id);
}
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;
}
static void infer_cds_visitor_test_data(GtQueue *queue)
{
GtError *error = gt_error_new();
const char *file = "data/gff3/grape-codons.gff3";
GtNodeStream *gff3in = gt_gff3_in_stream_new_unsorted(1, &file);
gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)gff3in);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)gff3in);
GtLogger *logger = gt_logger_new(true, "", stderr);
GtNodeStream *icv_stream = agn_infer_cds_stream_new(gff3in, NULL, logger);
GtArray *feats = gt_array_new( sizeof(GtFeatureNode *) );
GtNodeStream *arraystream = gt_array_out_stream_new(icv_stream, feats, error);
int pullresult = gt_node_stream_pull(arraystream, error);
if(pullresult == -1)
{
fprintf(stderr, "[AgnInferCDSVisitor::infer_cds_visitor_test_data] error "
"processing features: %s\n", gt_error_get(error));
}
gt_node_stream_delete(gff3in);
gt_node_stream_delete(icv_stream);
gt_node_stream_delete(arraystream);
gt_logger_delete(logger);
gt_array_sort(feats, (GtCompare)agn_genome_node_compare);
gt_array_reverse(feats);
while(gt_array_size(feats) > 0)
{
GtFeatureNode *fn = *(GtFeatureNode **)gt_array_pop(feats);
gt_queue_add(queue, fn);
}
gt_array_delete(feats);
gt_error_delete(error);
}
static void potentialintronspostpro(GtArray *intronstoprocess,
unsigned long icdelta,
unsigned long icminremintronlength)
{
GtArray *originalintrons;
GtRange potintron;
unsigned long i, potintronlength,
minintronlength = 2 * icdelta + icminremintronlength;
originalintrons = gt_array_new(sizeof (GtRange));
/* save all (potential) introns */
gt_array_add_array(originalintrons, intronstoprocess);
/* reset introns to process */
gt_array_set_size(intronstoprocess, 0);
/* store introns */
for (i = 0; i < gt_array_size(originalintrons); i++) {
potintron = *(GtRange*) gt_array_get(originalintrons, i);
potintronlength = potintron.end - potintron.start + 1;
if (potintronlength >= minintronlength) {
/* keep this intron (plus/minus intron deltas)
that is, this intron is cut out later */
potintron.start += icdelta;
potintron.end -= icdelta;
gt_array_add(intronstoprocess, potintron);
}
/* else: skip this intron
that is, this intron is not cut out later */
}
gt_array_delete(originalintrons);
}
static int feature_index_lua_get_features_for_range(lua_State *L)
{
GtFeatureIndex **feature_index;
const char *seqid;
GtRange *range;
GtError *err;
bool has_seqid;
GtArray *features;
GT_UNUSED int had_err;
feature_index = check_feature_index(L, 1);
seqid = luaL_checkstring(L, 2);
err = gt_error_new();
if (gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err))
return gt_lua_error(L, err);
gt_error_delete(err);
luaL_argcheck(L, has_seqid, 2,
"feature_index does not contain seqid");
range = check_range(L, 3);
features = gt_array_new(sizeof (GtGenomeNode*));
err = gt_error_new();
had_err = gt_feature_index_get_features_for_range(*feature_index, features,
seqid, range, err);
if (had_err)
return gt_lua_error(L, err);
gt_error_delete(err);
push_features_as_table(L, features);
gt_array_delete(features);
return 1;
}
static void findmaximalscores_withoverlaps(GtChain *chain,
GtChaininfo *chaininfo,
GtFragment *fragments,
unsigned long num_of_fragments,
unsigned long max_gap_width,
unsigned long seqlen1,
double mincoverage,
GtChainProc chainprocessor,
void *cpinfo,
Overlapinfo *overlapinfo)
{
unsigned long i, startfrag;
GtArray *startfragments;
gt_assert(seqlen1 != GT_UNDEF_ULONG);
gt_assert(mincoverage != GT_UNDEF_DOUBLE);
startfragments = gt_array_new(sizeof (unsigned long));
/* compute chain array */
for (i = 0; i < num_of_fragments; i++) {
if (overlapinfo[i].active) {
/* current fragment is active */
if (overlapinfo[overlapinfo[i].startofchain].chainarray ==
UNDEFPREVIOUS) {
if (((double) overlapinfo[i].dim1lengthofchain / (double) seqlen1) >=
mincoverage) {
/* no other fragment has the same start fragment yet and coverage is
high enough -> store end fragment */
overlapinfo[overlapinfo[i].startofchain].chainarray = i;
/* since this is the first time, store start fragment number
to avoid additional scan of all fragments below */
gt_array_add(startfragments, overlapinfo[i].startofchain);
}
}
else if (overlapinfo[i].dim1lengthofchain >
overlapinfo[overlapinfo[overlapinfo[i].startofchain].chainarray]
.dim1lengthofchain) {
/* coverage is higher then coverage of earlier start fragment
-> update end fragment */
overlapinfo[overlapinfo[i].startofchain].chainarray = i;
}
}
}
/* retrieve maximal chains */
for (i = 0; i < gt_array_size(startfragments); i++) {
startfrag = *(unsigned long*) gt_array_get(startfragments, i);
gt_assert(overlapinfo[startfrag].chainarray != UNDEFPREVIOUS);
gt_chain_reset(chain);
gt_chain_set_score(chain,
chaininfo[overlapinfo[startfrag].chainarray].score);
retracepreviousinchain(chain, chaininfo, num_of_fragments,
overlapinfo[startfrag].chainarray);
chainprocessor(chain, fragments, num_of_fragments, max_gap_width, cpinfo);
}
gt_array_delete(startfragments);
}
Splicedseq* gt_splicedseq_new(void)
{
Splicedseq *ss = gt_malloc(sizeof (Splicedseq));
ss->splicedseq = gt_str_new();
ss->positionmapping = gt_array_new(sizeof (unsigned long));
ss->forward = true;
return ss;
}
static int m2i_change_target_seqids(GtFeatureNode *fn, const char *target,
GtRegionMapping *region_mapping,
GtError *err)
{
GtStrArray *target_ids;
GtArray *target_ranges, *target_strands;
GtStr *desc, *new_seqid;
unsigned long i;
int had_err;
gt_error_check(err);
gt_assert(fn && target && region_mapping);
target_ids = gt_str_array_new();
target_ranges = gt_array_new(sizeof (GtRange));
target_strands = gt_array_new(sizeof (GtStrand));
desc = gt_str_new();
new_seqid = gt_str_new();
had_err = gt_gff3_parser_parse_all_target_attributes(target, false,
target_ids,
target_ranges,
target_strands, "", 0,
err);
for (i = 0; !had_err && i < gt_str_array_size(target_ids); i++) {
GtStr *seqid;
gt_str_reset(desc);
gt_str_reset(new_seqid);
seqid = gt_str_array_get_str(target_ids, i);
had_err = gt_region_mapping_get_description(region_mapping, desc, seqid,
err);
if (!had_err)
gt_regular_seqid_save(new_seqid, desc);
gt_str_array_set(target_ids, i, new_seqid);
}
if (!had_err) {
GtStr *new_target = gt_str_new();
gt_gff3_parser_build_target_str(new_target, target_ids, target_ranges,
target_strands);
gt_feature_node_set_attribute(fn, GT_GFF_TARGET, gt_str_get(new_target));
gt_str_delete(new_target);
}
gt_str_delete(new_seqid);
gt_str_delete(desc);
gt_array_delete(target_strands);
gt_array_delete(target_ranges);
gt_str_array_delete(target_ids);
return had_err;
}
static AutomaticSequenceRegion* automatic_sequence_region_new(bool is_circular)
{
AutomaticSequenceRegion *auto_sr;
auto_sr = gt_malloc(sizeof (AutomaticSequenceRegion));
auto_sr->feature_nodes = gt_array_new(sizeof (GtFeatureNode*));
auto_sr->is_circular = is_circular;
return auto_sr;
}
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;
}
static GtPBSResults* gt_pbs_results_new(GtLTRElement *elem,
GtPBSOptions *opts)
{
GtPBSResults *res = gt_calloc(1, sizeof (GtPBSResults));
res->elem = elem;
res->opts = opts;
res->hits = gt_array_new(sizeof (GtPBSHit*));
return res;
}
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 inverted_chain_init(GthInvertedChain *inverted_chain)
{
inverted_chain->gen_file_num = GT_UNDEF_ULONG;
inverted_chain->gen_seq_num = GT_UNDEF_ULONG;
inverted_chain->ref_file_num = GT_UNDEF_ULONG;
inverted_chain->ref_seq_num = GT_UNDEF_ULONG;
inverted_chain->startpos = GT_UNDEF_ULONG;
inverted_chain->endpos = GT_UNDEF_ULONG;
inverted_chain->forwardranges = gt_array_new(sizeof (GtRange));
}
static GtFeatureNodeIterator* feature_node_iterator_new_base(const GtFeatureNode
*fn)
{
GtFeatureNodeIterator *fni;
gt_assert(fn);
fni = gt_malloc(sizeof *fni);
fni->fn = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) fn);
fni->feature_stack = gt_array_new(sizeof (GtFeatureNode*));
return fni;
}
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;
}
GtBlock* gt_block_new(void)
{
GtBlock *block = gt_calloc(1, sizeof (GtBlock));
block->elements = gt_array_new(sizeof (GtElement*));
block->caption = NULL;
block->show_caption = true;
block->sorted = false;
block->strand = GT_STRAND_UNKNOWN;
block->top_level_feature = NULL;
return block;
}
GtNodeStream* gt_sort_stream_new(GtNodeStream *in_stream)
{
GtNodeStream *ns = gt_node_stream_create(gt_sort_stream_class(), true);
GtSortStream *sort_stream = gt_sort_stream_cast(ns);
gt_assert(in_stream);
sort_stream->in_stream = gt_node_stream_ref(in_stream);
sort_stream->sorted = false;
sort_stream->idx = 0;
sort_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
return ns;
}
GtNodeStream* gt_load_stream_new(GtNodeStream *in_stream)
{
GtNodeStream *ns = gt_node_stream_create(gt_load_stream_class(), true);
GtLoadStream *load_stream = gt_load_stream_cast(ns);
gt_assert(in_stream);
load_stream->in_stream = gt_node_stream_ref(in_stream);
load_stream->full = false;
load_stream->idx = 0;
load_stream->nodes = gt_array_new(sizeof (GtGenomeNode*));
return ns;
}
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 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;
}
