void
BlastSetUp_MaskQuery(BLAST_SequenceBlk* query_blk,
const BlastQueryInfo* query_info,
const BlastMaskLoc *filter_maskloc,
EBlastProgramType program_number)
{
const Boolean kIsNucl = (program_number == eBlastTypeBlastn);
Int4 context; /* loop variable. */
ASSERT(query_blk);
ASSERT(query_info);
ASSERT(filter_maskloc);
for (context = query_info->first_context;
context <= query_info->last_context; ++context) {
Int4 query_length = 0;
Int4 context_offset = 0;
Uint1 *buffer = NULL; /* holds sequence */
if (query_info->contexts[context].is_valid == FALSE) {
continue;
}
query_length = query_info->contexts[context].query_length;
context_offset = query_info->contexts[context].query_offset;
buffer = &query_blk->sequence[context_offset];
ASSERT(buffer);
Blast_MaskTheResidues(buffer, query_length, kIsNucl,
filter_maskloc->seqloc_array[context],
BlastIsReverseStrand(kIsNucl, context), 0);
}
}
void
BlastSetUp_MaskQuery(BLAST_SequenceBlk* query_blk,
const BlastQueryInfo* query_info,
const BlastMaskLoc *filter_maskloc,
EBlastProgramType program_number)
{
const Boolean kIsNucl = (program_number == eBlastTypeBlastn);
Int4 context; /* loop variable. */
Int4 total_length;
Boolean has_mask = FALSE; /* Check for whether filter_maskloc is empty. */
Int4 index; /* loop variable. */
ASSERT(query_blk);
ASSERT(query_info);
ASSERT(filter_maskloc);
for (index=0; index<filter_maskloc->total_size; index++)
{
if (filter_maskloc->seqloc_array[index])
{
has_mask = TRUE;
break;
}
}
if (has_mask == FALSE)
return;
total_length = query_info->contexts[query_info->last_context].query_offset
+ query_info->contexts[query_info->last_context].query_length + 2;
query_blk->sequence_start_nomask = BlastMemDup(query_blk->sequence_start, total_length);
query_blk->sequence_nomask = query_blk->sequence_start_nomask + 1;
query_blk->nomask_allocated = TRUE;
for (context = query_info->first_context;
context <= query_info->last_context; ++context) {
Int4 query_length = 0;
Int4 context_offset = 0;
Uint1 *buffer = NULL; /* holds sequence */
if (query_info->contexts[context].is_valid == FALSE) {
continue;
}
query_length = query_info->contexts[context].query_length;
context_offset = query_info->contexts[context].query_offset;
buffer = &query_blk->sequence[context_offset];
ASSERT(buffer);
Blast_MaskTheResidues(buffer, query_length, kIsNucl,
filter_maskloc->seqloc_array[context],
BlastIsReverseStrand(kIsNucl, context), 0);
}
}
/** Calculates the mask locations one context at a time.
* @param query_blk sequence [in]
* @param query_info information about sequences [in]
* @param context which context is this? [in]
* @param program_number program (blastn, blastp, etc.) [in]
* @param filter_options instructions for producing mask [in]
* @param filter_out results of filtering operations [out]
* @param blast_message any error or warning messages [out]
* @return zero on success
*/
static Int2
s_GetFilteringLocationsForOneContext(BLAST_SequenceBlk* query_blk,
const BlastQueryInfo* query_info,
Int4 context,
EBlastProgramType program_number,
const SBlastFilterOptions* filter_options,
BlastSeqLoc* *filter_out,
Blast_Message* *blast_message)
{
Int2 status = 0;
Int4 query_length = 0; /* Length of query described by SeqLocPtr. */
Int4 context_offset;
Uint1 *buffer; /* holds sequence for plus strand or protein. */
const Boolean kIsNucl = (program_number == eBlastTypeBlastn);
context_offset = query_info->contexts[context].query_offset;
buffer = &query_blk->sequence[context_offset];
if (query_info->contexts[context].is_valid == FALSE) {
return 0;
}
query_length = query_info->contexts[context].query_length;
status = BlastSetUp_Filter(program_number,
buffer,
query_length,
0,
filter_options,
filter_out,
blast_message);
if (status)
return status;
if (BlastIsReverseStrand(kIsNucl, context) == TRUE) {
/* Reverse this as it's on minus strand. */
BlastSeqLocReverse(*filter_out, query_length);
}
/* Extract the mask locations corresponding to this query
(frame, strand), detach it from other masks.
NB: for translated search the mask locations are expected in
protein coordinates. The nucleotide locations must be converted
to protein coordinates prior to the call to BLAST_MainSetUp.
*/
{
/* Auxiliary locations for lower-case masking or any other masking
* which occurred outside of CORE BLAST */
BlastSeqLoc *lcase_mask_slp = NULL;
if (query_blk->lcase_mask && query_blk->lcase_mask->seqloc_array)
{
ASSERT(context < query_blk->lcase_mask->total_size);
lcase_mask_slp = query_blk->lcase_mask->seqloc_array[context];
/* Set location list to NULL, to allow safe memory deallocation,
ownership transferred to filter_out below. */
query_blk->lcase_mask->seqloc_array[context] = NULL;
}
/* Attach the lower case mask locations to the filter locations and
combine them */
BlastSeqLocAppend(filter_out, lcase_mask_slp);
}
BlastSeqLocCombine(filter_out, 0);
return 0;
}
Int2
BLAST_ComplementMaskLocations(EBlastProgramType program_number,
const BlastQueryInfo* query_info,
const BlastMaskLoc* mask_loc, BlastSeqLoc* *complement_mask)
{
Int4 context;
const Boolean kIsNucl = (program_number == eBlastTypeBlastn);
BlastSeqLoc* tail = NULL; /* Pointer to the tail of the complement_mask
linked list */
if (complement_mask == NULL)
return -1;
*complement_mask = NULL;
for (context = query_info->first_context;
context <= query_info->last_context; ++context) {
Boolean first = TRUE; /* Specifies beginning of query. */
Boolean last_interval_open=TRUE; /* if TRUE last interval needs to be closed. */
Int4 start_offset, end_offset, filter_start, filter_end;
Int4 left=0, right; /* Used for left/right extent of a region. */
BlastSeqLoc* loc = NULL;
if (query_info->contexts[context].is_valid == FALSE) {
continue;
}
start_offset = query_info->contexts[context].query_offset;
end_offset = query_info->contexts[context].query_length
+ start_offset - 1;
ASSERT(start_offset <= end_offset);
/* mask_loc NULL is simply the case that NULL was passed in, which we
take to mean that nothing on query is masked. */
if (mask_loc == NULL || mask_loc->seqloc_array[context] == NULL) {
/* Cache the tail of the list to avoid the overhead of traversing the
* list when appending to it */
tail = BlastSeqLocNew(tail ? &tail : complement_mask,
start_offset, end_offset);
continue;
}
if (BlastIsReverseStrand(kIsNucl, context)) {
BlastSeqLocListReverse(&mask_loc->seqloc_array[context]);
}
loc = mask_loc->seqloc_array[context];
first = TRUE;
for ( ; loc; loc = loc->next) {
SSeqRange* seq_range = loc->ssr;
if (BlastIsReverseStrand(kIsNucl, context)) {
filter_start = end_offset - seq_range->right;
filter_end = end_offset - seq_range->left;
} else {
filter_start = start_offset + seq_range->left;
filter_end = start_offset + seq_range->right;
}
/* The canonical "state" at the top of this
while loop is that both "left" and "right" have
been initialized to their correct values.
The first time this loop is entered in a call to
the function this is not true and the following "if"
statement moves everything to the canonical state. */
if (first) {
last_interval_open = TRUE;
first = FALSE;
if (filter_start > start_offset) {
/* beginning of sequence not filtered */
left = start_offset;
} else {
/* beginning of sequence filtered */
left = filter_end + 1;
continue;
}
}
right = filter_start - 1;
/* Cache the tail of the list to avoid the overhead of traversing the
* list when appending to it */
tail = BlastSeqLocNew((tail ? &tail : complement_mask), left, right);
if (filter_end >= end_offset) {
/* last masked region at end of sequence */
last_interval_open = FALSE;
break;
} else {
left = filter_end + 1;
}
}
if (last_interval_open) {
/* Need to finish SSeqRange* for last interval. */
right = end_offset;
/* Cache the tail of the list to avoid the overhead of traversing the
* list when appending to it */
tail = BlastSeqLocNew((tail ? &tail : complement_mask), left, right);
}
}
return 0;
}
