static int region_mapping_lua_delete(lua_State *L)
{
GtRegionMapping **region_mapping;
region_mapping = check_region_mapping(L, 1);
gt_region_mapping_delete(*region_mapping);
return 0;
}
static void md5_to_id_visitor_free(GtNodeVisitor *nv)
{
GtMD5ToSeqidsVisitor *md5_to_id_visitor =
md5_to_id_visitor_cast(nv);
gt_assert(md5_to_id_visitor);
gt_region_mapping_delete(md5_to_id_visitor->region_mapping);
}
void gth_pgl_collection_traverse(const GthPGLCollection *pgl_collection,
GthPGLVisitor *pgl_visitor, GthInput *input,
bool use_desc_ranges)
{
GtUword i;
gt_assert(pgl_collection && pgl_visitor && input);
gth_pgl_visitor_preface(pgl_visitor, gth_pgl_collection_size(pgl_collection));
for (i = 0; i < gth_pgl_collection_size(pgl_collection); i++) {
GtRegionMapping *region_mapping;
GtUword file_num, seq_num, offset = 1;
GthSeqCon *seq_con;
GthPGL *pgl = gth_pgl_collection_get(pgl_collection, i);
file_num = gth_pgl_filenum(pgl);
gth_input_load_genomic_file(input, file_num, false);
seq_con = gth_input_current_gen_seq_con(input);
seq_num = gth_pgl_seqnum(pgl);
if (use_desc_ranges) {
GtRange descrange;
GtStr *description = gt_str_new();
gth_input_get_genomic_description(input, description, file_num, seq_num);
if (!gt_parse_description_range(gt_str_get(description), &descrange))
offset = descrange.start;
gt_str_delete(description);
}
region_mapping =
gt_region_mapping_new_rawseq((const char*)
gth_seq_con_get_orig_seq(seq_con, seq_num),
gth_seq_con_get_length(seq_con, seq_num),
offset);
gth_pgl_visitor_set_region_mapping(pgl_visitor, region_mapping);
gth_pgl_visitor_visit_pgl(pgl_visitor, pgl, i);
gt_region_mapping_delete(region_mapping);
}
gth_pgl_visitor_trailer(pgl_visitor);
}
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 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 int gt_inlineseq_add_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GtNodeStream *gff3_in_stream = NULL,
*add_stream = NULL,
*gff3_out_stream = NULL,
*last_stream = NULL;
GtRegionMapping *rm = NULL;
InlineseqAddArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
/* 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) {
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);
last_stream = add_stream = gt_sequence_node_add_stream_new(last_stream, rm,
err);
if (!add_stream) {
had_err = -1;
}
}
if (!had_err) {
last_stream = gff3_out_stream = gt_gff3_out_stream_new(last_stream,
arguments->outfp);
}
if (!had_err)
had_err = gt_node_stream_pull(last_stream, err);
/* free */
gt_node_stream_delete(gff3_in_stream);
gt_node_stream_delete(add_stream);
gt_node_stream_delete(gff3_out_stream);
gt_region_mapping_delete(rm);
return had_err;
}
GtRegionMapping* gt_region_mapping_new_mapping(GtStr *mapping_filename,
GtError *err)
{
GtRegionMapping *rm;
gt_error_check(err);
gt_assert(mapping_filename);
rm = gt_calloc(1, sizeof (GtRegionMapping));
rm->mapping = gt_mapping_new(mapping_filename, "mapping", MAPPINGTYPE_STRING,
err);
if (!rm->mapping) {
gt_region_mapping_delete(rm);
return NULL;
}
return rm;
}
static void extract_feature_visitor_free(GtNodeVisitor *nv)
{
GtExtractFeatureVisitor *efv = gt_extract_feature_visitor_cast(nv);
gt_assert(efv);
gt_region_mapping_delete(efv->region_mapping);
}
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;
}
