void gt_querysubstringmatchiterator_delete(GtQuerysubstringmatchiterator *qsmi)
{
if (qsmi != NULL)
{
gt_mmsearchiterator_delete(qsmi->mmsi);
gt_seq_iterator_delete(qsmi->seqit);
gt_free(qsmi);
}
}
static int gt_fasta_header_iterator_reset(GtCstrIterator *cstr_iterator,
GtError *err)
{
GtFastaHeaderIterator *fhi = gt_fasta_header_iterator_cast(cstr_iterator);
gt_error_check(err);
gt_seq_iterator_delete(fhi->seq_iter);
fhi->seq_iter = gt_seq_iterator_sequence_buffer_new(fhi->filenametab, err);
if (fhi->seq_iter == NULL)
return -1;
gt_seq_iterator_set_sequence_output(fhi->seq_iter, false);
return 0;
}
int gt_esa2shulengthqueryfiles(unsigned long *totalgmatchlength,
const Suffixarray *suffixarray,
const GtStrArray *queryfilenames,
GtError *err)
{
bool haserr = false;
GtSeqIterator *seqit;
const GtUchar *query;
unsigned long querylen;
char *desc = NULL;
int retval;
GtAlphabet *alphabet;
gt_error_check(err);
alphabet = gt_encseq_alphabet(suffixarray->encseq);
gt_assert(gt_str_array_size(queryfilenames) == 1UL);
seqit = gt_seq_iterator_sequence_buffer_new(queryfilenames, err);
if (!seqit)
{
haserr = true;
}
if (!haserr)
{
gt_seq_iterator_set_symbolmap(seqit, gt_alphabet_symbolmap(alphabet));
for (; /* Nothing */; )
{
retval = gt_seq_iterator_next(seqit,
&query,
&querylen,
&desc,
err);
if (retval < 0)
{
haserr = true;
break;
}
if (retval == 0)
{
break;
}
*totalgmatchlength += gt_esa2shulengthquery(suffixarray,query,querylen);
}
gt_seq_iterator_delete(seqit);
}
return haserr ? -1 : 0;
}
static int hcr_write_seqs(FILE *fp, GtHcrEncoder *hcr_enc, GtError *err)
{
int had_err = 0, seqit_err;
GtUword bits_to_write = 0,
len,
read_counter = 0,
page_counter = 0,
bits_left_in_page,
cur_read = 0;
GtWord filepos;
GtSeqIterator *seqit;
const GtUchar *seq,
*qual;
char *desc;
GtBitOutStream *bitstream;
gt_error_check(err);
gt_assert(hcr_enc->seq_encoder->sampling);
gt_safe_assign(bits_left_in_page, (hcr_enc->pagesize * 8));
gt_xfseek(fp, hcr_enc->seq_encoder->start_of_encoding, SEEK_SET);
bitstream = gt_bitoutstream_new(fp);
seqit = gt_seq_iterator_fastq_new(hcr_enc->files, err);
if (!seqit) {
gt_assert(gt_error_is_set(err));
had_err = -1;
}
if (!had_err) {
gt_seq_iterator_set_quality_buffer(seqit, &qual);
gt_seq_iterator_set_symbolmap(seqit,
gt_alphabet_symbolmap(hcr_enc->seq_encoder->alpha));
hcr_enc->seq_encoder->total_num_of_symbols = 0;
while (!had_err &&
(seqit_err = gt_seq_iterator_next(seqit,
&seq,
&len,
&desc, err)) == 1) {
/* count the bits */
bits_to_write = hcr_write_seq(hcr_enc->seq_encoder, seq, qual, len,
bitstream, true);
/* check if a new sample has to be added */
if (gt_sampling_is_next_element_sample(hcr_enc->seq_encoder->sampling,
page_counter,
read_counter,
bits_to_write,
bits_left_in_page)) {
gt_bitoutstream_flush_advance(bitstream);
filepos = gt_bitoutstream_pos(bitstream);
if (filepos < 0) {
had_err = -1;
gt_error_set(err, "error by ftell: %s", strerror(errno));
}
else {
gt_sampling_add_sample(hcr_enc->seq_encoder->sampling,
(size_t) filepos,
cur_read);
read_counter = 0;
page_counter = 0;
gt_safe_assign(bits_left_in_page, (hcr_enc->pagesize * 8));
}
}
if (!had_err) {
/* do the writing */
bits_to_write = hcr_write_seq(hcr_enc->seq_encoder,
seq, qual, len, bitstream, false);
/* update counter for sampling */
while (bits_left_in_page < bits_to_write) {
page_counter++;
bits_to_write -= bits_left_in_page;
gt_safe_assign(bits_left_in_page, (hcr_enc->pagesize * 8));
}
bits_left_in_page -= bits_to_write;
/* always set first page as written */
if (page_counter == 0)
page_counter++;
read_counter++;
hcr_enc->seq_encoder->total_num_of_symbols += len;
cur_read++;
}
}
gt_assert(hcr_enc->num_of_reads == cur_read);
if (!had_err && seqit_err) {
had_err = seqit_err;
gt_assert(gt_error_is_set(err));
}
}
if (!had_err) {
gt_bitoutstream_flush(bitstream);
filepos = gt_bitoutstream_pos(bitstream);
if (filepos < 0) {
had_err = -1;
gt_error_set(err, "error by ftell: %s", strerror(errno));
}
else {
hcr_enc->seq_encoder->startofsamplingtab = filepos;
gt_log_log("start of samplingtab: "GT_WU"",
hcr_enc->seq_encoder->startofsamplingtab);
if (hcr_enc->seq_encoder->sampling != NULL)
gt_sampling_write(hcr_enc->seq_encoder->sampling, fp);
}
}
gt_bitoutstream_delete(bitstream);
gt_seq_iterator_delete(seqit);
return had_err;
}
GtHcrEncoder *gt_hcr_encoder_new(GtStrArray *files, GtAlphabet *alpha,
bool descs, GtQualRange qrange, GtTimer *timer,
GtError *err)
{
GtBaseQualDistr *bqd;
GtHcrEncoder *hcr_enc;
GtSeqIterator *seqit;
GtStrArray *file;
int had_err = 0,
status;
GtUword len1,
len2,
i,
num_of_reads = 0;
const GtUchar *seq,
*qual;
char *desc;
gt_error_check(err);
gt_assert(alpha && files);
if (timer != NULL)
gt_timer_show_progress(timer, "get <base,qual> distr", stdout);
if (qrange.start != GT_UNDEF_UINT)
if (qrange.start == qrange.end) {
gt_error_set(err, "qrange.start must unequal qrange.end");
return NULL;
}
hcr_enc = gt_malloc(sizeof (GtHcrEncoder));
hcr_enc->files = files;
hcr_enc->num_of_files = gt_str_array_size(files);
hcr_enc->num_of_reads = 0;
hcr_enc->page_sampling = false;
hcr_enc->regular_sampling = false;
hcr_enc->sampling_rate = 0;
hcr_enc->pagesize = gt_pagesize();
if (descs) {
hcr_enc->encdesc_encoder = gt_encdesc_encoder_new();
if (timer != NULL)
gt_encdesc_encoder_set_timer(hcr_enc->encdesc_encoder, timer);
}
else
hcr_enc->encdesc_encoder = NULL;
hcr_enc->seq_encoder = gt_malloc(sizeof (GtHcrSeqEncoder));
hcr_enc->seq_encoder->alpha = alpha;
hcr_enc->seq_encoder->sampling = NULL;
hcr_enc->seq_encoder->fileinfos = gt_calloc((size_t) hcr_enc->num_of_files,
sizeof (*(hcr_enc->seq_encoder->fileinfos)));
hcr_enc->seq_encoder->qrange = qrange;
bqd = hcr_base_qual_distr_new(alpha, qrange);
/* check if reads in the same file are of same length and get
<base, quality> pair distribution */
for (i = 0; i < hcr_enc->num_of_files; i++) {
file = gt_str_array_new();
gt_str_array_add(file, gt_str_array_get_str(files, i));
seqit = gt_seq_iterator_fastq_new(file, err);
if (!seqit) {
gt_error_set(err, "cannot initialize GtSeqIteratorFastQ object");
had_err = -1;
}
if (!had_err) {
gt_seq_iterator_set_symbolmap(seqit, gt_alphabet_symbolmap(alpha));
gt_seq_iterator_set_quality_buffer(seqit, &qual);
status = gt_seq_iterator_next(seqit, &seq, &len1, &desc, err);
if (status == 1) {
num_of_reads = 1UL;
while (!had_err) {
status = gt_seq_iterator_next(seqit, &seq, &len2, &desc, err);
if (status == -1)
had_err = -1;
if (status != 1)
break;
if (len2 != len1) {
gt_error_set(err, "reads have to be of equal length");
had_err = -1;
break;
}
if (hcr_base_qual_distr_add(bqd, qual, seq, len1) != 0)
had_err = -1;
len1 = len2;
num_of_reads++;
}
}
else if (status == -1)
had_err = -1;
if (!had_err) {
if (i == 0)
hcr_enc->seq_encoder->fileinfos[i].readnum = num_of_reads;
else
hcr_enc->seq_encoder->fileinfos[i].readnum =
hcr_enc->seq_encoder->fileinfos[i - 1].readnum + num_of_reads;
hcr_enc->seq_encoder->fileinfos[i].readlength = len1;
}
}
hcr_enc->num_of_reads += num_of_reads;
gt_str_array_delete(file);
gt_seq_iterator_delete(seqit);
}
if (!had_err)
hcr_base_qual_distr_trim(bqd);
if (!had_err) {
if (timer != NULL)
gt_timer_show_progress(timer, "build huffman tree for sequences and"
" qualities", stdout);
hcr_enc->seq_encoder->huffman =
gt_huffman_new(bqd,
hcr_base_qual_distr_func,
(GtUword) bqd->ncols * bqd->nrows);
}
if (!had_err) {
hcr_enc->seq_encoder->qual_offset = bqd->qual_offset;
hcr_base_qual_distr_delete(bqd);
return hcr_enc;
}
return NULL;
}
static void gt_fasta_header_iterator_delete(GtCstrIterator *cstr_iterator)
{
GtFastaHeaderIterator *fhi = gt_fasta_header_iterator_cast(cstr_iterator);
gt_seq_iterator_delete(fhi->seq_iter);
gt_str_array_delete(fhi->filenametab);
}
static int gt_seqtranslate_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GT_UNUSED GtError *err)
{
GtTranslateArguments *arguments = tool_arguments;
GtSeqIterator *si = NULL;
GtSequenceBuffer *sb = NULL;
GtStrArray *infiles;
int had_err = 0,
rval,
i;
GtStr *translations[3];
translations[0] = gt_str_new();
translations[1] = gt_str_new();
translations[2] = gt_str_new();
gt_error_check(err);
gt_assert(arguments);
infiles = gt_str_array_new();
for (i = parsed_args; i < argc; i++) {
gt_str_array_add_cstr(infiles, argv[i]);
}
sb = gt_sequence_buffer_new_guess_type(infiles, err);
if (!sb)
had_err = -1;
if (!had_err) {
si = gt_seq_iterator_sequence_buffer_new_with_buffer(sb);
if (!si)
had_err = -1;
}
if (!had_err) {
char *desc;
const GtUchar *sequence;
GtUword len;
while (!had_err && (rval = gt_seq_iterator_next(si,
&sequence,
&len, &desc, err))) {
if (rval < 0) {
had_err = -1;
break;
}
if (len < GT_CODON_LENGTH) {
gt_warning("sequence '%s' is shorter than codon length of %d, skipping",
desc, GT_CODON_LENGTH);
} else {
had_err = gt_seqtranslate_do_translation(arguments, (char*) sequence,
len, desc,
translations, false, err);
if (!had_err && arguments->reverse) {
char *revseq = gt_cstr_dup_nt((char*) sequence, len);
had_err = gt_reverse_complement(revseq, len, err);
if (!had_err) {
had_err = gt_seqtranslate_do_translation(arguments, revseq, len,
desc, translations, true,
err);
}
gt_free(revseq);
}
}
}
}
gt_str_delete(translations[0]);
gt_str_delete(translations[1]);
gt_str_delete(translations[2]);
gt_str_array_delete(infiles);
gt_seq_iterator_delete(si);
gt_sequence_buffer_delete(sb);
return had_err;
}
int gt_runidxlocali(const IdxlocaliOptions *idxlocalioptions,GtError *err)
{
Genericindex *genericindex = NULL;
bool haserr = false;
GtLogger *logger;
const GtEncseq *encseq = NULL;
logger = gt_logger_new(idxlocalioptions->verbose,
GT_LOGGER_DEFLT_PREFIX, stdout);
if (idxlocalioptions->doonline)
{
GtEncseqLoader *el;
el = gt_encseq_loader_new();
gt_encseq_loader_require_multiseq_support(el);
gt_encseq_loader_drop_description_support(el);
gt_encseq_loader_set_logger(el, logger);
encseq = gt_encseq_loader_load(el, gt_str_get(idxlocalioptions->indexname),
err);
gt_encseq_loader_delete(el);
if (encseq == NULL)
{
haserr = true;
}
} else
{
genericindex = genericindex_new(gt_str_get(idxlocalioptions->indexname),
idxlocalioptions->withesa,
idxlocalioptions->withesa ||
idxlocalioptions->docompare,
false,
true,
0,
logger,
err);
if (genericindex == NULL)
{
haserr = true;
} else
{
encseq = genericindex_getencseq(genericindex);
}
}
if (!haserr)
{
GtSeqIterator *seqit;
const GtUchar *query;
unsigned long querylen;
char *desc = NULL;
int retval;
Limdfsresources *limdfsresources = NULL;
const AbstractDfstransformer *dfst;
SWdpresource *swdpresource = NULL;
Showmatchinfo showmatchinfo;
ProcessIdxMatch processmatch;
GtAlphabet *a;
void *processmatchinfoonline, *processmatchinfooffline;
Storematchinfo storeonline, storeoffline;
a = gt_encseq_alphabet(encseq);
if (idxlocalioptions->docompare)
{
processmatch = storematch;
gt_initstorematch(&storeonline,encseq);
gt_initstorematch(&storeoffline,encseq);
processmatchinfoonline = &storeonline;
processmatchinfooffline = &storeoffline;
} else
{
processmatch = showmatch;
showmatchinfo.encseq = encseq;
showmatchinfo.characters = gt_alphabet_characters(a);
showmatchinfo.wildcardshow = gt_alphabet_wildcard_show(a);
showmatchinfo.showalignment = idxlocalioptions->showalignment;
processmatchinfoonline = processmatchinfooffline = &showmatchinfo;
}
if (idxlocalioptions->doonline || idxlocalioptions->docompare)
{
swdpresource = gt_newSWdpresource(idxlocalioptions->matchscore,
idxlocalioptions->mismatchscore,
idxlocalioptions->gapextend,
idxlocalioptions->threshold,
idxlocalioptions->showalignment,
processmatch,
processmatchinfoonline);
}
dfst = gt_locali_AbstractDfstransformer();
if (!idxlocalioptions->doonline || idxlocalioptions->docompare)
{
gt_assert(genericindex != NULL);
limdfsresources = gt_newLimdfsresources(genericindex,
true,
0,
0, /* maxpathlength */
true, /* keepexpandedonstack */
processmatch,
processmatchinfooffline,
NULL, /* processresult */
NULL, /* processresult info */
dfst);
}
seqit = gt_seq_iterator_sequence_buffer_new(idxlocalioptions->queryfiles,
err);
if (!seqit)
haserr = true;
if (!haserr)
{
gt_seq_iterator_set_symbolmap(seqit, gt_alphabet_symbolmap(a));
for (showmatchinfo.queryunit = 0; /* Nothing */;
showmatchinfo.queryunit++)
{
retval = gt_seq_iterator_next(seqit,
&query,
&querylen,
&desc,
err);
if (retval < 0)
{
haserr = true;
break;
}
if (retval == 0)
{
break;
}
printf("process sequence " Formatuint64_t " of length %lu\n",
PRINTuint64_tcast(showmatchinfo.queryunit),querylen);
if (idxlocalioptions->doonline || idxlocalioptions->docompare)
{
gt_multiapplysmithwaterman(swdpresource,encseq,query,querylen);
}
if (!idxlocalioptions->doonline || idxlocalioptions->docompare)
{
gt_indexbasedlocali(limdfsresources,
idxlocalioptions->matchscore,
idxlocalioptions->mismatchscore,
idxlocalioptions->gapstart,
idxlocalioptions->gapextend,
idxlocalioptions->threshold,
query,
querylen,
dfst);
}
if (idxlocalioptions->docompare)
{
gt_checkandresetstorematch(showmatchinfo.queryunit,
&storeonline,&storeoffline);
}
}
if (limdfsresources != NULL)
{
gt_freeLimdfsresources(&limdfsresources,dfst);
}
if (swdpresource != NULL)
{
gt_freeSWdpresource(swdpresource);
swdpresource = NULL;
}
gt_seq_iterator_delete(seqit);
}
if (idxlocalioptions->docompare)
{
gt_freestorematch(&storeonline);
gt_freestorematch(&storeoffline);
}
}
if (genericindex == NULL)
{
gt_encseq_delete((GtEncseq *) encseq);
encseq = NULL;
} else
{
genericindex_delete(genericindex);
}
gt_logger_delete(logger);
logger = NULL;
return haserr ? -1 : 0;
}
static int gt_sequniq_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GtSequniqArguments *arguments = tool_arguments;
GtUint64 duplicates = 0, num_of_sequences = 0;
int i, had_err = 0;
GtMD5Set *md5set;
gt_error_check(err);
gt_assert(arguments);
md5set = gt_md5set_new(arguments->nofseqs);
if (!arguments->seqit) {
GtUword j;
GtBioseq *bs;
for (i = parsed_args; !had_err && i < argc; i++) {
if (!(bs = gt_bioseq_new(argv[i], err)))
had_err = -1;
if (!had_err) {
GtMD5SetStatus retval;
for (j = 0; j < gt_bioseq_number_of_sequences(bs) && !had_err; j++) {
char *seq = gt_bioseq_get_sequence(bs, j);
retval = gt_md5set_add_sequence(md5set, seq,
gt_bioseq_get_sequence_length(bs, j),
arguments->rev, err);
if (retval == GT_MD5SET_NOT_FOUND)
gt_fasta_show_entry(gt_bioseq_get_description(bs, j), seq,
gt_bioseq_get_sequence_length(bs, j),
arguments->width, arguments->outfp);
else if (retval != GT_MD5SET_ERROR)
duplicates++;
else
had_err = -1;
num_of_sequences++;
gt_free(seq);
}
gt_bioseq_delete(bs);
}
}
}
else {
GtSeqIterator *seqit;
GtStrArray *files;
off_t totalsize;
const GtUchar *sequence;
char *desc;
GtUword len;
files = gt_str_array_new();
for (i = parsed_args; i < argc; i++)
gt_str_array_add_cstr(files, argv[i]);
totalsize = gt_files_estimate_total_size(files);
seqit = gt_seq_iterator_sequence_buffer_new(files, err);
if (!seqit)
had_err = -1;
if (!had_err) {
if (arguments->verbose) {
gt_progressbar_start(gt_seq_iterator_getcurrentcounter(seqit,
(GtUint64) totalsize),
(GtUint64) totalsize);
}
while (!had_err) {
GtMD5SetStatus retval;
if ((gt_seq_iterator_next(seqit, &sequence, &len, &desc, err)) != 1)
break;
retval = gt_md5set_add_sequence(md5set, (const char*) sequence, len,
arguments->rev, err);
if (retval == GT_MD5SET_NOT_FOUND)
gt_fasta_show_entry(desc, (const char*) sequence, len,
arguments->width, arguments->outfp);
else if (retval != GT_MD5SET_ERROR)
duplicates++;
else
had_err = -1;
num_of_sequences++;
}
if (arguments->verbose)
gt_progressbar_stop();
gt_seq_iterator_delete(seqit);
}
gt_str_array_delete(files);
}
/* show statistics */
if (!had_err) {
fprintf(stderr,
"# "GT_WU" out of "GT_WU" sequences have been removed (%.3f%%)\n",
(GtUword)duplicates, (GtUword)num_of_sequences,
((double) duplicates / (double)num_of_sequences) * 100.0);
}
gt_md5set_delete(md5set);
return had_err;
}
static int gt_convertseq_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GtConvertseqArguments *arguments = tool_arguments;
int had_err = 0, i;
GtFilelengthvalues *flv;
GtSeqIterator *seqit;
GtSequenceBuffer *sb = NULL;
GtStrArray *files;
const GtUchar *sequence;
char *desc;
GtUword len, j;
off_t totalsize;
gt_error_check(err);
gt_assert(arguments != NULL);
files = gt_str_array_new();
for (i = parsed_args; i < argc; i++)
{
gt_str_array_add_cstr(files, argv[i]);
}
totalsize = gt_files_estimate_total_size(files);
flv = gt_calloc((size_t) gt_str_array_size(files),
sizeof (GtFilelengthvalues));
sb = gt_sequence_buffer_new_guess_type(files, err);
if (!sb) {
had_err = -1;
}
if (!had_err) {
gt_sequence_buffer_set_filelengthtab(sb, flv);
/* read input using seqiterator */
seqit = gt_seq_iterator_sequence_buffer_new_with_buffer(sb);
if (arguments->verbose)
{
gt_progressbar_start(gt_seq_iterator_getcurrentcounter(seqit,
(GtUint64)
totalsize),
(GtUint64) totalsize);
}
while (true)
{
GtUchar *seq = NULL;
desc = NULL;
j = 0UL;
had_err = gt_seq_iterator_next(seqit, &sequence, &len, &desc, err);
if (had_err != 1)
break;
if (arguments->revcomp) {
GtUchar *newseq = gt_calloc((size_t) len+1, sizeof (GtUchar));
memcpy(newseq, sequence, (size_t) len*sizeof (GtUchar));
had_err = gt_reverse_complement((char*) newseq, len, err);
if (had_err)
break;
seq = newseq;
} else seq = (GtUchar*) sequence;
if (!arguments->showseq) {
bool in_wildcard = false;
gt_file_xprintf(arguments->outfp, ">%s\n", desc);
for (i = 0; (GtUword) i < len; i++) {
if (arguments->reduce_wc_dna) {
switch (seq[i]) {
case 'a':
case 'A':
case 'c':
case 'C':
case 'g':
case 'G':
case 't':
case 'u':
case 'T':
case 'U':
in_wildcard = false;
gt_file_xfputc((int) seq[i], arguments->outfp);
j++;
break;
default:
if (!in_wildcard) {
in_wildcard = true;
if (isupper((int) seq[i]))
gt_file_xfputc((int) 'N', arguments->outfp);
else
gt_file_xfputc((int) 'n', arguments->outfp);
j++;
}
}
}
else if (arguments->reduce_wc_prot) {
switch (seq[i]) {
case 'X':
case 'B':
case 'Z':
if (!in_wildcard) {
in_wildcard = true;
gt_file_xfputc((int) 'N', arguments->outfp);
j++;
}
break;
case 'x':
case 'b':
case 'z':
if (!in_wildcard) {
in_wildcard = true;
gt_file_xfputc((int) 'n', arguments->outfp);
j++;
}
break;
default:
in_wildcard = false;
gt_file_xfputc((int) seq[i], arguments->outfp);
j++;
}
}
else {
gt_file_xfputc((int) seq[i], arguments->outfp);
j++;
}
if (arguments->fastawidth > 0 && j % arguments->fastawidth == 0) {
j = 0;
gt_file_xprintf(arguments->outfp, "\n");
}
}
if (arguments->fastawidth == 0 || len % arguments->fastawidth != 0)
gt_file_xprintf(arguments->outfp, "\n");
}
if (arguments->revcomp) {
gt_free(seq);
}
}
if (arguments->showflv) {
for (j=0;j<gt_str_array_size(files);j++) {
fprintf(stderr, "file "GT_WU" (%s): "GT_WU"/"GT_WU"\n",
j,
gt_str_array_get(files, j),
(GtUword) flv[j].length,
(GtUword) flv[j].effectivelength);
}
}
if (arguments->verbose)
{
gt_progressbar_stop();
}
gt_sequence_buffer_delete(sb);
gt_seq_iterator_delete(seqit);
}
gt_str_array_delete(files);
gt_free(flv);
return had_err;
}
static int gt_callenumquerymatches_withindex(
GtQuerysubstringmatchfunc findquerymatches,
const Suffixarray *suffixarray,
const GtStrArray *queryfiles,
bool forwardstrand,
bool reversestrand,
unsigned int userdefinedleastlength,
GtProcessquerybeforematching
processquerybeforematching,
GtProcessquerymatch processquerymatch,
void *processquerymatchinfo,
GtError *err)
{
GtSeqIterator *seqit;
bool haserr = false;
seqit = gt_seq_iterator_sequence_buffer_new(queryfiles, err);
if (seqit == NULL)
{
haserr = true;
} else
{
GtQuerymatch *querymatchspaceptr = gt_querymatch_new();
const GtUchar *query;
unsigned long querylen;
int retval;
uint64_t queryunitnum;
GtUchar *queryreverse = NULL;
unsigned long queryreverse_length = 0;
char *desc = NULL;
int mode;
gt_seq_iterator_set_symbolmap(seqit,
gt_alphabet_symbolmap(gt_encseq_alphabet(
suffixarray->encseq)));
for (queryunitnum = 0; /* Nothing */; queryunitnum++)
{
retval = gt_seq_iterator_next(seqit, &query, &querylen, &desc, err);
if (retval < 0)
{
haserr = true;
break;
}
if (retval == 0)
{
break;
}
if (querylen >= (unsigned long) userdefinedleastlength)
{
GtQueryrep queryrep;
queryrep.encseq = NULL;
queryrep.readmode = GT_READMODE_FORWARD;
queryrep.startpos = 0;
queryrep.length = querylen;
for (mode = 0; mode <= 1; mode++)
{
if (mode == 0 && forwardstrand)
{
queryrep.sequence = query;
queryrep.reversecopy = false;
if (processquerybeforematching != NULL)
{
processquerybeforematching(processquerymatchinfo,desc,query,
querylen,true);
}
} else
{
if (mode == 1 && reversestrand)
{
if (querylen > queryreverse_length)
{
queryreverse = gt_realloc(queryreverse,
sizeof (*queryreverse) * querylen);
queryreverse_length = querylen;
}
gt_copy_reversecomplement(queryreverse,query,querylen);
queryrep.sequence = queryreverse;
queryrep.reversecopy = true;
if (processquerybeforematching != NULL)
{
processquerybeforematching(processquerymatchinfo,desc,
queryreverse,querylen,false);
}
} else
{
queryrep.sequence = NULL;
queryrep.reversecopy = false;
}
}
if (queryrep.sequence != NULL)
{
int ret = findquerymatches(false,
suffixarray,
queryunitnum,
&queryrep,
(unsigned long) userdefinedleastlength,
processquerymatch,
processquerymatchinfo,
querymatchspaceptr,
err);
if (ret != 0)
{
haserr = true;
break;
}
}
}
}
}
gt_seq_iterator_delete(seqit);
gt_free(queryreverse);
gt_querymatch_delete(querymatchspaceptr);
}
return haserr ? -1 : 0;
}