GtNodeStream* gt_dot_out_stream_new(GtNodeStream *in_stream)
{
GtNodeVisitor *nv;
gt_assert(in_stream);
nv = gt_dot_visitor_new();
return gt_visitor_stream_new(in_stream, nv);
}
GtNodeStream *agn_gaeval_stream_new(GtNodeStream *in, GtNodeStream *astream,
AgnGaevalParams gparams)
{
GtNodeVisitor *nv = agn_gaeval_visitor_new(astream, gparams);
GtNodeStream *ns = gt_visitor_stream_new(in, nv);
return ns;
}
static int gt_seqids_runner(GT_UNUSED int argc, const char **argv,
int parsed_args,
GT_UNUSED void *tool_arguments, GtError *err)
{
GtNodeStream *in_stream, *v_stream;
GtCstrTable *cst;
int had_err = 0;
gt_error_check(err);
cst = gt_cstr_table_new();
in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
argv + parsed_args);
v_stream = gt_visitor_stream_new(in_stream, gt_collect_ids_visitor_new(cst));
had_err = gt_node_stream_pull(v_stream, err);
if (!had_err) {
GtStrArray *seqids;
GtUword i;
seqids = gt_cstr_table_get_all(cst);
for (i = 0; i < gt_str_array_size(seqids); i++) {
printf("%s\n", gt_str_array_get(seqids, i));
}
gt_str_array_delete(seqids);
}
gt_node_stream_delete(v_stream);
gt_node_stream_delete(in_stream);
gt_cstr_table_delete(cst);
return had_err;
}
GtNodeStream* agn_infer_cds_stream_new(GtNodeStream *in, GtStr *source,
GtLogger *logger)
{
GtNodeVisitor *nv = agn_infer_cds_visitor_new(logger);
if(source != NULL)
agn_infer_cds_visitor_set_source((AgnInferCDSVisitor *)nv, source);
GtNodeStream *ns = gt_visitor_stream_new(in, nv);
return ns;
}
GtNodeStream* gt_ltrharvest_fasta_out_stream_new(GtNodeStream *in_stream,
bool inner,
const GtEncseq *encseq,
GtUword width,
GtFile *outfp)
{
GtNodeVisitor *nv;
nv = gt_ltrharvest_fasta_out_visitor_new(encseq, inner, width, outfp);
return gt_visitor_stream_new(in_stream, nv);
}
GtNodeStream* gt_extract_feature_stream_new(GtNodeStream *in_stream,
GtRegionMapping *rm,
const char *type, bool join,
bool translate, bool seqid,
bool target, unsigned long width,
GtFile *outfp)
{
GtNodeVisitor *nv = gt_extract_feature_visitor_new(rm, type, join, translate,
seqid, target, width,
outfp);
return gt_visitor_stream_new(in_stream, nv);
}
GtNodeStream* gt_cds_stream_new(GtNodeStream *in_stream, GtRegionMapping *rm,
unsigned int minorflen, const char *source,
bool start_codon, bool final_stop_codon,
bool generic_start_codons)
{
GtNodeVisitor *nv;
GtStr *source_str;
source_str = gt_str_new_cstr(source);
nv = gt_cds_visitor_new(rm, minorflen, source_str, start_codon,
final_stop_codon, generic_start_codons);
gt_str_delete(source_str);
return gt_visitor_stream_new(in_stream, nv);
}
GtNodeStream* gt_gff3_in_stream_new_sorted(const char *filename)
{
GtNodeStream *ns = gt_node_stream_create(gt_gff3_in_stream_class(), true);
GtGFF3InStream *is = gff3_in_stream_cast(ns);
is->fix_region_stream = NULL;
is->last_stream = is->gff3_in_stream_plain =
gt_gff3_in_stream_plain_new_sorted(filename);
gt_gff3_in_stream_plain_check_region_boundaries(
(GtGFF3InStreamPlain*) is->gff3_in_stream_plain);
is->last_stream = is->add_ids_stream = gt_add_ids_stream_new(is->last_stream);
is->last_stream = is->multi_sanitize_stream =
gt_visitor_stream_new(is->last_stream, gt_multi_sanitizer_visitor_new());
is->last_stream = is->cds_check_stream =
gt_cds_check_stream_new(is->last_stream);
return ns;
}
static int gt_speck_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL,
*a_in_stream = NULL, *a_out_stream = NULL,
*feature_stream = NULL, *sort_stream = NULL,
*last_stream = NULL;
GtNodeVisitor *spec_visitor = NULL;
GtSpecResults *res = NULL;
GtFeatureIndex *fi = NULL;
GtTimer *t = NULL;
GtRegionMapping *rm = NULL;
GtArray *arr = gt_array_new(sizeof (GtFeatureNode*));
SpeccheckArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
res = gt_spec_results_new();
gt_assert(res);
t = gt_timer_new();
gt_assert(t);
spec_visitor = gt_spec_visitor_new(gt_str_get(arguments->specfile), res,
err);
if (!spec_visitor)
return -1;
/* add region mapping if given */
if (gt_seqid2file_option_used(arguments->s2fi)) {
rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
if (!rm)
had_err = -1;
if (!had_err)
gt_spec_visitor_add_region_mapping((GtSpecVisitor*) spec_visitor, rm);
}
/* set runtime error behaviour */
if (arguments->fail_hard)
gt_spec_visitor_fail_on_runtime_error((GtSpecVisitor*) spec_visitor);
else
gt_spec_visitor_report_runtime_errors((GtSpecVisitor*) spec_visitor);
/* redirect warnings */
gt_warning_set_handler(gt_speck_record_warning, res);
last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted(
argc - parsed_args,
argv + parsed_args);
gt_assert(gff3_in_stream);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream);
/* insert sort stream if requested */
if (arguments->sort) {
last_stream = sort_stream = gt_sort_stream_new(last_stream);
}
/* if -provideindex is given, collect input features and index them first */
if (arguments->provideindex) {
fi = gt_feature_index_memory_new();
gt_assert(fi);
last_stream = feature_stream = gt_feature_stream_new(last_stream, fi);
gt_assert(feature_stream);
last_stream = a_out_stream = gt_array_out_stream_all_new(last_stream, arr,
err);
if (!a_out_stream)
had_err = -1;
gt_timer_start(t);
if (!had_err)
had_err = gt_node_stream_pull(last_stream, err);
if (!had_err) {
gt_spec_visitor_add_feature_index((GtSpecVisitor*) spec_visitor,
gt_feature_index_ref(fi));
last_stream = a_in_stream = gt_array_in_stream_new(arr, NULL, err);
if (!a_in_stream)
had_err = -1;
}
} else {
gt_timer_start(t);
}
if (!had_err) {
checker_stream = gt_visitor_stream_new(last_stream, spec_visitor);
gt_assert(checker_stream);
}
/* perform checking */
if (!had_err)
had_err = gt_node_stream_pull(checker_stream, err);
gt_timer_stop(t);
/* reset warnings output */
gt_warning_set_handler(gt_warning_default_handler, NULL);
/* output results */
if (!had_err)
gt_spec_results_report(res, arguments->outfp,
gt_str_get(arguments->specfile),
arguments->verbose, arguments->colored,
!arguments->allexpects);
if (!had_err)
gt_timer_show_formatted(t, "Finished in " GT_WD ".%06ld s.\n", stderr);
/* free */
gt_node_stream_delete(gff3_in_stream);
gt_node_stream_delete(a_in_stream);
gt_node_stream_delete(a_out_stream);
gt_node_stream_delete(checker_stream);
gt_node_stream_delete(feature_stream);
gt_node_stream_delete(sort_stream);
gt_spec_results_delete(res);
gt_feature_index_delete(fi);
gt_timer_delete(t);
gt_array_delete(arr);
return had_err;
}
static int gt_gff3_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GFF3Arguments *arguments = tool_arguments;
GtTypeChecker *type_checker = NULL;
GtNodeStream *gff3_in_stream,
*sort_stream = NULL,
*load_stream = NULL,
*merge_feature_stream = NULL,
*add_introns_stream = NULL,
*set_source_stream = NULL,
*gff3_out_stream = NULL,
*last_stream;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
/* create a gff3 input stream */
gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
argv + parsed_args);
if (arguments->verbose && arguments->outfp)
gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);
if (arguments->checkids)
gt_gff3_in_stream_check_id_attributes((GtGFF3InStream*) gff3_in_stream);
if (!arguments->addids)
gt_gff3_in_stream_disable_add_ids(gff3_in_stream);
last_stream = gff3_in_stream;
/* set different type checker if necessary */
if (gt_typecheck_info_option_used(arguments->tci)) {
type_checker = gt_typecheck_info_create_type_checker(arguments->tci, err);
if (!type_checker)
had_err = -1;
if (!had_err)
gt_gff3_in_stream_set_type_checker(gff3_in_stream, type_checker);
}
/* set offset (if necessary) */
if (!had_err && arguments->offset != GT_UNDEF_WORD)
gt_gff3_in_stream_set_offset(gff3_in_stream, arguments->offset);
/* set offsetfile (if necessary) */
if (!had_err && gt_str_length(arguments->offsetfile)) {
had_err = gt_gff3_in_stream_set_offsetfile(gff3_in_stream,
arguments->offsetfile, err);
}
/* enable strict mode (if necessary) */
if (!had_err && arguments->strict)
gt_gff3_in_stream_enable_strict_mode((GtGFF3InStream*) gff3_in_stream);
/* enable tidy mode (if necessary) */
if (!had_err && arguments->tidy)
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream);
if (!had_err && arguments->fixboundaries)
gt_gff3_in_stream_fix_region_boundaries((GtGFF3InStream*) gff3_in_stream);
/* create load stream (if necessary) */
if (!had_err && arguments->load) {
load_stream = gt_load_stream_new(last_stream);
last_stream = load_stream;
}
/* create sort stream (if necessary) */
if (!had_err && arguments->sort) {
sort_stream = gt_sort_stream_new(last_stream);
last_stream = sort_stream;
}
/* create merge feature stream (if necessary) */
if (!had_err && arguments->mergefeat) {
gt_assert(sort_stream);
merge_feature_stream = gt_merge_feature_stream_new(sort_stream);
last_stream = merge_feature_stream;
}
/* create addintrons stream (if necessary) */
if (!had_err && arguments->addintrons) {
gt_assert(last_stream);
add_introns_stream = gt_add_introns_stream_new(last_stream);
last_stream = add_introns_stream;
}
/* create setsource stream (if necessary) */
if (!had_err && gt_str_length(arguments->newsource) > 0) {
gt_assert(last_stream);
GtNodeVisitor *ssv = gt_set_source_visitor_new(arguments->newsource);
set_source_stream = gt_visitor_stream_new(last_stream, ssv);
last_stream = set_source_stream;
}
/* create gff3 output stream */
if (!had_err && arguments->show) {
gff3_out_stream = gt_gff3_out_stream_new(last_stream, arguments->outfp);
last_stream = gff3_out_stream;
gt_gff3_out_stream_set_fasta_width((GtGFF3OutStream*) last_stream,
arguments->width);
if (arguments->retainids)
gt_gff3_out_stream_retain_id_attributes((GtGFF3OutStream*) last_stream);
}
/* pull the features through the stream and free them afterwards */
if (!had_err)
had_err = gt_node_stream_pull(last_stream, err);
/* free */
gt_node_stream_delete(gff3_out_stream);
gt_node_stream_delete(sort_stream);
gt_node_stream_delete(load_stream);
gt_node_stream_delete(merge_feature_stream);
gt_node_stream_delete(add_introns_stream);
gt_node_stream_delete(set_source_stream);
gt_node_stream_delete(gff3_in_stream);
gt_type_checker_delete(type_checker);
return had_err;
}
// Main method
int main(int argc, char * const *argv)
{
GtError *error;
GtLogger *logger;
GtQueue *streams;
GtNodeStream *stream, *last_stream;
CanonGFF3Options options = { NULL, NULL, false };
gt_lib_init();
error = gt_error_new();
canon_gff3_parse_options(argc, argv + 0, &options, error);
streams = gt_queue_new();
logger = gt_logger_new(true, "", stderr);
stream = gt_gff3_in_stream_new_unsorted(argc - optind, (const char **)
argv+optind);
gt_gff3_in_stream_check_id_attributes((GtGFF3InStream *)stream);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream *)stream);
gt_queue_add(streams, stream);
last_stream = stream;
if(options.infer)
{
GtHashmap *type_parents = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
gt_free_func);
gt_hashmap_add(type_parents, gt_cstr_dup("mRNA"), gt_cstr_dup("gene"));
gt_hashmap_add(type_parents, gt_cstr_dup("tRNA"), gt_cstr_dup("gene"));
stream = agn_infer_parent_stream_new(last_stream,
type_parents);
gt_hashmap_delete(type_parents);
gt_queue_add(streams, stream);
last_stream = stream;
}
stream = agn_gene_stream_new(last_stream, logger);
gt_queue_add(streams, stream);
last_stream = stream;
if(options.source != NULL)
{
GtNodeVisitor *ssv = gt_set_source_visitor_new(options.source);
stream = gt_visitor_stream_new(last_stream, ssv);
gt_queue_add(streams, stream);
last_stream = stream;
}
stream = gt_gff3_out_stream_new(last_stream, options.outstream);
if(!options.infer)
gt_gff3_out_stream_retain_id_attributes((GtGFF3OutStream *)stream);
gt_queue_add(streams, stream);
last_stream = stream;
if(gt_node_stream_pull(last_stream, error) == -1)
{
fprintf(stderr, "[CanonGFF3] error processing node stream: %s",
gt_error_get(error));
}
while(gt_queue_size(streams) > 0)
{
stream = gt_queue_get(streams);
gt_node_stream_delete(stream);
}
gt_queue_delete(streams);
if(options.source != NULL)
gt_str_delete(options.source);
if(options.outstream != NULL)
gt_file_delete(options.outstream);
gt_error_delete(error);
gt_logger_delete(logger);
gt_lib_clean();
return 0;
}
static int gt_tir_runner(GT_UNUSED int argc, GT_UNUSED const char **argv,
GT_UNUSED int parsed_args, void *tool_arguments,
GtError *err)
{
GtTirArguments *arguments = tool_arguments;
GtNodeStream *tir_stream = NULL,
*pdom_stream = NULL,
*gff3_out_stream = NULL,
*last_stream = NULL;
GtPdomModelSet *ms = NULL;
GtRegionMapping *rmap = NULL;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
tir_stream = gt_tir_stream_new(arguments->str_indexname,
arguments->min_seed_length,
arguments->min_TIR_length,
arguments->max_TIR_length,
arguments->min_TIR_distance,
arguments->max_TIR_distance,
arguments->arbit_scores,
arguments->xdrop_belowscore,
arguments->similarity_threshold,
arguments->best_overlaps,
arguments->no_overlaps,
arguments->min_TSD_length,
arguments->max_TSD_length,
arguments->vicinity,
err);
if (tir_stream == NULL)
return -1;
last_stream = tir_stream;
rmap = gt_region_mapping_new_encseq((GtEncseq*)
gt_tir_stream_get_encseq((GtTIRStream*) tir_stream),
true, false);
gt_assert(rmap);
if (!had_err && gt_str_array_size(arguments->hmm_files) > 0)
{
if (!strcmp(gt_str_get(arguments->cutoffs), "GA")) {
arguments->cutoff = GT_PHMM_CUTOFF_GA;
} else if (!strcmp(gt_str_get(arguments->cutoffs), "TC")) {
arguments->cutoff = GT_PHMM_CUTOFF_TC;
} else if (!strcmp(gt_str_get(arguments->cutoffs), "NONE")) {
arguments->cutoff = GT_PHMM_CUTOFF_NONE;
} else {
gt_error_set(err, "invalid cutoff setting!");
had_err = -1;
}
}
if (!had_err && gt_str_array_size(arguments->hmm_files) > 0) {
GtNodeVisitor *pdom_v;
ms = gt_pdom_model_set_new(arguments->hmm_files, err);
if (ms != NULL) {
pdom_v = gt_ltrdigest_pdom_visitor_new(ms, arguments->cutoff,
arguments->chain_max_gap_length,
arguments->evalue_cutoff, rmap,
err);
if (pdom_v == NULL)
had_err = -1;
if (!had_err) {
last_stream = pdom_stream = gt_visitor_stream_new(last_stream, pdom_v);
gt_ltrdigest_pdom_visitor_set_root_type((GtLTRdigestPdomVisitor*)
pdom_v,
gt_ft_terminal_inverted_repeat_element);
gt_ltrdigest_pdom_visitor_set_source_tag((GtLTRdigestPdomVisitor*)
pdom_v,
"TIRvish");
}
} else had_err = -1;
}
gff3_out_stream = gt_gff3_out_stream_new(last_stream, NULL);
last_stream = gff3_out_stream;
/* pull the features through the stream and free them afterwards */
if (!had_err)
had_err = gt_node_stream_pull(last_stream, err);
gt_node_stream_delete(tir_stream);
gt_node_stream_delete(pdom_stream);
gt_node_stream_delete(gff3_out_stream);
gt_region_mapping_delete(rmap);
gt_pdom_model_set_delete(ms);
return had_err;
}
static int gt_ltrdigest_runner(GT_UNUSED int argc, const char **argv,
int parsed_args, void *tool_arguments,
GtError *err)
{
GtLTRdigestOptions *arguments = tool_arguments;
GtNodeStream *gff3_in_stream = NULL,
*gff3_out_stream = NULL,
*pdom_stream = NULL,
*ppt_stream = NULL,
*pbs_stream = NULL,
*tab_out_stream = NULL,
*sa_stream = NULL,
*last_stream = NULL;
int had_err = 0,
tests_to_run = 0,
arg = parsed_args;
GtRegionMapping *rmap = NULL;
GtPdomModelSet *ms = NULL;
gt_error_check(err);
gt_assert(arguments);
/* determine and open sequence source */
if (gt_seqid2file_option_used(arguments->s2fi)) {
/* create region mapping */
rmap = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
if (!rmap)
had_err = -1;
} else {
GtEncseqLoader *el;
GtEncseq *encseq;
/* no new-style sequence source option given, fall back to legacy syntax */
if (argc < 3) {
gt_error_set(err, "missing mandatory argument(s)");
had_err = -1;
}
if (!had_err) {
el = gt_encseq_loader_new();
gt_encseq_loader_disable_autosupport(el);
gt_encseq_loader_require_md5_support(el);
gt_encseq_loader_require_description_support(el);
encseq = gt_encseq_loader_load(el, argv[argc-1], err);
/* XXX: clip off terminal argument */
gt_free((char*) argv[argc-1]);
argv[argc-1] = NULL;
argc--;
gt_encseq_loader_delete(el);
if (!encseq)
had_err = -1;
else {
rmap = gt_region_mapping_new_encseq_seqno(encseq);
gt_encseq_delete(encseq);
}
}
}
gt_assert(had_err || rmap);
/* Always search for PPT. */
tests_to_run |= GT_LTRDIGEST_RUN_PPT;
/* Open tRNA library if given. */
if (!had_err && arguments->trna_lib
&& gt_str_length(arguments->trna_lib) > 0)
{
tests_to_run |= GT_LTRDIGEST_RUN_PBS;
arguments->trna_lib_bs = gt_bioseq_new(gt_str_get(arguments->trna_lib),
err);
if (gt_error_is_set(err))
had_err = -1;
}
/* Set HMMER cutoffs. */
if (!had_err && gt_str_array_size(arguments->hmm_files) > 0)
{
tests_to_run |= GT_LTRDIGEST_RUN_PDOM;
if (!strcmp(gt_str_get(arguments->cutoffs), "GA")) {
arguments->cutoff = GT_PHMM_CUTOFF_GA;
} else if (!strcmp(gt_str_get(arguments->cutoffs), "TC")) {
arguments->cutoff = GT_PHMM_CUTOFF_TC;
} else if (!strcmp(gt_str_get(arguments->cutoffs), "NONE")) {
arguments->cutoff = GT_PHMM_CUTOFF_NONE;
} else {
gt_error_set(err, "invalid cutoff setting!");
had_err = -1;
}
}
if (!had_err) {
last_stream = gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[arg]);
}
if (!had_err && gt_str_array_size(arguments->hmm_files) > 0) {
GtNodeVisitor *pdom_v;
ms = gt_pdom_model_set_new(arguments->hmm_files, err);
if (ms != NULL) {
pdom_v = gt_ltrdigest_pdom_visitor_new(ms, arguments->evalue_cutoff,
arguments->chain_max_gap_length,
arguments->cutoff, rmap, err);
if (pdom_v == NULL)
had_err = -1;
if (!had_err) {
gt_ltrdigest_pdom_visitor_set_source_tag((GtLTRdigestPdomVisitor*)
pdom_v,
GT_LTRDIGEST_TAG);
if (arguments->output_all_chains)
gt_ltrdigest_pdom_visitor_output_all_chains((GtLTRdigestPdomVisitor*)
pdom_v);
last_stream = pdom_stream = gt_visitor_stream_new(last_stream, pdom_v);
}
} else had_err = -1;
}
if (!had_err && arguments->trna_lib_bs) {
GtNodeVisitor *pbs_v;
pbs_v = gt_ltrdigest_pbs_visitor_new(rmap, arguments->pbs_radius,
arguments->max_edist,
arguments->alilen,
arguments->offsetlen,
arguments->trnaoffsetlen,
arguments->ali_score_match,
arguments->ali_score_mismatch,
arguments->ali_score_insertion,
arguments->ali_score_deletion,
arguments->trna_lib_bs, err);
if (pbs_v != NULL)
last_stream = pbs_stream = gt_visitor_stream_new(last_stream, pbs_v);
else
had_err = -1;
}
if (!had_err) {
GtNodeVisitor *ppt_v;
ppt_v = gt_ltrdigest_ppt_visitor_new(rmap, arguments->ppt_len,
arguments->ubox_len,
arguments->ppt_pyrimidine_prob,
arguments->ppt_purine_prob,
arguments->bkg_a_prob,
arguments->bkg_g_prob,
arguments->bkg_t_prob,
arguments->bkg_c_prob,
arguments->ubox_u_prob,
arguments->ppt_radius,
arguments->max_ubox_dist, err);
if (ppt_v != NULL)
last_stream = ppt_stream = gt_visitor_stream_new(last_stream, ppt_v);
else
had_err = -1;
}
if (!had_err) {
GtNodeVisitor *sa_v;
sa_v = gt_ltrdigest_strand_assign_visitor_new();
gt_assert(sa_v);
last_stream = sa_stream = gt_visitor_stream_new(last_stream, sa_v);
}
if (!had_err)
{
/* attach tabular output stream, if requested */
if (gt_str_length(arguments->prefix) > 0)
{
last_stream = tab_out_stream = gt_ltrdigest_file_out_stream_new(
last_stream,
tests_to_run,
rmap,
gt_str_get(arguments->prefix),
arguments->seqnamelen,
err);
if (!tab_out_stream)
had_err = -1;
if (!had_err && arguments->print_metadata)
{
had_err = gt_ltrdigest_file_out_stream_write_metadata(
(GtLTRdigestFileOutStream*)
tab_out_stream,
tests_to_run,
gt_str_get(arguments->trna_lib),
argv[arg],
arguments->ppt_len,
arguments->ubox_len,
arguments->ppt_radius,
arguments->alilen,
arguments->max_edist,
arguments->offsetlen,
arguments->trnaoffsetlen,
arguments->pbs_radius,
arguments->hmm_files,
arguments->chain_max_gap_length,
arguments->evalue_cutoff,
err);
}
if (!had_err)
{
if (arguments->write_alignments)
gt_ltrdigest_file_out_stream_enable_pdom_alignment_output(
tab_out_stream);
if (arguments->write_aaseqs)
gt_ltrdigest_file_out_stream_enable_aa_sequence_output(
tab_out_stream);
}
}
last_stream = gff3_out_stream = gt_gff3_out_stream_new(last_stream,
arguments->outfp);
/* pull the features through the stream and free them afterwards */
had_err = gt_node_stream_pull(last_stream, err);
}
gt_pdom_model_set_delete(ms);
gt_node_stream_delete(gff3_out_stream);
gt_node_stream_delete(ppt_stream);
gt_node_stream_delete(pbs_stream);
gt_node_stream_delete(sa_stream);
gt_node_stream_delete(pdom_stream);
gt_node_stream_delete(tab_out_stream);
gt_node_stream_delete(gff3_in_stream);
gt_bioseq_delete(arguments->trna_lib_bs);
gt_region_mapping_delete(rmap);
return had_err;
}
static int gt_speck_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL,
*a_in_stream = NULL, *a_out_stream = NULL,
*feature_stream = NULL, *sort_stream = NULL,
*last_stream = NULL;
GtNodeVisitor *spec_visitor = NULL;
GtSpecResults *res = NULL;
GtFeatureIndex *fi = NULL;
GtTypeChecker *type_checker = NULL;
GtTimer *t = NULL;
GtRegionMapping *rm = NULL;
GtArray *arr = gt_array_new(sizeof (GtFeatureNode*));
GtStr *prog, *speclib;
SpeccheckArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
res = gt_spec_results_new();
gt_assert(res);
if (gt_file_exists(gt_str_get(arguments->format))) {
speclib = gt_str_ref(arguments->format);
} else {
prog = gt_str_new();
gt_str_append_cstr_nt(prog, gt_error_get_progname(err),
gt_cstr_length_up_to_char(gt_error_get_progname(err), ' '));
speclib = gt_get_gtdata_path(gt_str_get(prog), NULL);
gt_str_delete(prog);
gt_str_append_cstr(speclib, "/spec/output_drivers/");
gt_str_append_str(speclib, arguments->format);
if (!gt_file_exists(gt_str_get(speclib))) {
gt_error_set(err, "output driver file \"%s\" does not exist",
gt_str_get(speclib));
had_err = -1;
}
}
if (!had_err) {
spec_visitor = gt_spec_visitor_new(gt_str_get(arguments->specfile), res,
err);
if (!spec_visitor) {
gt_spec_results_delete(res);
return -1;
}
}
t = gt_timer_new();
gt_assert(t);
/* add region mapping if given */
if (!had_err && gt_seqid2file_option_used(arguments->s2fi)) {
rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
if (!rm)
had_err = -1;
if (!had_err)
gt_spec_visitor_add_region_mapping((GtSpecVisitor*) spec_visitor, rm);
}
/* set type checker if necessary */
if (!had_err && gt_typecheck_info_option_used(arguments->tci)) {
type_checker = gt_typecheck_info_create_type_checker(arguments->tci, err);
if (!type_checker)
had_err = -1;
if (!had_err)
gt_spec_visitor_add_type_checker((GtSpecVisitor*) spec_visitor,
type_checker);
}
if (!had_err) {
/* set runtime error behaviour */
if (arguments->fail_hard)
gt_spec_visitor_fail_on_runtime_error((GtSpecVisitor*) spec_visitor);
else
gt_spec_visitor_report_runtime_errors((GtSpecVisitor*) spec_visitor);
/* redirect warnings */
gt_warning_set_handler(gt_speck_record_warning, res);
last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted(
argc - parsed_args,
argv + parsed_args);
gt_assert(gff3_in_stream);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream);
/* insert sort stream if requested */
if (arguments->sort) {
last_stream = sort_stream = gt_sort_stream_new(last_stream);
}
/* if -provideindex is given, collect input features and index them first */
if (arguments->provideindex) {
fi = gt_feature_index_memory_new();
gt_assert(fi);
last_stream = feature_stream = gt_feature_stream_new(last_stream, fi);
gt_assert(feature_stream);
last_stream = a_out_stream = gt_array_out_stream_all_new(last_stream, arr,
err);
if (!a_out_stream)
had_err = -1;
gt_timer_start(t);
if (!had_err)
had_err = gt_node_stream_pull(last_stream, err);
if (!had_err) {
gt_spec_visitor_add_feature_index((GtSpecVisitor*) spec_visitor,
gt_feature_index_ref(fi));
last_stream = a_in_stream = gt_array_in_stream_new(arr, NULL, err);
if (!a_in_stream)
had_err = -1;
}
} else {
gt_timer_start(t);
}
if (!had_err) {
checker_stream = gt_visitor_stream_new(last_stream, spec_visitor);
gt_assert(checker_stream);
}
/* perform checking */
if (!had_err)
had_err = gt_node_stream_pull(checker_stream, err);
gt_timer_stop(t);
/* reset warnings output */
gt_warning_set_handler(gt_warning_default_handler, NULL);
/* output results */
if (!had_err) {
GtStr *runtime = gt_str_new();
gt_timer_get_formatted(t, GT_WD ".%06ld", runtime);
had_err = gt_spec_results_render_template(res, gt_str_get(speclib),
arguments->outfp,
gt_str_get(arguments->specfile),
arguments->verbose,
arguments->colored,
gt_str_get(runtime), err);
gt_str_delete(runtime);
}
}
/* free */
gt_node_stream_delete(gff3_in_stream);
gt_node_stream_delete(a_in_stream);
gt_node_stream_delete(a_out_stream);
gt_node_stream_delete(checker_stream);
gt_node_stream_delete(feature_stream);
gt_node_stream_delete(sort_stream);
gt_spec_results_delete(res);
gt_feature_index_delete(fi);
gt_type_checker_delete(type_checker);
gt_timer_delete(t);
gt_array_delete(arr);
gt_str_delete(speclib);
return had_err;
}
GtNodeStream*
agn_locus_map_stream_new(GtNodeStream *in, FILE *genefh, FILE *mrnafh)
{
GtNodeVisitor *nv = agn_locus_map_visitor_new(genefh, mrnafh);
return gt_visitor_stream_new(in, nv);
}
