BlastQueryInfo* BlastQueryInfoDup(const BlastQueryInfo* query_info)
{
BlastQueryInfo* retval = BlastMemDup(query_info, sizeof(BlastQueryInfo));
Int4 num_contexts = query_info->last_context + 1;
retval->contexts =
BlastMemDup(query_info->contexts, num_contexts * sizeof(BlastContextInfo));
if (query_info->pattern_info) {
assert(retval->pattern_info == 0);
}
return retval;
}
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);
}
}
/** Initializes and populates the RPS BLAST specific structures.
* @param seq_src Database sequences source [in]
* @param options All search options [in]
* @param rps_options Copy of options, with RPS-specific modifications for
* scoring and hit saving options. All other options pointers
* are left the same as in input "options". [out]
* @param rps_info_out Auxiliary structure with RPS-specific information [out]
* @param rps_mmap Memory mapped lookup table [out]
* @param rps_pssm_mmap Memory mapped PSSM [out]
* @param scale_factor Scaling factor for RPS matrix. [out]
* @param extra_returns Structure containing error information [in] [out]
* @return Status.
*/
static Int2
s_RPSExtraStructsSetUp(const BlastSeqSrc* seq_src, const SBlastOptions* options,
SBlastOptions* *rps_options, BlastRPSInfo* *rps_info_out,
Nlm_MemMapPtr *rps_mmap, Nlm_MemMapPtr *rps_pssm_mmap,
double *scale_factor, Blast_SummaryReturn* extra_returns)
{
const char* kDbName;
BlastRPSInfo* rps_info = NULL;
BlastScoringOptions* rps_score_options;
BlastHitSavingOptions* rps_hit_options;
Int2 status = 0;
/* The caller has already checked these, so we are just asserting it here. */
ASSERT(seq_src && options && extra_returns);
kDbName = BlastSeqSrcGetName(seq_src);
if (kDbName == NULL ||
(status = s_BlastRPSInfoInit(&rps_info, rps_mmap,
rps_pssm_mmap, kDbName)) != 0) {
SBlastMessageWrite(&extra_returns->error, SEV_WARNING, "RPS BLAST database setup failed", NULL, FALSE);
return status;
}
*rps_info_out = rps_info;
*scale_factor = rps_info->aux_info.scale_factor;
rps_score_options = (BlastScoringOptions*)
BlastMemDup(options->score_options, sizeof(BlastScoringOptions));
rps_hit_options = (BlastHitSavingOptions*)
BlastMemDup(options->hit_options, sizeof(BlastHitSavingOptions));
rps_score_options->gap_open =
rps_info->aux_info.gap_open_penalty;
rps_score_options->gap_extend =
rps_info->aux_info.gap_extend_penalty;
rps_score_options->matrix =
strdup(rps_info->aux_info.orig_score_matrix);
*rps_options = (SBlastOptions*) BlastMemDup(options, sizeof(SBlastOptions));
(*rps_options)->score_options = rps_score_options;
(*rps_options)->hit_options = rps_hit_options;
return 0;
}
/** Multi sequence source copier; copies the MultiSeqInfo structure
* @param seq_src BlastSeqSrc structure to copy [in]
* @return New BlastSeqSrc structure
*/
static BlastSeqSrc*
s_MultiSeqSrcCopy(BlastSeqSrc* seq_src)
{
MultiSeqInfo* seq_info;
if (!seq_src)
return NULL;
seq_info = (MultiSeqInfo*) BlastMemDup
(_BlastSeqSrcImpl_GetDataStructure(seq_src), sizeof(MultiSeqInfo));
seq_info->contents_allocated = FALSE;
_BlastSeqSrcImpl_SetDataStructure(seq_src, (void*) seq_info);
return seq_src;
}
Int2
BlastScoringOptionsDup(BlastScoringOptions* *new_opt, const BlastScoringOptions* old_opt)
{
if (old_opt == NULL || new_opt == NULL)
return BLASTERR_INVALIDPARAM;
*new_opt = (BlastScoringOptions*) BlastMemDup(old_opt, sizeof(BlastScoringOptions));
if (*new_opt == NULL)
return BLASTERR_MEMORY;
if (old_opt->matrix)
(*new_opt)->matrix = strdup(old_opt->matrix);
if (old_opt->matrix_path)
(*new_opt)->matrix_path = strdup(old_opt->matrix_path);
return 0;
}
BlastSeqSrc* BlastSeqSrcCopy(const BlastSeqSrc* seq_src)
{
BlastSeqSrcCopier copy_fnptr = NULL;
BlastSeqSrc* retval = NULL;
if (!seq_src) {
return (BlastSeqSrc*) NULL;
}
if ( !(retval = (BlastSeqSrc*) BlastMemDup(seq_src, sizeof(BlastSeqSrc)))) {
return (BlastSeqSrc*) NULL;
}
/* If copy function is not provided, just return a copy of the structure */
if ( !(copy_fnptr = (*seq_src->CopyFnPtr))) {
return retval;
}
return (BlastSeqSrc*) (*copy_fnptr)(retval);
}
