Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/seq__loc__util_8cpp_source.html below:

NCBI C++ ToolKit: src/objmgr/util/seq_loc_util.cpp Source File

scope->GetSequenceLength(

);

(loc.

()) {

);

SCoverageCollector {

(loc.

()) {

Add(loc.

(), scope);

);

m_Intervals[idh] +=

(from, to);

( TIntervals, it, m_Intervals ) {

coverage += it2->GetLength();

TIntervals m_Intervals;

(loc.

()) {

SCoverageCollector(loc, scope).GetCoverage();

);

( id1.

(id2) ) {

scope && scope->

(id1, id2, get_flag);

&

= it.GetSeq_id();

*

=

;

*

=

;

(loc.

()) {

strand_set =

;

istrand = (*i)->IsSetStrand() ? (*i)->GetStrand() :

}

(!strand_set) {

}

(istrand != strand) {

strand_set =

;

((*it)->IsNull() || (*it)->IsEmpty()) {

}

(!strand_set) {

}

(istrand != strand) {

(loc.

()) {

(!scope || !

) {

->Assign(*tmp_id);

last_range = lit.GetRange();

(last_range.

() < lit.GetRange().GetTo()) {

(last_range.

() > lit.GetRange().GetFrom()) {

last_range = lit.GetRange();

(lit->Which()) {

(!

(lit->GetInt(), scope)) {

(!

(lit->GetPnt(), scope)) {

(!

(lit->GetPacked_pnt(), scope)) {

rl(outer, inner, scope);

want_reverse =

;

want_reverse =

;

want_reverse =

;

want_reverse = outer_is_reverse;

want_reverse = !outer_is_reverse;

rl.

.front()->GetFrom();

& retval,

miss_end =

;

retval = 0;

(

loc_iter(loc); loc_iter; ++loc_iter ) {

= &(loc_iter.GetEmbeddingSeq_loc());

= &(loc_iter.GetEmbeddingSeq_loc());

(slp->

()) {

}

(slp ==

) {

ints.empty() ? 0 : ints.front().GetPointer();

ints.empty() ? 0 : ints.back().GetPointer();

slp ==

&& *it == first_int,

slp ==

&& *it == last_int,

}

(slp ==

) {

}

(slp ==

) {

(syn_it != syns.

()) {

syn_it->second;

infos[id].push_back(

);

->second.sort();

(me_infos.

() == you_infos.

()) {

( ; mid_it != me_infos.

(); ++mid_it, ++yid_it) {

(mid_it->first != yid_it->first ||

mid_it->second.size() != yid_it->second.size()) {

TRangeInfoList::const_iterator mit = mid_it->second.begin();

TRangeInfoList::const_iterator yit = yid_it->second.begin();

( ; mit != mid_it->second.end(); ++mit, ++yit) {

(yit != yid_it->second.end());

( !equal )

;

me_contained =

;

overlap =

;

(yid_it == you_infos.

()) {

me_contained =

;

mit_contained =

;

(yit->GetToOpen() > mit->GetFrom() &&

yit->GetFrom() < mit->GetToOpen()) {

(yit->GetFrom() <= mit->GetFrom() &&

yit->GetToOpen() >= mit->GetToOpen()) {

mit_contained =

;

( !mit_contained ) {

me_contained =

;

( overlap )

;

(!me_contained && overlap) {

you_contained =

;

(mid_it == me_infos.

()) {

you_contained =

;

yit_contained =

;

(mit->GetFrom() <= yit->GetFrom() &&

mit->GetToOpen() >= yit->GetToOpen()) {

yit_contained =

;

( !yit_contained ) {

you_contained =

;

( !you_contained ) {

( you_contained ) {

( me_contained ) {

id1_last != id2_first) {

strand1 == strand2

x < 0 ? -x : x;

infos[id].second.CombineWith(rg);

infos[id].first.CombineWith(rg);

infos[id].second.push_back(

);

infos[id].first.push_back(

);

->second.first.sort();

->second.second.sort();

(found != topologies.

()) {

found->second;

.circular =

;

topologies[idh] =

;

crossed_zero =

;

break_range = reverse != last_reverse ||

!= last_id;

bad_order =

;

( !break_range && !last_rg.

() ) {

( !crossed_zero ) {

crossed_zero =

;

( !crossed_zero ) {

crossed_zero =

;

(break_range || bad_order) {

( last_reverse ) {

infos[last_id].second.push_back(total_range);

infos[last_id].first.push_back(total_range);

( crossed_zero ) {

crossed_zero =

;

last_reverse = reverse;

( !total_range.

() ) {

( last_reverse ) {

infos[last_id].second.push_back(total_range);

infos[last_id].first.push_back(total_range);

->second.first.sort();

->second.second.sort();

(rg_it2->GetFrom() > rg.

())

;

(rg_it2->GetFrom() > rg.

()) {

diff +=

(rg_it2->GetFrom() - rg.

());

(rg_it2->GetTo() < rg.

()) {

rg.

(rg_it2->GetToOpen());

(id_it2 != ranges2.

()) {

diff += diff_plus + diff_minus;

diff += rg_it->GetLength();

diff += rg_it->GetLength();

(id_it1 == rm1.

()) {

contained =

;

(!contained && it1->GetFrom() > it2->GetFrom()) {

(it1->IsWhole() ||

(it1->GetFrom() <= it2->GetFrom() &&

it1->GetTo() >= it2->GetTo())) {

( !contained )

;

contained =

;

(!contained && it1->GetFrom() > it2->GetFrom()) {

(it1->IsWhole() ||

(it1->GetFrom() <= it2->GetFrom() &&

it1->GetTo() >= it2->GetTo())) {

( !contained )

;

( it1 && it2 ) {

same_it_id = single_id;

( !same_it_id ) {

( minus_strand ) {

( minus_strand ) {

overlap =

;

(id_it1 == ranges1.

()) {

contained =

;

( !rg_it2->IntersectingWith(*rg_it1) ) {

(rg_it2->GetTo() < rg_it1->GetFrom())

;

(rg_it2->GetFrom() >= rg_it1->GetFrom() &&

rg_it2->GetTo() <= rg_it1->GetTo()) {

( !contained )

-1;

( overlap )

;

contained =

;

( !rg_it2->IntersectingWith(*rg_it1) ) {

(rg_it2->GetTo() < rg_it1->GetFrom())

;

(rg_it2->GetFrom() >= rg_it1->GetFrom() &&

rg_it2->GetTo() <= rg_it1->GetTo()) {

( !contained )

-1;

( overlap )

;

diff1 + diff2;

overlap =

;

(id_it2 == ranges2.

())

;

( rg_it1->IntersectingWith(*rg_it2) ) {

( overlap )

;

( overlap )

;

( rg_it1->IntersectingWith(*rg_it2) ) {

( overlap )

;

( overlap )

;

( !overlap )

-1;

syns, topologies,

, scope);

syns, topologies,

, scope);

diff1 + diff2;

(circular_len == 0) {

);

id1 = loc1.

();

id2 = loc2.

();

single_seq =

;

topo.

= circular_len;

topologies[idh1] = topo;

);

);

single_seq =

;

);

syns, topologies,

, scope);

(ploc1, ploc2);

syns, topologies,

, scope);

(ploc1, ploc2);

(ploc1, ploc2);

single_id = (id1 && id2);

( ; it1; ++it1) {

(id_syn != m_SynMap.end()) {

id_syn->second;

(synh.

()) {

gi = synh.

();

(rank < best_rank) {

m_SynMap[idh] = idh;

m_SynMap[syn_set->GetSeq_id_Handle(syn_it)] = best;

<<

<< gi);

);

CDefaultSynonymMapper syn_mapper(scope);

CDefaultSynonymMapper syn_mapper(scope);

loc1.

(loc2,

, &syn_mapper);

CDefaultSynonymMapper syn_mapper(scope);

loc1.

(loc2,

, &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)

static SLJIT_INLINE sljit_ins msg(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)

Location relative to a base Seq-loc: one (usually) or more ranges of offsets.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4