/// Performs sanity checks to make sure that the sequence requested is of
/// the expected type. If the tests fail, an exception is thrown.
/// @param id Sequence id for this sequence [in]
void x_ValidateMoleculeType(CConstRef<CSeq_id> id)
{
_ASSERT(m_BioseqMaker.NotEmpty());
if (id.Empty())
{
NCBI_THROW(CInputException, eInvalidInput,
"Empty SeqID passed to the molecule type validation");
}
bool isProtein = m_BioseqMaker->IsProtein(id);
if (!isProtein && m_ReadProteins)
{
NCBI_THROW(CInputException, eSequenceMismatch,
"GI/accession/sequence mismatch: protein input required but nucleotide provided");
}
if (isProtein && !m_ReadProteins)
{
NCBI_THROW(CInputException, eSequenceMismatch,
"GI/accession/sequence mismatch: nucleotide input required but protein provided");
}
if (!isProtein) // Never seen a virtual protein sequence.
{
if (m_BioseqMaker->HasSequence(id) == false)
{
string message = "No sequence available for " + id->AsFastaString();
NCBI_THROW(CInputException, eInvalidInput, message);
}
}
}
// ----------------------------------------------------------------------------
CConstRef<CSeq_feat> CFeatTableEdit::xGetMrnaParent(
const CSeq_feat& feat)
// ----------------------------------------------------------------------------
{
CConstRef<CSeq_feat> pMrna;
CSeq_feat_Handle sfh = mpScope->GetSeq_featHandle(feat);
CSeq_annot_Handle sah = sfh.GetAnnot();
if (!sah) {
return pMrna;
}
size_t bestLength(0);
CFeat_CI findGene(sah, CSeqFeatData::eSubtype_mRNA);
for ( ; findGene; ++findGene) {
Int8 compare = sequence::TestForOverlap64(
findGene->GetLocation(), feat.GetLocation(),
sequence::eOverlap_Contained);
if (compare == -1) {
continue;
}
size_t currentLength = sequence::GetLength(findGene->GetLocation(), mpScope);
if (!bestLength || currentLength > bestLength) {
pMrna.Reset(&(findGene->GetOriginalFeature()));
bestLength = currentLength;
}
}
return pMrna;
}
bool CBioseq_Handle::ContainsSegment(CSeq_id_Handle id,
size_t resolve_depth,
EFindSegment limit_flag) const
{
CBioseq_Handle h = GetScope().GetBioseqHandle(id);
CConstRef<CSynonymsSet> syns;
if ( h ) {
syns = h.GetSynonyms();
}
SSeqMapSelector sel;
sel.SetFlags(CSeqMap::fFindRef);
if ( limit_flag == eFindSegment_LimitTSE ) {
sel.SetLimitTSE(GetTopLevelEntry());
}
sel.SetResolveCount(resolve_depth);
CSeqMap_CI it = GetSeqMap().BeginResolved(&GetScope(), sel);
for ( ; it; ++it) {
if ( syns ) {
if ( syns->ContainsSynonym(it.GetRefSeqid()) ) {
return true;
}
}
else {
if (it.GetRefSeqid() == id) {
return true;
}
}
}
return false;
}
void x_ValidatePssmVsGi7450545(CConstRef<CSeq_align> sa, int hsp_num) {
BOOST_REQUIRE(sa->GetSegs().IsDenseg());
const CDense_seg & denseg = sa->GetSegs().GetDenseg();
if (hsp_num == 1)
{
// Validate the first HSP
pair<TSeqRange, TSeqRange> first_hsp =
make_pair(TSeqRange(24, 29), TSeqRange(245, 250));
TSeqRange hsp1_query = denseg.GetSeqRange(0);
TSeqRange hsp1_subj = denseg.GetSeqRange(1);
BOOST_REQUIRE_EQUAL(first_hsp.first.GetFrom(), hsp1_query.GetFrom());
BOOST_REQUIRE_EQUAL(first_hsp.first.GetTo(), hsp1_query.GetTo());
BOOST_REQUIRE_EQUAL(first_hsp.second.GetFrom(), hsp1_subj.GetFrom());
BOOST_REQUIRE_EQUAL(first_hsp.second.GetTo(), hsp1_subj.GetTo());
}
else if (hsp_num == 2)
{
// Validate the second HSP
const pair<TSeqRange, TSeqRange> second_hsp =
make_pair(TSeqRange(74, 86), TSeqRange(108, 120));
TSeqRange hsp2_query = denseg.GetSeqRange(0);
TSeqRange hsp2_subj = denseg.GetSeqRange(1);
BOOST_REQUIRE_EQUAL(second_hsp.first.GetFrom(), hsp2_query.GetFrom());
BOOST_REQUIRE_EQUAL(second_hsp.first.GetTo(), hsp2_query.GetTo());
BOOST_REQUIRE_EQUAL(second_hsp.second.GetFrom(), hsp2_subj.GetFrom());
BOOST_REQUIRE_EQUAL(second_hsp.second.GetTo(), hsp2_subj.GetTo());
}
}
CConstRef<CGC_Sequence> CGC_Sequence::GetTopLevelParent() const
{
CConstRef<CGC_Sequence> top = GetParent();
for ( ; top && top->GetParent(); top = top->GetParent()) {
}
return top;
}
// ----------------------------------------------------------------------------
void CFeatTableEdit::GenerateLocusTags()
// ----------------------------------------------------------------------------
{
CRef<CGb_qual> pLocusTag;
SAnnotSelector selGenes;
selGenes.IncludeFeatSubtype(CSeqFeatData::eSubtype_gene);
CFeat_CI itGenes(mHandle, selGenes);
for ( ; itGenes; ++itGenes) {
string locusTagVal = itGenes->GetNamedQual("locus_tag");
if (!locusTagVal.empty()) {
continue;
}
CSeq_feat_EditHandle feh(mpScope->GetObjectHandle(
(itGenes)->GetOriginalFeature()));
feh.AddQualifier("locus_tag", xNextLocusTag());
}
SAnnotSelector selOther;
selOther.ExcludeFeatSubtype(CSeqFeatData::eSubtype_gene);
CFeat_CI itOther(mHandle, selOther);
for ( ; itOther; ++itOther) {
const CSeq_feat& feat = itOther->GetOriginalFeature();
CSeq_feat_EditHandle feh(mpScope->GetObjectHandle(
(itOther)->GetOriginalFeature()));
feh.RemoveQualifier("locus_tag");
CConstRef<CSeq_feat> pGeneParent = xGetGeneParent(feat);
if (!pGeneParent) {
continue;
}
string locusTag = pGeneParent->GetNamedQual("locus_tag");
feh.AddQualifier("locus_tag", locusTag);
}
}
bool CLocation_constraint :: x_DoesBioseqMatchSequenceType(CConstRef <CBioseq> bioseq, const ESeqtype_constraint& seq_type) const
{
if (seq_type == eSeqtype_constraint_any
|| (bioseq->IsNa() && seq_type == eSeqtype_constraint_nuc)
|| (bioseq->IsAa() && seq_type == eSeqtype_constraint_prot)) {
return true;
}
else return false;
};
void CSeqMap_CI::x_Push(const CConstRef<CSeqMap>& seqMap,
const CTSE_Handle& tse,
TSeqPos from, TSeqPos length,
bool minusStrand,
TSeqPos pos)
{
TSegmentInfo push;
push.m_SeqMap = seqMap;
push.m_TSE = tse;
push.m_LevelRangePos = from;
push.m_LevelRangeEnd = from + length;
if (push.m_LevelRangeEnd < push.m_LevelRangePos) {
// Detect (from + length) overflow
NCBI_THROW(CSeqMapException, eDataError,
"Sequence position overflow");
}
push.m_MinusStrand = minusStrand;
TSeqPos findOffset = !minusStrand? pos: length - 1 - pos;
push.m_Index = seqMap->x_FindSegment(from + findOffset, GetScope());
if ( push.m_Index == size_t(-1) ) {
if ( !m_Stack.empty() ) {
return;
}
push.m_Index = !minusStrand?
seqMap->x_GetLastEndSegmentIndex():
seqMap->x_GetFirstEndSegmentIndex();
}
else {
_ASSERT(push.m_Index > seqMap->x_GetFirstEndSegmentIndex() &&
push.m_Index < seqMap->x_GetLastEndSegmentIndex());
if ( pos >= length ) {
if ( !minusStrand ) {
if ( seqMap->x_GetSegmentPosition(push.m_Index, 0) <
push.m_LevelRangeEnd ) {
++push.m_Index;
_ASSERT(seqMap->x_GetSegmentPosition(push.m_Index, 0) >=
push.m_LevelRangeEnd);
}
}
else {
if ( seqMap->x_GetSegmentEndPosition(push.m_Index, 0) >
push.m_LevelRangePos ) {
--push.m_Index;
_ASSERT(seqMap->x_GetSegmentEndPosition(push.m_Index, 0) <=
push.m_LevelRangePos);
}
}
}
}
// update length of current segment
seqMap->x_GetSegmentLength(push.m_Index, GetScope());
m_Stack.push_back(push);
// update position
m_Selector.m_Position += x_GetTopOffset();
// update length
m_Selector.m_Length = push.x_CalcLength();
}
pair<double, bool> CScoreUniqSeqCoverage::MakeScore(CBioseq_Handle const& query_handle, vector<CSeq_align const*>::const_iterator begin, vector<CSeq_align const*>::const_iterator end)
{
CConstRef<CBioseq> bioseq = query_handle.GetCompleteBioseq();
unsigned int qlen = 0;
if ( !bioseq.Empty() && bioseq->IsSetLength()) {
qlen = bioseq->GetLength();
}
if ( !qlen ) {
return make_pair(0, false);
}
bool isDenDiag = ( (*begin)->GetSegs().Which() == CSeq_align::C_Segs::e_Dendiag) ?
true : false;
CRangeCollection<TSeqPos> subj_rng_coll((*begin)->GetSeqRange(1));
CRange<TSeqPos> q_rng((*begin)->GetSeqRange(0));
CRangeCollection<TSeqPos> query_rng_coll(s_FixMinusStrandRange(q_rng));
for( ++begin; begin != end; ++begin ) {
const CRange<TSeqPos> align_subj_rng((*begin)->GetSeqRange(1));
// subject range should always be on the positive strand
assert(align_subj_rng.GetTo() > align_subj_rng.GetFrom());
CRangeCollection<TSeqPos> coll(align_subj_rng);
coll.Subtract(subj_rng_coll);
if ( coll.empty() ) {
continue;
}
if(coll[0] == align_subj_rng) {
CRange<TSeqPos> query_rng ((*begin)->GetSeqRange(0));
query_rng_coll += s_FixMinusStrandRange(query_rng);
subj_rng_coll += align_subj_rng;
}
else {
ITERATE (CRangeCollection<TSeqPos>, uItr, coll) {
CRange<TSeqPos> query_rng;
const CRange<TSeqPos> & subj_rng = (*uItr);
CRef<CSeq_align> densegAln;
if ( isDenDiag) {
densegAln = CreateDensegFromDendiag(**begin);
}
CAlnMap map( (isDenDiag) ? densegAln->GetSegs().GetDenseg() : (*begin)->GetSegs().GetDenseg());
TSignedSeqPos subj_aln_start = map.GetAlnPosFromSeqPos(1,subj_rng.GetFrom());
TSignedSeqPos subj_aln_end = map.GetAlnPosFromSeqPos(1,subj_rng.GetTo());
query_rng.SetFrom(map.GetSeqPosFromAlnPos(0,subj_aln_start));
query_rng.SetTo(map.GetSeqPosFromAlnPos(0,subj_aln_end));
query_rng_coll += s_FixMinusStrandRange(query_rng);
subj_rng_coll += subj_rng;
}
}
}
static TReadId sx_GetReadId(const CSeq_id_Handle& idh)
{
if ( idh.Which() != CSeq_id::e_General ) {
return TReadId();
}
CConstRef<CSeq_id> id = idh.GetSeqId();
const CDbtag& general = id->GetGeneral();
if ( general.GetDb() != "SRA") {
return TReadId();
}
return sx_GetReadId(general.GetTag().GetStr(), true);
}
void
CCmdLineBlastXML2ReportData::x_InitSubjects(CConstRef<IBlastSeqInfoSrc> subjectsInfo)
{
if(subjectsInfo->Size() == 0) {
NCBI_THROW(CException, eUnknown, "blastxml2: Empty seq info src");
}
for(unsigned int i =0; i < subjectsInfo->Size(); i++) {
list<CRef<objects::CSeq_id> > ids = subjectsInfo->GetId(i);
m_SubjectIds.push_back(CAlignFormatUtil::GetSeqIdString(ids, true));
}
}
int
CLocalBlastDbAdapter::GetTaxId(const CSeq_id_Handle& idh)
{
int retval = static_cast<int>(kInvalidSeqPos);
CConstRef<CSeq_id> id = idh.GetSeqId();
if (id.NotEmpty()) {
int oid = 0;
if (SeqidToOid(*id, oid)) {
map<int, int> gi_to_taxid;
m_SeqDB->GetTaxIDs(oid, gi_to_taxid);
if (idh.IsGi()) {
retval = gi_to_taxid[GI_TO(int, idh.GetGi())];
} else {
void x_ValidatePssmVsGi129295(CConstRef<CSeq_align> sa) {
BOOST_REQUIRE(sa->GetSegs().IsDenseg());
const CDense_seg & denseg = sa->GetSegs().GetDenseg();
// Validate the first (and only) HSP, which is a self hit
const TSeqRange hsp(0, 231);
TSeqRange hsp1_query = denseg.GetSeqRange(0);
TSeqRange hsp1_subj = denseg.GetSeqRange(1);
BOOST_REQUIRE_EQUAL(hsp.GetFrom(), hsp1_query.GetFrom());
BOOST_REQUIRE_EQUAL(hsp.GetTo(), hsp1_query.GetTo());
BOOST_REQUIRE_EQUAL(hsp.GetFrom(), hsp1_subj.GetFrom());
BOOST_REQUIRE_EQUAL(hsp.GetTo(), hsp1_subj.GetTo());
}
CRef<CBioseq> CBlastBioseqMaker::
CreateBioseqFromId(CConstRef<CSeq_id> id, bool retrieve_seq_data)
{
_ASSERT(m_scope.NotEmpty());
// N.B.: this call fetches the Bioseq into the scope from its
// data sources (should be BLAST DB first, then Genbank)
TSeqPos len = sequence::GetLength(*id, m_scope);
if (len == numeric_limits<TSeqPos>::max()) {
NCBI_THROW(CInputException, eSeqIdNotFound,
"Sequence ID not found: '" +
id->AsFastaString() + "'");
}
CBioseq_Handle bh = m_scope->GetBioseqHandle(*id);
CRef<CBioseq> retval;
if (retrieve_seq_data) {
retval.Reset(const_cast<CBioseq*>(&*bh.GetCompleteBioseq()));
} else {
retval.Reset(new CBioseq());
CRef<CSeq_id> idToStore(new CSeq_id);
idToStore->Assign(*id);
retval->SetId().push_back(idToStore);
retval->SetInst().SetRepr(CSeq_inst::eRepr_raw);
retval->SetInst().SetMol(bh.IsProtein()
? CSeq_inst::eMol_aa
: CSeq_inst::eMol_dna);
retval->SetInst().SetLength(len);
}
return retval;
}
void CSeqMap_CI::x_Select(const CConstRef<CSeqMap>& seqMap,
const SSeqMapSelector& selector,
TSeqPos pos)
{
m_Selector = selector;
if ( m_Selector.m_Length == kInvalidSeqPos ) {
TSeqPos len = seqMap->GetLength(GetScope());
len -= min(len, m_Selector.m_Position);
m_Selector.m_Length = len;
}
if ( pos < m_Selector.m_Position ) {
pos = m_Selector.m_Position;
}
else if ( pos > m_Selector.m_Position + m_Selector.m_Length ) {
pos = m_Selector.m_Position + m_Selector.m_Length;
}
x_Push(seqMap, m_Selector.m_TopTSE,
m_Selector.m_Position,
m_Selector.m_Length,
m_Selector.m_MinusStrand,
pos - m_Selector.m_Position);
while ( !x_Found() && GetPosition() < m_SearchEnd ) {
if ( !x_Push(pos - m_Selector.m_Position) ) {
x_SettleNext();
break;
}
}
}
CPsiBlast::CPsiBlast(CRef<IQueryFactory> query_factory,
CRef<CLocalDbAdapter> blastdb,
CConstRef<CPSIBlastOptionsHandle> options)
: m_Subject(blastdb), m_Impl(0)
{
m_Impl = new CPsiBlastImpl(query_factory, m_Subject,
CConstRef<CBlastProteinOptionsHandle>(options.GetPointer()));
}
// ----------------------------------------------------------------------------
string CFeatTableEdit::xCurrentTranscriptId(
const CSeq_feat& cds)
// ----------------------------------------------------------------------------
{
// format: mLocusTagPrefix|mrna.<locus tag of gene>[_numeric disambiguation]
CConstRef<CSeq_feat> pGene = xGetGeneParent(cds);
if (!pGene) {
return "";
}
string locusTag = pGene->GetNamedQual("locus_tag");
string disAmbig = "";
map<string, int>::iterator it = mMapProtIdCounts.find(locusTag);
if (it != mMapProtIdCounts.end() && mMapProtIdCounts[locusTag] != 0) {
disAmbig = string("_") + NStr::IntToString(mMapProtIdCounts[locusTag]);
}
return (mLocusTagPrefix + "|mrna." + locusTag + disAmbig);
}
CSeq_id_Info::CSeq_id_Info(const CConstRef<CSeq_id>& seq_id,
CSeq_id_Mapper* mapper)
: m_Seq_id_Type(seq_id->Which()),
m_Seq_id(seq_id),
m_Mapper(mapper)
{
_ASSERT(mapper);
}
void
CPsiBlastIterationState::GetSeqIds(CConstRef<objects::CSeq_align_set> seqalign,
CConstRef<CPSIBlastOptionsHandle> opts,
TSeqIds& retval)
{
retval.clear();
CPsiBlastAlignmentProcessor proc;
proc(*seqalign, opts->GetInclusionThreshold(), retval);
}
string& CAlnVec::GetAlnSeqString(string& buffer,
TNumrow row,
const TSignedRange& aln_rng) const
{
string buff;
buffer.erase();
CSeqVector& seq_vec = x_GetSeqVector(row);
TSeqPos seq_vec_size = seq_vec.size();
// get the chunks which are aligned to seq on anchor
CRef<CAlnMap::CAlnChunkVec> chunk_vec =
GetAlnChunks(row, aln_rng, fSkipInserts | fSkipUnalignedGaps);
// for each chunk
for (int i=0; i<chunk_vec->size(); i++) {
CConstRef<CAlnMap::CAlnChunk> chunk = (*chunk_vec)[i];
if (chunk->GetType() & fSeq) {
// add the sequence string
if (IsPositiveStrand(row)) {
seq_vec.GetSeqData(chunk->GetRange().GetFrom(),
chunk->GetRange().GetTo() + 1,
buff);
} else {
seq_vec.GetSeqData(seq_vec_size - chunk->GetRange().GetTo() - 1,
seq_vec_size - chunk->GetRange().GetFrom(),
buff);
}
if (GetWidth(row) == 3) {
TranslateNAToAA(buff, buff, GetGenCode(row));
}
buffer += buff;
} else {
// add appropriate number of gap/end chars
const int n = chunk->GetAlnRange().GetLength();
char* ch_buff = new char[n+1];
char fill_ch;
if (chunk->GetType() & fNoSeqOnLeft ||
chunk->GetType() & fNoSeqOnRight) {
fill_ch = GetEndChar();
} else {
fill_ch = GetGapChar(row);
}
memset(ch_buff, fill_ch, n);
ch_buff[n] = 0;
buffer += ch_buff;
delete[] ch_buff;
}
}
return buffer;
}
bool CLocation_constraint :: Match(const CSeq_feat& feat, CConstRef <CSeq_feat> feat_to, CConstRef <CBioseq> feat_bioseq) const
{
if (x_IsLocationConstraintEmpty()) {
return true;
}
const CSeq_loc& feat_loc = feat.GetLocation();
if (GetStrand() != eStrand_constraint_any) {
if (feat_bioseq.Empty()) {
return false;
}
else if (feat_bioseq->IsAa()) {
if (feat_to.Empty()) { // when feat is product, feat_to points to cds
return false;
}
else if (!x_DoesStrandMatchConstraint (feat_to->GetLocation())) {
return false;
}
}
else if (!x_DoesStrandMatchConstraint (feat_loc)) {
return false;
}
}
if (!x_DoesBioseqMatchSequenceType(feat_bioseq, GetSeq_type())) {
return false;
}
if (!x_DoesLocationMatchPartialnessConstraint (feat_loc)) {
return false;
}
if (!x_DoesLocationMatchTypeConstraint (feat_loc)) {
return false;
}
if (!x_DoesLocationMatchDistanceConstraint(feat_bioseq, feat_loc)) {
return false;
}
return true;
};
bool CLocation_constraint :: x_DoesLocationMatchDistanceConstraint(CConstRef <CBioseq> bioseq, const CSeq_loc& loc) const
{
if (!CanGetEnd5() && !CanGetEnd3()) {
return true;
}
unsigned pos = loc.GetStop(eExtreme_Positional);
int pos2;
if (bioseq.NotEmpty()) {
pos2 = (bioseq->IsSetLength() ? bioseq->GetLength() : 0) - pos - 1;
}
if (loc.GetStrand() == eNa_strand_minus) {
if (CanGetEnd5()) {
if (bioseq.Empty()) {
return false;
}
else {
if (!GetEnd5().Match(pos2)) {
return false;
}
}
}
if (CanGetEnd3()) {
return GetEnd3().Match(pos);
}
}
else
{
if (CanGetEnd5() && !GetEnd5().Match(pos)) {
return false;
}
if (CanGetEnd3()) {
if (bioseq.Empty()) {
return false;
}
return GetEnd3().Match(pos2);
}
}
return true;
};
// ----------------------------------------------------------------------------
string CFeatTableEdit::xNextProteinId(
const CSeq_feat& cds)
// ----------------------------------------------------------------------------
{
// format: mLocusTagPrefix|<locus tag of gene>[_numeric disambiguation]
CConstRef<CSeq_feat> pGene = xGetGeneParent(cds);
if (!pGene) {
return "";
}
string locusTag = pGene->GetNamedQual("locus_tag");
string disAmbig = "";
map<string, int>::iterator it = mMapProtIdCounts.find(locusTag);
if (it == mMapProtIdCounts.end()) {
mMapProtIdCounts[locusTag] = 0;
}
else {
++mMapProtIdCounts[locusTag];
disAmbig = string("_") + NStr::IntToString(mMapProtIdCounts[locusTag]);
}
return (mLocusTagPrefix + "|" + locusTag + disAmbig);
}
void
CCmdLineBlastXML2ReportData::x_InitCommon(
const CSearchResults & results,
CConstRef<CBlastOptions> opts)
{
if(opts.Empty()) {
NCBI_THROW(CException, eUnknown, "blastxml2: Empty blast options");
}
if(m_Scope.Empty()) {
NCBI_THROW(CException, eUnknown, "blastxml2: Empty scope");
}
x_FillScoreMatrix(m_Options->GetMatrixName());
string resolved = SeqDB_ResolveDbPath("taxdb.bti");
if(!resolved.empty()) {
m_TaxDBFound = true;
}
m_isIterative = opts->IsIterativeSearch();
}
bool CBlastBioseqMaker::IsProtein(CConstRef<CSeq_id> id)
{
_ASSERT(m_scope.NotEmpty());
CBioseq_Handle bh = m_scope->GetBioseqHandle(*id);
if (!bh)
{
NCBI_THROW(CInputException, eSeqIdNotFound,
"Sequence ID not found: '" +
id->AsFastaString() + "'");
}
return bh.IsProtein();
}
CRef<CBlastQueryVector>
CBlastInput::GetNextSeqBatch(CScope& scope)
{
CRef<CBlastQueryVector> retval(new CBlastQueryVector);
TSeqPos size_read = 0;
while (size_read < GetBatchSize()) {
if (End())
break;
CRef<CBlastSearchQuery> q;
try { q.Reset(m_Source->GetNextSequence(scope)); }
catch (const CObjReaderParseException& e) {
if (e.GetErrCode() == CObjReaderParseException::eEOF) {
break;
}
throw;
}
CConstRef<CSeq_loc> loc = q->GetQuerySeqLoc();
if (loc->IsInt()) {
size_read += sequence::GetLength(loc->GetInt().GetId(),
q->GetScope());
} else if (loc->IsWhole()) {
size_read += sequence::GetLength(loc->GetWhole(), q->GetScope());
} else {
// programmer error, CBlastInputSource should only return Seq-locs
// of type interval or whole
abort();
}
retval->AddQuery(q);
}
return retval;
}
pair<double, bool> CScoreSeqCoverage::MakeScore(CBioseq_Handle const& query_handle, vector<CSeq_align const*>::const_iterator begin, vector<CSeq_align const*>::const_iterator end)
{
CConstRef<CBioseq> bioseq = query_handle.GetCompleteBioseq();
unsigned int qlen = 0;
if ( !bioseq.Empty() && bioseq->IsSetLength()) {
qlen = bioseq->GetLength();
}
if ( !qlen ) {
return make_pair(0, false);
}
// Subject coverage score
CRangeCollection<TSeqPos> range_coll;
for ( ; begin != end; ++begin ) {
CRange<TSeqPos> range = (*begin)->GetSeqRange(0);
s_FixMinusStrandRange(range);
range_coll += range;
}
double score = ( 100.0 * range_coll.GetCoveredLength() ) / qlen;
return make_pair(score, true);
}
static
CRef<CBioseq> MakeMaskingBioseq(const CSeq_id& new_id,
TSeqPos seq_length,
CConstRef<CSeq_id> original_id,
const CSeq_loc& masking_loc)
{
vector<CRange<TSeqPos> > mask_ranges;
for ( CSeq_loc_CI it(masking_loc); it; ++it ) {
if ( !original_id ) {
original_id = &it.GetSeq_id();
}
else if ( !original_id->Equals(it.GetSeq_id()) ) {
continue;
}
mask_ranges.push_back(it.GetRange());
}
return MakeMaskingBioseq(new_id, seq_length, *original_id, mask_ranges);
}
bool CBioseq_Handle::IsSynonym(const CSeq_id_Handle& idh) const
{
CConstRef<CSynonymsSet> syns = GetSynonyms();
return syns && syns->ContainsSynonym(idh);
}
void x_ValidatePssmVsGi40456275(CConstRef<CSeq_align> sa) {
BOOST_REQUIRE_EQUAL(false, sa->IsSetSegs());
}
