GtAlphabet* gt_alphabet_new_from_string(const char *alphadef, unsigned long len,
GtError *err)
{
unsigned long i, j;
GtStrArray *sa;
GtAlphabet *alpha;
gt_assert(alphadef && len > 0);
gt_error_check(err);
alpha = gt_alphabet_new_empty();
gt_assert(alphadef);
sa = gt_str_array_new();
j = 0;
for (i = 0; i < len; i++) {
if (alphadef[i] == '\n' || i == len - 1) {
gt_str_array_add_cstr_nt(sa, alphadef+j, i - j);
j = i+1;
}
}
if (read_symbolmap_from_lines(alpha, NULL, sa, err) != 0) {
gt_str_array_delete(sa);
gt_assert(gt_error_is_set(err));
return NULL;
}
gt_str_array_delete(sa);
return alpha;
}
GtStrArray* agn_seq_union(GtFeatureIndex *refrfeats, GtFeatureIndex *predfeats,
AgnLogger *logger)
{
// Fetch seqids from reference and prediction annotations
GtError *e = gt_error_new();
GtStrArray *refrseqids = gt_feature_index_get_seqids(refrfeats, e);
if(gt_error_is_set(e))
{
agn_logger_log_error(logger, "error fetching seqids for reference: %s",
gt_error_get(e));
gt_error_unset(e);
}
GtStrArray *predseqids = gt_feature_index_get_seqids(predfeats, e);
if(gt_error_is_set(e))
{
agn_logger_log_error(logger, "error fetching seqids for prediction: %s",
gt_error_get(e));
gt_error_unset(e);
}
gt_error_delete(e);
if(agn_logger_has_error(logger))
{
gt_str_array_delete(refrseqids);
gt_str_array_delete(predseqids);
return NULL;
}
GtStrArray *seqids = agn_gt_str_array_union(refrseqids, predseqids);
gt_str_array_delete(refrseqids);
gt_str_array_delete(predseqids);
return seqids;
}
static void gt_matstat_arguments_delete(void *tool_arguments)
{
Gfmsubcallinfo *arguments = tool_arguments;
if (!arguments) return;
gt_str_array_delete(arguments->queryfilenames);
gt_str_array_delete(arguments->flagsoutputoption);
gt_str_delete(arguments->indexname);
gt_free(arguments);
}
static void freesimpleoption(Cmppairwiseopt *cmppairwise)
{
gt_str_array_delete(cmppairwise->strings);
gt_str_array_delete(cmppairwise->files);
gt_str_delete(cmppairwise->text);
if (cmppairwise->charlistlen != NULL)
{
gt_str_delete(cmppairwise->charlistlen->charlist);
gt_free(cmppairwise->charlistlen);
}
}
static void gt_linspace_align_arguments_delete(void *tool_arguments)
{
GtLinspaceArguments *arguments = tool_arguments;
if (arguments != NULL) {
gt_str_delete(arguments->outputfile);
gt_str_array_delete(arguments->strings);
gt_str_array_delete(arguments->files);
gt_str_array_delete(arguments->linearcosts);
gt_str_array_delete(arguments->affinecosts);
gt_str_array_delete(arguments->diagonalbonds);
gt_free(arguments);
}
}
static void gt_tyr_search_arguments_delete(void *tool_arguments)
{
Tyr_search_options *arguments = tool_arguments;
if (!arguments)
{
return;
}
gt_str_delete(arguments->str_inputindex);
gt_str_delete(arguments->strandspec);
gt_str_array_delete(arguments->queryfilenames);
gt_str_array_delete(arguments->showmodespec);
gt_free(arguments);
}
static void gt_tyr_occratio_arguments_delete(void *tool_arguments)
{
Tyr_occratio_options *arguments = tool_arguments;
if (!arguments)
{
return;
}
gt_str_array_delete(arguments->mersizesstrings);
gt_str_array_delete(arguments->outputspec);
gt_str_delete(arguments->str_inputindex);
gt_option_delete(arguments->refoptionmersizes);
gt_free(arguments->outputvector);
gt_free(arguments);
}
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;
}
static void gt_extracttarget_arguments_delete(void *tool_arguments)
{
ExtractTargetArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_array_delete(arguments->seqfiles);
gt_free(arguments);
}
static void sequence_node_add_stream_free(GtNodeStream *ns)
{
GtSequenceNodeAddStream *fs = gt_sequence_node_add_stream_cast(ns);
gt_node_visitor_delete(fs->collect_vis);
gt_cstr_table_delete(fs->seqid_table);
gt_str_array_delete(fs->seqids);
gt_node_stream_delete(fs->in_stream);
}
void gt_index_options_delete(GtIndexOptions *oi)
{
if (oi == NULL) return;
gt_str_delete(oi->kysargumentstring);
gt_str_delete(oi->indexname);
gt_str_delete(oi->dir);
gt_str_delete(oi->memlimit);
gt_str_array_delete(oi->algbounds);
gt_free(oi);
}
void gt_sfxoptions_delete(Suffixeratoroptions *so)
{
/* no checking if error occurs, since errors have been output before */
gt_index_options_delete(so->idxopts);
gt_encseq_options_delete(so->encopts);
gt_encseq_options_delete(so->loadopts);
gt_str_delete(so->indexname);
gt_str_delete(so->inputindex);
gt_str_array_delete(so->db);
}
static void gt_compreads_compress_arguments_delete(void *tool_arguments)
{
GtCsrHcrEncodeArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->name);
gt_str_array_delete(arguments->files);
gt_str_delete(arguments->smap);
gt_str_delete(arguments->method);
gt_free(arguments);
}
static int construct_bioseq_files(GtBioseq *bs, GtStr *bioseq_indexname,
GtError *err)
{
GtStr *sequence_filename;
GtEncseqEncoder *ee;
GtStrArray *indexfn;
int had_err = 0;
gt_error_check(err);
/* register the signal handler to remove incomplete files upon termination */
if (!bs->use_stdin) {
gt_bioseq_index_filename = gt_str_get(bs->sequence_file);
gt_sig_register_all(remove_bioseq_files);
}
/* if stdin is used as input, we need to create a tempfile containing the
sequence as GtEncseq cannot be built from stdin directly */
if (bs->use_stdin) {
GtStr *tmpfilename;
FILE *tmpfile = NULL;
int i;
char buf[BUFSIZ];
tmpfilename = gt_str_new();
tmpfile = gt_xtmpfp(tmpfilename);
gt_assert(tmpfile);
i = 1;
while (i > 0) {
i = fread(buf, 1, BUFSIZ, stdin);
if (i > 0) fwrite(buf, 1, i, tmpfile);
}
gt_fa_xfclose(tmpfile);
sequence_filename = tmpfilename;
} else {
sequence_filename = gt_str_ref(bs->sequence_file);
}
gt_assert(gt_str_length(sequence_filename) > 0);
ee = gt_encseq_encoder_new();
gt_encseq_encoder_enable_description_support(ee);
gt_encseq_encoder_enable_md5_support(ee);
gt_encseq_encoder_enable_multiseq_support(ee);
gt_encseq_encoder_enable_lossless_support(ee);
indexfn = gt_str_array_new();
gt_str_array_add(indexfn, sequence_filename);
gt_str_delete(sequence_filename);
had_err = gt_encseq_encoder_encode(ee, indexfn,
gt_str_get(bioseq_indexname), err);
/* unregister the signal handler */
if (!bs->use_stdin)
gt_sig_unregister_all();
gt_str_array_delete(indexfn);
gt_encseq_encoder_delete(ee);
return had_err;
}
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_tir_arguments_delete(void *tool_arguments)
{
GtTirArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->str_indexname);
gt_str_delete(arguments->cutoffs);
gt_str_delete(arguments->str_overlaps);
gt_str_array_delete(arguments->hmm_files);
gt_option_delete(arguments->optionoverlaps);
gt_free(arguments);
}
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 int feature_index_lua_get_seqids(lua_State *L)
{
GtFeatureIndex **feature_index;
GtStrArray *seqids;
feature_index = check_feature_index(L, 1);
seqids = gt_feature_index_get_seqids(*feature_index);
gt_assert(seqids);
/* push table containing sequence ids onto the stack */
gt_lua_push_strarray_as_table(L, seqids);
gt_str_array_delete(seqids);
return 1;
}
static int encseq_encoder_lua_encode(lua_State *L)
{
GtEncseqEncoder **encoder;
GtStrArray *seqfiles = gt_str_array_new();
GtError *err;
const char *indexname;
encoder = check_encseq_encoder(L, 1);
err = gt_error_new();
if (gt_lua_get_table_as_strarray(L, 2, seqfiles, err) != 0) {
gt_str_array_delete(seqfiles);
gt_lua_error(L, err);
}
indexname = luaL_checkstring(L, 3);
gt_assert(*encoder);
if (gt_encseq_encoder_encode(*encoder, seqfiles, indexname, err) != 0) {
gt_str_array_delete(seqfiles);
gt_lua_error(L, err);
}
gt_str_array_delete(seqfiles);
gt_error_delete(err);
return 0;
}
static void gt_repfind_arguments_delete(void *tool_arguments)
{
Maxpairsoptions *arguments = tool_arguments;
if (!arguments)
{
return;
}
gt_str_delete(arguments->indexname);
gt_str_array_delete(arguments->queryfiles);
gt_option_delete(arguments->refforwardoption);
gt_free(arguments);
}
static void gt_ltrdigest_arguments_delete(void *tool_arguments)
{
GtLTRdigestOptions *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->trna_lib);
gt_str_delete(arguments->prefix);
gt_str_delete(arguments->cutoffs);
gt_str_array_delete(arguments->hmm_files);
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_seqid2file_info_delete(arguments->s2fi);
gt_free(arguments);
}
static void gt_genomediff_arguments_delete(void *tool_arguments)
{
GtGenomediffArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->indexname);
gt_str_delete(arguments->unitfile);
gt_str_delete(arguments->indextype);
gt_str_array_delete(arguments->filenames);
gt_option_delete(arguments->ref_unitfile);
gt_encseq_options_delete(arguments->loadopts);
gt_index_options_delete(arguments->idxopts);
gt_free(arguments);
}
static void gt_cge_spacedseed_arguments_delete(void *tool_arguments)
{
Cge_spacedseed_options *arguments = tool_arguments;
if (!arguments)
{
return;
}
gt_str_delete(arguments->str_inputindex);
gt_str_array_delete(arguments->queryfilenames);
gt_option_delete(arguments->refoptionpckindex);
gt_option_delete(arguments->refoptionesaindex);
gt_free(arguments);
}
static void gt_idxlocali_arguments_delete (void *tool_arguments)
{
IdxlocaliOptions *arguments = tool_arguments;
if (!arguments)
{
return;
}
gt_str_delete (arguments->indexname);
gt_str_array_delete (arguments->queryfiles);
gt_option_delete (arguments->refoptionesaindex);
gt_option_delete (arguments->refoptionpckindex);
gt_free (arguments);
}
static int extract_feature_visitor_feature_node(GtNodeVisitor *nv,
GtFeatureNode *fn, GtError *err)
{
GtExtractFeatureVisitor *efv;
GtFeatureNodeIterator *fni;
GtFeatureNode *child;
GtStrArray *target_ids = NULL;
GtStr *seqid = NULL,
*description,
*sequence;
int had_err = 0;
gt_error_check(err);
efv = gt_extract_feature_visitor_cast(nv);
gt_assert(efv->region_mapping);
fni = gt_feature_node_iterator_new(fn);
if (efv->target)
target_ids = gt_str_array_new();
if (efv->seqid)
seqid = gt_str_new();
description = gt_str_new();
sequence = gt_str_new();
while (!had_err && (child = gt_feature_node_iterator_next(fni))) {
if (seqid)
gt_str_reset(seqid);
if (target_ids)
gt_str_array_reset(target_ids);
if (gt_extract_feature_sequence(sequence, (GtGenomeNode*) child, efv->type,
efv->join, seqid, target_ids,
efv->region_mapping, err)) {
had_err = -1;
}
if (!had_err && gt_str_length(sequence)) {
efv->fastaseq_counter++;
construct_description(description, efv->type, efv->fastaseq_counter,
efv->join, efv->translate, seqid, target_ids);
had_err = show_entry(description, sequence, efv->translate, efv->width,
efv->outfp);
gt_str_reset(description);
gt_str_reset(sequence);
}
}
gt_str_delete(sequence);
gt_str_delete(description);
gt_str_delete(seqid);
gt_str_array_delete(target_ids);
gt_feature_node_iterator_delete(fni);
return had_err;
}
static void gt_ltrdigest_arguments_delete(void *tool_arguments)
{
GtLTRdigestOptions *arguments = tool_arguments;
if (!arguments) return;
#ifdef HAVE_HMMER
gt_str_array_delete(arguments->pdom_opts.hmm_files);
#endif
gt_str_delete(arguments->trna_lib);
gt_str_delete(arguments->prefix);
gt_str_delete(arguments->cutoffs);
gt_file_delete(arguments->outfp);
gt_outputfileinfo_delete(arguments->ofi);
gt_free(arguments);
}
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 void gt_select_arguments_delete(void *tool_arguments)
{
SelectArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_str_delete(arguments->targetgt_strand_char);
gt_str_delete(arguments->gt_strand_char);
gt_str_delete(arguments->source);
gt_str_delete(arguments->seqid);
gt_str_array_delete(arguments->filter_files);
gt_str_delete(arguments->filter_logic);
gt_str_delete(arguments->dropped_file);
gt_free(arguments);
}
static int read_symbolmap(GtAlphabet *alpha,const char *mapfile,GtError *err)
{
bool haserr = false;
GtStrArray *lines;
gt_error_check(err);
lines = gt_str_array_new_file(mapfile);
gt_assert(lines != NULL);
if (read_symbolmap_from_lines(alpha,mapfile,lines,err) != 0)
{
haserr = true;
}
gt_str_array_delete(lines);
return haserr ? -1 : 0;
}
static int feature_index_lua_get_seqids(lua_State *L)
{
GtFeatureIndex **feature_index;
GtStrArray *seqids;
GtError *err;
feature_index = check_feature_index(L, 1);
err = gt_error_new();
seqids = gt_feature_index_get_seqids(*feature_index, err);
if (!seqids)
return gt_lua_error(L, err);
gt_error_delete(err);
/* push table containing sequence ids onto the stack */
gt_lua_push_strarray_as_table(L, seqids);
gt_str_array_delete(seqids);
return 1;
}
