64 #define NCBI_USE_ERRCODE_X ObjMgr_SeqUtil
83 return scope->GetSequenceLength(
id);
90 switch (loc.
Which()) {
113 "Unable to determine length");
119 struct SCoverageCollector {
126 switch (loc.
Which()) {
159 "Unable to determine coverage");
164 m_Intervals[idh] +=
TRange(from, to);
206 ITERATE ( TIntervals, it, m_Intervals ) {
208 coverage += it2->GetLength();
218 TIntervals m_Intervals;
225 switch (loc.
Which()) {
239 return SCoverageCollector(loc, scope).GetCoverage();
245 "Unable to determine length");
303 if ( id1.
Match(id2) ) {
321 return scope && scope->
IsSameBioseq(id1, id2, get_flag);
334 const CSeq_id&
id = it.GetSeq_id();
343 *msg =
"Location contains segments on more than one bioseq.";
351 if (sip ==
NULL && msg !=
NULL && msg->empty()) {
352 *msg =
"Location contains no IDs.";
395 switch (loc.
Which()) {
431 bool strand_set =
false;
433 ENa_strand istrand = (*i)->IsSetStrand() ? (*i)->GetStrand() :
441 }
else if (!strand_set) {
444 }
else if (istrand != strand) {
453 bool strand_set =
false;
455 if ((*it)->IsNull() || (*it)->IsEmpty()) {
465 }
else if (!strand_set) {
468 }
else if (istrand != strand) {
483 switch (loc.
Which()) {
597 last_range = lit.GetRange();
602 if (last_range.
GetTo() < lit.GetRange().GetTo()) {
606 if (last_range.
GetFrom() > lit.GetRange().GetFrom()) {
610 last_range = lit.GetRange();
643 switch (lit->Which()) {
645 if (!
IsValid(lit->GetInt(), scope)) {
661 if (!
IsValid(lit->GetPnt(), scope)) {
666 if (!
IsValid(lit->GetPacked_pnt(), scope)) {
681 SRelLoc rl(outer, inner, scope);
685 bool want_reverse =
false;
690 want_reverse =
false;
696 want_reverse = outer_is_reverse;
699 want_reverse = !outer_is_reverse;
708 return rl.
m_Ranges.front()->GetFrom();
714 unsigned int& retval,
780 bool miss_end =
false;
821 unsigned int retval = 0;
828 for (
CSeq_loc_CI loc_iter(loc); loc_iter; ++loc_iter ) {
830 first = &(loc_iter.GetEmbeddingSeq_loc());
832 last = &(loc_iter.GetEmbeddingSeq_loc());
841 switch (slp->
Which()) {
845 }
else if (slp ==
last) {
861 ints.empty() ? 0 : ints.front().GetPointer();
863 ints.empty() ? 0 : ints.back().GetPointer();
866 slp ==
first && *it == first_int,
867 slp ==
last && *it == last_int,
883 }
else if (slp ==
last) {
902 }
else if (slp ==
last) {
988 if (syn_it != syns.
end()) {
990 return syn_it->second;
1028 infos[id].push_back(
info);
1031 info->second.sort();
1047 if (me_infos.
size() == you_infos.
size()) {
1051 for ( ; mid_it != me_infos.
end(); ++mid_it, ++yid_it) {
1053 if (mid_it->first != yid_it->first ||
1054 mid_it->second.size() != yid_it->second.size()) {
1058 TRangeInfoList::const_iterator mit = mid_it->second.begin();
1059 TRangeInfoList::const_iterator yit = yid_it->second.begin();
1060 for ( ; mit != mid_it->second.end(); ++mit, ++yit) {
1061 _ASSERT(yit != yid_it->second.end());
1067 if ( !equal )
break;
1075 bool me_contained =
true;
1076 bool overlap =
false;
1080 if (yid_it == you_infos.
end()) {
1082 me_contained =
false;
1090 bool mit_contained =
false;
1092 if (yit->GetToOpen() > mit->GetFrom() &&
1093 yit->GetFrom() < mit->GetToOpen()) {
1095 if (yit->GetFrom() <= mit->GetFrom() &&
1096 yit->GetToOpen() >= mit->GetToOpen()) {
1097 mit_contained =
true;
1102 if ( !mit_contained ) {
1103 me_contained =
false;
1104 if ( overlap )
break;
1107 if (!me_contained && overlap) {
1113 bool you_contained =
true;
1117 if (mid_it == me_infos.
end()) {
1119 you_contained =
false;
1124 bool yit_contained =
false;
1126 if (mit->GetFrom() <= yit->GetFrom() &&
1127 mit->GetToOpen() >= yit->GetToOpen()) {
1128 yit_contained =
true;
1132 if ( !yit_contained ) {
1133 you_contained =
false;
1137 if ( !you_contained ) {
1143 if ( you_contained ) {
1146 if ( me_contained ) {
1177 id1_last != id2_first) {
1256 return strand1 == strand2
1267 return x < 0 ? -x : x;
1293 infos[id].second.CombineWith(rg);
1296 infos[id].first.CombineWith(rg);
1335 infos[id].second.push_back(
info);
1338 infos[id].first.push_back(
info);
1342 info->second.first.sort();
1343 info->second.second.sort();
1362 if (found != topologies.
end()) {
1363 return found->second;
1366 info.circular =
false;
1378 topologies[idh] =
info;
1400 bool crossed_zero =
false;
1409 bool break_range = reverse != last_reverse ||
id != last_id;
1411 bool bad_order =
false;
1414 if ( !break_range && !last_rg.
Empty() ) {
1419 if ( !crossed_zero ) {
1422 crossed_zero =
true;
1430 if ( !crossed_zero ) {
1433 crossed_zero =
true;
1439 if (break_range || bad_order) {
1441 if ( last_reverse ) {
1442 infos[last_id].second.push_back(total_range);
1445 infos[last_id].first.push_back(total_range);
1448 if ( crossed_zero ) {
1457 crossed_zero =
false;
1462 last_reverse = reverse;
1464 if ( !total_range.
Empty() ) {
1465 if ( last_reverse ) {
1466 infos[last_id].second.push_back(total_range);
1469 infos[last_id].first.push_back(total_range);
1473 info->second.first.sort();
1474 info->second.second.sort();
1486 if (rg_it2->GetFrom() > rg.
GetTo())
break;
1488 if (rg_it2->GetFrom() > rg.
GetFrom()) {
1489 diff +=
static_cast<Int8>(rg_it2->GetFrom() - rg.
GetFrom());
1491 if (rg_it2->GetTo() < rg.
GetTo()) {
1492 rg.
SetFrom(rg_it2->GetToOpen());
1513 if (id_it2 != ranges2.
end()) {
1518 diff += diff_plus + diff_minus;
1523 diff += rg_it->GetLength();
1527 diff += rg_it->GetLength();
1546 if (id_it1 == rm1.
end()) {
1554 bool contained =
false;
1557 if (!contained && it1->GetFrom() > it2->GetFrom()) {
1561 if (it1->IsWhole() ||
1562 (it1->GetFrom() <= it2->GetFrom() &&
1563 it1->GetTo() >= it2->GetTo())) {
1568 if ( !contained )
return false;
1571 bool contained =
false;
1574 if (!contained && it1->GetFrom() > it2->GetFrom()) {
1578 if (it1->IsWhole() ||
1579 (it1->GetFrom() <= it2->GetFrom() &&
1580 it1->GetTo() >= it2->GetTo())) {
1585 if ( !contained )
return false;
1599 while ( it1 && it2 ) {
1600 bool same_it_id = single_id;
1601 if ( !same_it_id ) {
1609 if ( minus_strand ) {
1638 if ( minus_strand ) {
1671 bool overlap =
false;
1674 if (id_it1 == ranges1.
end()) {
1686 bool contained =
false;
1688 if ( !rg_it2->IntersectingWith(*rg_it1) ) {
1691 if (rg_it2->GetTo() < rg_it1->GetFrom())
break;
1696 if (rg_it2->GetFrom() >= rg_it1->GetFrom() &&
1697 rg_it2->GetTo() <= rg_it1->GetTo()) {
1707 if ( !contained )
return -1;
1709 else if ( overlap )
break;
1713 bool contained =
false;
1715 if ( !rg_it2->IntersectingWith(*rg_it1) ) {
1718 if (rg_it2->GetTo() < rg_it1->GetFrom())
break;
1723 if (rg_it2->GetFrom() >= rg_it1->GetFrom() &&
1724 rg_it2->GetTo() <= rg_it1->GetTo()) {
1734 if ( !contained )
return -1;
1736 else if ( overlap )
break;
1752 return diff1 + diff2;
1770 bool overlap =
false;
1773 if (id_it2 == ranges2.
end())
continue;
1777 if ( rg_it1->IntersectingWith(*rg_it2) ) {
1782 if ( overlap )
break;
1784 if ( overlap )
break;
1788 if ( rg_it1->IntersectingWith(*rg_it2) ) {
1793 if ( overlap )
break;
1795 if ( overlap )
break;
1798 if ( !overlap )
return -1;
1803 syns, topologies,
flags, scope);
1805 syns, topologies,
flags, scope);
1811 return diff1 + diff2;
1822 if (circular_len == 0) {
1828 "Circular length can not be combined with no-topology flag.");
1839 bool single_seq =
true;
1855 topo.
length = circular_len;
1856 topologies[idh1] = topo;
1862 "Multi-bioseq locations are disabled by the flags.");
1868 "Circular bioseq length can not be specified "
1869 "for multi-bioseq locations.");
1889 "Multi-strand locations are disabled by the flags.");
1896 syns, topologies,
flags, scope);
1902 syns, topologies,
flags, scope);
1924 bool single_id = (id1 && id2);
1925 for ( ; it1; ++it1) {
2014 if (id_syn != m_SynMap.end()) {
2015 return id_syn->second;
2031 if (rank < best_rank) {
2038 m_SynMap[idh] = idh;
2042 m_SynMap[syn_set->GetSeq_id_Handle(syn_it)] = best;
2048 <<
" instead of GI " << gi);
2092 "Can not get length of whole location");
2102 CDefaultSynonymMapper syn_mapper(scope);
2112 CDefaultSynonymMapper syn_mapper(scope);
2113 return loc1.
Add(loc2,
flags, &syn_mapper);
2122 CDefaultSynonymMapper syn_mapper(scope);
2124 return loc1.
Subtract(loc2,
flags, &syn_mapper, &len_getter);
static CRef< CScope > m_Scope
bool IsReverse(ENa_strand s)
ESeqLocExtremes
Used to determine the meaning of a location's Start/Stop positions.
@ eExtreme_Positional
numerical value
@ eExtreme_Biological
5' and 3'
User-defined methods of the data storage class.
vector< TRangeWithFuzz > TRanges
CLocalRange< TOffset > TRange
define for the fundamental building block of sequence ranges
CDefaultLengthGetter(CScope *scope)
virtual ~CDefaultLengthGetter(void)
virtual TSeqPos GetLength(const CSeq_id &id)
virtual ~CDefaultSynonymMapper(void)
CDefaultSynonymMapper(CScope *scope)
map< CSeq_id_Handle, CSeq_id_Handle > TSynonymMap
CRef< CSeq_id_Mapper > m_IdMapper
virtual CSeq_id_Handle GetBestSynonym(const CSeq_id &id)
Exceptions for objmgr/util library.
TSeqPos GetLength(void) const
Wraps up any functionality needed that might be outside the scope of this library.
TSeqPos GetLength(void) const
Seq-loc iterator class – iterates all intervals from a seq-loc in the correct order.
Template class for iteration on objects of class C (non-medifiable version)
Template class for iteration on objects of class C.
Interface for getting bioseq length.
Interface for mapping IDs to the best synonym.
container_type::const_iterator const_iterator
container_type::iterator iterator
const_iterator begin() const
const_iterator end() const
const_iterator find(const key_type &key) const
static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)
static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)
unsigned int TSeqPos
Type for sequence locations and lengths.
#define ITERATE(Type, Var, Cont)
ITERATE macro to sequence through container elements.
#define NON_CONST_ITERATE(Type, Var, Cont)
Non constant version of ITERATE macro.
const TSeqPos kInvalidSeqPos
Define special value for invalid sequence position.
void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)
#define ERR_POST(message)
Error posting with file, line number information but without error codes.
#define NCBI_THROW(exception_class, err_code, message)
Generic macro to throw an exception, given the exception class, error code and message string.
CConstRef< CSeq_id > GetSeqId(void) const
int BestRankScore(void) const
bool Match(const CSeq_id &sid2) const
Match() - TRUE if SeqIds are equivalent.
static int WorstRank(const CRef< CSeq_id > &id)
static CSeq_id_Handle GetHandle(const CSeq_id &id)
Normal way of getting a handle, works for any seq-id.
static int BestRank(const CRef< CSeq_id > &id)
const CTextseq_id * GetTextseq_Id(void) const
Return embedded CTextseq_id, if any.
TSeqPos GetStart(ESeqLocExtremes ext) const
Return start and stop positions of the seq-loc.
CRef< CSeq_loc > Merge(TOpFlags flags, ISynonymMapper *syn_mapper) const
All functions create and return a new seq-loc object.
bool IsSetStrand(void) const
Get strand.
CSeq_id_Handle GetSeq_id_Handle(void) const
bool IsWhole(void) const
True if the current location is a whole sequence.
void Add(const CSeq_loc &other)
Simple adding of seq-locs.
CRef< CSeq_loc > Subtract(const CSeq_loc &other, TOpFlags flags, ISynonymMapper *syn_mapper, ILengthGetter *len_getter) const
Subtract seq-loc from this, merge/sort resulting ranges depending on flags.
const CSeq_loc & GetEmbeddingSeq_loc(void) const
Get the nearest seq-loc containing the current range.
bool IsEmpty(void) const
True if the current location is empty.
void SetPos(size_t pos)
Set iterator's position.
const CSeq_id * GetId(void) const
Get the id of the location return NULL if has multiple ids or no id at all.
size_t GetSize(void) const
Get number of ranges.
TRange GetRange(void) const
Get the range.
ENa_strand GetStrand(void) const
const CSeq_id & GetSeq_id(void) const
Get seq_id of the current location.
TSeqPos GetStop(ESeqLocExtremes ext) const
@ eOrder_Biological
Iterate sub-locations in positional order.
@ eEmpty_Allow
ignore empty locations
CConstBeginInfo ConstBegin(const C &obj)
Get starting point of non-modifiable object hierarchy.
CBeginInfo Begin(C &obj)
Get starting point of object hierarchy.
TSeqPos GetStop(const CSeq_loc &loc, CScope *scope, ESeqLocExtremes ext)
If only one CBioseq is represented by CSeq_loc, returns the position at the stop of the location.
const CSeq_id & GetId(const CSeq_loc &loc, CScope *scope)
If all CSeq_ids embedded in CSeq_loc refer to the same CBioseq, returns the first CSeq_id found,...
bool BadSeqLocSortOrder(const CBioseq_Handle &bsh, const CSeq_loc &loc)
Returns true if the order of Seq_locs is bad, otherwise, false.
TSeqPos GetLength(const CSeq_id &id, CScope *scope)
Get sequence length if scope not null, else return max possible TSeqPos.
ESeqLocCheck
SeqLocCheck results.
ENa_strand GetStrand(const CSeq_loc &loc, CScope *scope)
Returns eNa_strand_unknown if multiple Bioseqs in loc Returns eNa_strand_other if multiple strands in...
bool IsValid(const CSeq_point &pt, CScope *scope)
Checks that point >= 0 and point < length of Bioseq.
Int8 TestForOverlapEx(const CSeq_loc &loc1, const CSeq_loc &loc2, EOverlapType type, CScope *scope, TOverlapFlags flags)
Updated version of TestForOverlap64().
TSeqPos LocationOffset(const CSeq_loc &outer, const CSeq_loc &inner, EOffsetType how, CScope *scope)
returns (TSeqPos)-1 if the locations don't overlap
void ChangeSeqLocId(CSeq_loc *loc, bool best, CScope *scope)
Change each of the CSeq_ids embedded in a CSeq_loc to the best or worst CSeq_id accoring to the value...
TSeqPos GetStart(const CSeq_loc &loc, CScope *scope, ESeqLocExtremes ext)
If only one CBioseq is represented by CSeq_loc, returns the position at the start of the location.
int SeqLocPartialCheck(const CSeq_loc &loc, CScope *scope)
ECompare Compare(const CSeq_loc &me, const CSeq_loc &you, CScope *scope)
Returns the sequence::ECompare containment relationship between CSeq_locs.
TSeqPos GetCoverage(const CSeq_loc &loc, CScope *scope)
Get number of unique bases in the location.
CRef< CSeq_loc > Seq_loc_Subtract(const CSeq_loc &loc1, const CSeq_loc &loc2, CSeq_loc::TOpFlags flags, CScope *scope)
Subtract the second seq-loc from the first one.
Int8 TestForOverlap64(const CSeq_loc &loc1, const CSeq_loc &loc2, EOverlapType type, TSeqPos circular_len, CScope *scope)
64-bit version of TestForOverlap() Check if the two locations have ovarlap of a given type.
CSeq_id_Handle GetIdHandle(const CSeq_loc &loc, CScope *scope)
void ChangeSeqId(CSeq_id *id, bool best, CScope *scope)
Change a CSeq_id to the one for the CBioseq that it represents that has the best rank or worst rank a...
CRef< CSeq_loc > Seq_loc_Merge(const CSeq_loc &loc, CSeq_loc::TOpFlags flags, CScope *scope)
Merge ranges in the seq-loc.
bool IsOneBioseq(const CSeq_loc &loc, CScope *scope)
Returns true if all embedded CSeq_ids represent the same CBioseq, else false.
CRef< CSeq_loc > Seq_loc_Add(const CSeq_loc &loc1, const CSeq_loc &loc2, CSeq_loc::TOpFlags flags, CScope *scope)
Add two seq-locs.
int TestForOverlap(const CSeq_loc &loc1, const CSeq_loc &loc2, EOverlapType type, TSeqPos circular_len, CScope *scope)
Calls TestForOverlap64() and if the result is greater than kMax_Int truncates it to kMax_Int.
bool IsSameBioseq(const CSeq_id &id1, const CSeq_id &id2, CScope *scope, CScope::EGetBioseqFlag get_flag)
Determines if two CSeq_ids represent the same CBioseq.
CSeq_loc * SeqLocRevCmpl(const CSeq_loc &loc, CScope *)
Get reverse complement of the seq-loc (?)
ESeqLocCheck SeqLocCheck(const CSeq_loc &loc, CScope *scope)
Checks that a CSeq_loc is all on one strand on one CBioseq.
@ eSeqlocPartial_Internal
@ eSeqlocPartial_Nointernal
@ eSeqlocPartial_Limwrong
@ fCompareAbutting
Check if seq-locs are abutting (loc2 follows loc1)
@ fCompareOverlapping
Check if seq-locs are overlapping.
@ fComparePositional
Use positional coordinates (ignore strands) when looking for abutting locations.
@ eOverlap_SubsetRev
1st is a subset of 2nd ranges
@ eOverlap_CheckIntervals
2nd is a subset of 1st with matching boundaries
@ eOverlap_Contains
2nd contains 1st extremes
@ eOverlap_CheckIntRev
1st is a subset of 2nd with matching boundaries
@ eOverlap_Simple
any overlap of extremes
@ eOverlap_Interval
at least one pair of intervals must overlap
@ eOverlap_Contained
2nd contained within 1st extremes
@ eOverlap_Subset
2nd is a subset of 1st ranges
@ eContains
First CSeq_loc contains second.
@ eOverlap
CSeq_locs overlap.
@ eSame
CSeq_locs contain each other.
@ eAbutting
Abutting seq-locs.
@ eContained
First CSeq_loc contained by second.
@ eAbutAndOverlap
Seq-locs do both abut and overlap.
@ eNoOverlap
CSeq_locs do not overlap or abut.
@ fOverlap_NoMultiSeq
Throw if locations reference multiple bioseqs.
@ fOverlap_NoMultiStrand
Throw if locations reference multiple strands.
@ fOverlap_IgnoreTopology
Ignore sequence topology (circularity)
@ fOverlap_Default
Enable multi-id, multi-strand, check topology.
@ eOffset_FromLeft
relative to low-numbered end
@ eOffset_FromRight
relative to high-numbered end
@ eOffset_FromEnd
relative to end of location
@ eOffset_FromStart
For positive-orientation strands, start = left and end = right; for reverse-orientation strands,...
CBioseq_Handle GetBioseqFromSeqLoc(const CSeq_loc &loc, CScope &scope, CScope::EGetBioseqFlag flag=CScope::eGetBioseq_Loaded)
Retrieve the Bioseq Handle from a location.
CRef< CSeq_loc > Map(const CSeq_loc &src_loc)
Map seq-loc.
CBioseq_Handle GetBioseqHandle(const CSeq_id &id)
Get bioseq handle by seq-id.
CConstRef< CSynonymsSet > GetSynonyms(const CSeq_id &id)
Get bioseq synonyms, resolving to the bioseq in this scope.
bool IsSameBioseq(const CSeq_id_Handle &id1, const CSeq_id_Handle &id2, EGetBioseqFlag get_flag)
Check if two seq-ids are resolved to the same Bioseq.
@ eSeqMap_Up
map from segments to the top level bioseq
TBioseqCore GetBioseqCore(void) const
Get bioseq core structure.
TSeqPos GetBioseqLength(void) const
TInst_Topology GetInst_Topology(void) const
bool IsSetInst_Topology(void) const
int64_t Int8
8-byte (64-bit) signed integer
position_type GetLength(void) const
bool IntersectingWith(const TThisType &r) const
TThisType & CombineWith(const TThisType &r)
TThisType & SetToOpen(position_type toOpen)
position_type GetToOpen(void) const
static TThisType GetEmpty(void)
TThisType & SetOpen(position_type from, position_type toOpen)
static position_type GetWholeToOpen(void)
#define END_NCBI_SCOPE
End previously defined NCBI scope.
#define END_SCOPE(ns)
End the previously defined scope.
#define BEGIN_NCBI_SCOPE
Define ncbi namespace.
#define BEGIN_SCOPE(ns)
Define a new scope.
C::value_type FindBestChoice(const C &container, F score_func)
Find the best choice (lowest score) for values in a container.
void SetFrom(TFrom value)
Assign a value to From data member.
TTo GetTo(void) const
Get the To member data.
TFrom GetFrom(void) const
Get the From member data.
bool IsLim(void) const
Check if variant Lim is selected.
TLim GetLim(void) const
Get the variant data.
E_Choice Which(void) const
Which variant is currently selected.
const TFuzz_from & GetFuzz_from(void) const
Get the Fuzz_from member data.
const TB & GetB(void) const
Get the B member data.
list< CRef< CSeq_interval > > Tdata
ENa_strand
strand of nucleic acid
const Tdata & Get(void) const
Get the member data.
TStrand GetStrand(void) const
Get the Strand member data.
const TId & GetId(void) const
Get the Id member data.
const TPnt & GetPnt(void) const
Get the variant data.
TPoint GetPoint(void) const
Get the Point member data.
const TFuzz_to & GetFuzz_to(void) const
Get the Fuzz_to member data.
bool IsSetA(void) const
connection to a least one residue Check if a value has been assigned to A data member.
const TWhole & GetWhole(void) const
Get the variant data.
bool IsSetStrand(void) const
Check if a value has been assigned to Strand data member.
TFrom GetFrom(void) const
Get the From member data.
bool IsSetFuzz(void) const
Check if a value has been assigned to Fuzz data member.
list< CRef< CSeq_loc > > Tdata
const TFuzz & GetFuzz(void) const
Get the Fuzz member data.
E_Choice Which(void) const
Which variant is currently selected.
const TId & GetId(void) const
Get the Id member data.
const TId & GetId(void) const
Get the Id member data.
TStrand GetStrand(void) const
Get the Strand member data.
bool IsSetFuzz(void) const
Check if a value has been assigned to Fuzz data member.
const Tdata & Get(void) const
Get the member data.
const TPacked_pnt & GetPacked_pnt(void) const
Get the variant data.
vector< TSeqPos > TPoints
const TA & GetA(void) const
Get the A member data.
bool IsSetStrand(void) const
Check if a value has been assigned to Strand data member.
bool IsSetFuzz_to(void) const
Check if a value has been assigned to Fuzz_to data member.
bool IsSetStrand(void) const
Check if a value has been assigned to Strand data member.
const TPoints & GetPoints(void) const
Get the Points member data.
TStrand GetStrand(void) const
Get the Strand member data.
TTo GetTo(void) const
Get the To member data.
bool IsWhole(void) const
Check if variant Whole is selected.
const TInt & GetInt(void) const
Get the variant data.
bool IsNull(void) const
Check if variant Null is selected.
bool IsSetVersion(void) const
Check if a value has been assigned to Version data member.
bool IsSetFuzz_from(void) const
Check if a value has been assigned to Fuzz_from data member.
const TFuzz & GetFuzz(void) const
Get the Fuzz member data.
const TMix & GetMix(void) const
Get the variant data.
bool IsSetB(void) const
other end may not be available Check if a value has been assigned to B data member.
const TPacked_int & GetPacked_int(void) const
Get the variant data.
const TAccession & GetAccession(void) const
Get the Accession member data.
const TBond & GetBond(void) const
Get the variant data.
@ eNa_strand_both
in forward orientation
@ e_not_set
No variant selected.
@ e_not_set
No variant selected.
@ e_Equiv
equivalent sets of locations
@ e_Empty
to NULL one Seq-id in a collection
@ e_Feat
indirect, through a Seq-feat
bool IsSetCompleteness(void) const
Check if a value has been assigned to Completeness data member.
const TId & GetId(void) const
Get the Id member data.
TCompleteness GetCompleteness(void) const
Get the Completeness member data.
const TMolinfo & GetMolinfo(void) const
Get the variant data.
@ eCompleteness_no_left
missing 5' or NH3 end
@ eCompleteness_partial
partial but no details given
@ eCompleteness_no_right
missing 3' or COOH end
@ eCompleteness_no_ends
missing both ends
@ e_Molinfo
info on the molecule and techniques
unsigned int
A callback function used to compare two keys in a database.
Definition of all error codes used in objmgr libraries (xobjmgr.lib, xobjutil.lib and others).
CSeq_loc * GetReverseComplement(const CSeq_loc &loc, CReverseComplementHelper *helper)
Get reverse complement of the seq-loc (?).
bool s_Test_Strands(ENa_strand strand1, ENa_strand strand2)
void s_SeqLocToRangeInfoMap(const CSeq_loc &loc, TRangeInfoMap &infos, TSynMap &syns, CScope *scope)
ECompare s_CompareOverlapping(const CSeq_loc &me, const CSeq_loc &you, TSynMap &syns, CScope *scope)
bool s_CheckAbutting(const CSeq_loc &loc1, const CSeq_loc &loc2, TSynMap &syns, CScope *scope, ESeqLocExtremes ext)
CSeq_id_Handle s_GetSynHandle(CSeq_id_Handle id, TSynMap &syns, CScope *scope)
void SeqIntPartialCheck(const CSeq_interval &itv, unsigned int &retval, bool is_first, bool is_last, CScope &scope)
map< CSeq_id_Handle, TRangeInfoListByStrand > TRangeInfoMapByStrand
void s_SeqLocToRangeInfoMapByStrand(const CSeq_loc &loc, TRangeInfoMapByStrand &infos, TSynMap &syns, CScope *scope)
Int8 s_Test_Extremes(const CSeq_loc &loc1, const CSeq_loc &loc2, EOverlapType type, TSynMap &syns, TTopologyMap &topologies, TOverlapFlags flags, CScope *scope)
static ENa_strand s_GetStrand(const CSeq_loc &loc)
CRange< TSeqPos > TRangeInfo
STopologyInfo s_GetTopology(CSeq_id_Handle idh, TTopologyMap &topologies, TOverlapFlags flags, CScope *scope)
map< CSeq_id_Handle, STopologyInfo > TTopologyMap
Int8 s_Test_Interval(const CSeq_loc &loc1, const CSeq_loc &loc2, TSynMap &syns, TTopologyMap &topologies, TOverlapFlags flags, CScope *scope)
list< TRangeInfo > TRangeInfoList
void s_SeqLocToTotalRangeInfoMap(const CSeq_loc &loc, TTotalRangeInfoMap &infos, TSynMap &syns, CScope *scope)
bool s_Test_Subset(const CSeq_loc &loc1, const CSeq_loc &loc2, CScope *scope)
pair< TRangeInfoList, TRangeInfoList > TRangeInfoListByStrand
void s_SeqLocToTotalRangesInfoMapByStrand(const CSeq_loc &loc, TRangeInfoMapByStrand &infos, TSynMap &syns, TTopologyMap &topologies, TOverlapFlags flags, CScope *scope)
map< CSeq_id_Handle, TRangeInfoByStrand > TTotalRangeInfoMap
pair< TRangeInfo, TRangeInfo > TRangeInfoByStrand
bool s_Test_CheckIntervals(CSeq_loc_CI it1, CSeq_loc_CI it2, bool minus_strand, CScope *scope, bool single_id)
map< CSeq_id_Handle, TRangeInfoList > TRangeInfoMap
map< CSeq_id_Handle, CSeq_id_Handle > TSynMap
static const CSeq_id * s_GetId(const CSeq_loc &loc, CScope *scope, string *msg=NULL)
Int8 s_TestForOverlapEx(const CSeq_loc &loc1, const CSeq_loc &loc2, EOverlapType type, TOverlapFlags flags, TSeqPos circular_len, CScope *scope)
Int8 s_GetUncoveredLength(const TRangeInfoList &ranges1, const TRangeInfoList &ranges2)
Location relative to a base Seq-loc: one (usually) or more ranges of offsets.