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_8cpp_source.html below:

NCBI C++ ToolKit: src/objects/seqloc/Seq_loc.cpp Source File

:

;

( points.size() == 1 ) {

( ranges.size() == 1 ) {

ranges.front().GetFrom(), ranges.front().GetTo(), strand));

( src.

() ) {

);

.back()->Assign(**

);

.back()->Assign(**

);

( loc.

() ) {

.store(

, memory_order_release);

may_throw)

( total_id ==

) {

}

( (

&& !total_id->

(*

)) ) {

);

(

() ) {

total_range.

(pos, pos);

total_range +=

(pos, pos);

total_range += (*li)->x_CalculateTotalRangeCheckId(

);

total_range += (*li)->x_CalculateTotalRangeCheckId(

);

total_range =

(pos, pos);

total_range +=

(pos, pos);

<<

( !id1 || !id2 ) {

);

circular1 = from1 > to1;

circular2 = from2 > to2;

(

diff = circular2 - circular1 ) {

( from1 != from2 ) {

from1 < from2? -1: 1;

to1 > to2? -1: 1;

(s1 != s2)

s1 < s2 ? -1 : 1;

( ; iter1 && iter2; ) {

(

k = 0; k < 2; ++k ) {

( !loc->

() ) {

( loc1 && !loc2 ) {

( loc2 && !loc1 ) {

( !loc1 && !loc2 ) {

id1 = loc1->

();

id2 = loc2->

();

( iter1 && !iter2 ) {

( iter2 && !iter1 ) {

!filter || (*filter)( loc.

() );

!filter || (*filter)( &loc.

() );

( minus_strand ) {

<

Container1,

Container2 >

Container2& container2,

Container1::const_iterator iter1 = container1.begin();

Container1::const_iterator iter1end = container1.end();

Container2::const_iterator iter2 = container2.begin();

Container2::const_iterator iter2end = container2.end();

( ; iter1 != iter1end && iter2 != iter2end ; ++iter1, ++iter2 ) {

(

!= filter ) {

( iter1 == iter1end || iter2 == iter2end ) {

( iter1 == iter1end ) {

( iter2 == iter2end ) {

( loc2.

() ) {

minus_strand? -1: 1;

( loc2.

() ) {

minus_strand? -1: 1;

minus_strand? 1: -1;

(

() ) {

(

() ) {

<<

(

() ) {

(

() ) {

? (seq_len - stop + start + 1) : (stop - start + 1);

? (start - stop + 1) : (seq_len - start + stop + 1);

: m_IsSetStrand(

),

part ==

.begin()? 0: *--part;

.m_Loc &&

.m_Loc->IsPnt();

( !

.m_Loc ) {

(

.m_Loc->Which() ) {

(

idx_begin,

idx_end)

;

.m_Loc &&

.m_Loc->IsBond();

( it->Contains(idx) ) {

( it->Contains(idx) ) {

vector<const SEquivSet*> sets;

( it->Contains(idx) ) {

sets.push_back(&*it);

( level >= sets.size() ) {

<<level);

*sets[level];

: m_HasChanges(

),

m_EmptyFlag(empty_flag),

m_HasChanges(

),

<

Container>

( cont.size()+add_size > cont.capacity() ) {

cont.reserve(

(cont.size()+add_size, cont.capacity()*2));

( loc.

() ) {

part_start =

.size();

part_end =

.size();

( part_start != part_end ) {

eq_set.

.push_back(part_end-start);

( !eq_set.

.empty() ) {

<<

( eq_end <= begin || eq_begin >= end ) {

( eq_begin > begin && eq_begin < end ) {

ret =

(ret, eq_begin);

ret == end? 0: ret;

( eq_begin < begin || eq_end > end ) {

( used_equivs.

(&eq_set) != used_equivs.

() ) {

( !ret ||

()(ret, &eq_set) ) {

( idx < start_index ) {

= idx - start_index;

prev_offset = 0;

( *it2 == prev_offset ) {

(idx > start && idx <= end) || (idx == start && idx == 0);

( idx <

.size() ) {

( loc->

() ) {

vector<SEquivSet*> add_to_set_mid;

( idx == eq_start &&

( !add_to_set_beg ||

()(&eq_set, add_to_set_beg) ) {

add_to_set_beg = &eq_set;

( idx == eq_end &&

( !add_to_set_end ||

()(&eq_set, add_to_set_end) ) {

add_to_set_end = &eq_set;

( idx > eq_start && idx < eq_end ) {

add_to_set_mid.push_back(&eq_set);

( idx <= eq_start ) {

(add_to_set_mid.begin(), add_to_set_mid.end(),

());

( add_to_set_beg ) {

add_to_set_beg->

.insert(add_to_set_beg->

.begin(), 1);

( add_to_set_end ) {

add_to_set_end->

.push_back(add_to_set_end->

.back()+1);

++add_to_set_end->

.back();

!add_to_set_mid.empty() ) {

& eq_set = **add_to_set_mid.begin();

add_to_set_mid.erase(add_to_set_mid.begin());

( ; it != eq_set.

.end(); ++it ) {

( vector<SEquivSet*>, set_it, add_to_set_mid ) {

( ; it != eq_set.

.end(); ++it ) {

eq_set.

.push_back(1);

(

.m_Range.GetLength() != 1 ) {

(

.m_Fuzz.first !=

.m_Fuzz.second ) {

( !

.m_IdHandle ) {

(

.m_Range.Empty() ||

.m_Range.IsWhole() ) {

( !

.m_IdHandle ) {

= idx_end - idx_begin;

(

(idx_begin) != make_pair(idx_begin, idx_end) ) {

(

idx = idx_begin; idx < idx_end; ++idx ) {

( idx > 0 &&

[idx-1].m_Loc == loc ) {

);

( idx = range.first; idx < range.second; ++idx ) {

pair<size_t, size_t> range;

bond_len = range.second-range.first;

( bond_len > 0 ) {

( idx != range.first ) {

);

( bond_len == 1 ) {

( idx = range.first+1; idx < range.second; ++idx ) {

);

pair<size_t, size_t> range;

bond_len = range.second-range.first;

( bond_len > 0 ) {

( idx != range.first ) {

);

( bond_len == 2 ) {

( bond_len > 2 ) {

( idx = range.first+2; idx < range.second; ++idx ) {

);

pair<size_t, size_t> range;

bond_len = range.second-range.first;

( bond_len > 0 ) {

( range.first != idx + 1 ) {

);

( bond_len == 2 ) {

( bond_len > 2 ) {

( idx = range.first+2; idx < range.second; ++idx ) {

idx_end)

( idx_begin+1 < idx_end ) {

( !

.m_IdHandle ) {

);

(

.m_IsSetStrand ) {

(

.m_Fuzz.first ) {

(

.m_Loc ) {

(

.m_Loc->Which() ) {

.m_Loc =

;

seq_int->

(

.m_Range.GetTo());

(

.m_IsSetStrand ) {

(

.m_Fuzz.first ) {

(

.m_Fuzz.second ) {

(

.m_Range.IsWhole() ) {

( !

.m_Range.Empty() ) {

);

(

.m_IdHandle ) {

(

.m_Range.IsWhole() ||

.m_Range.Empty() ) {

idx_end)

(idx_end >= idx_begin);

( idx_end == idx_begin ) {

(

idx = idx_begin; idx < idx_end; ++idx ) {

( idx != idx_begin ) {

(

.m_Fuzz.first != info0.

.first ) {

idx_end)

(idx_end >= idx_begin);

(

idx = idx_begin; idx < idx_end; ++idx ) {

idx_end)

( info0.

.first ) {

pnts.

().reserve(idx_end-idx_begin);

(

idx = idx_begin; idx < idx_end; ++idx ) {

idx_end)

(

idx = idx_begin; idx < idx_end; ++idx ) {

( !loc->

() ) {

loc->

().Set().push_back(loc1);

loc->

().Set().push_back(loc2);

used_equivs.

(eq_set);

idx = eq_set->GetStartIndex();

( idx > idx_begin ) {

loc =

(idx_begin, idx, make_type, used_equivs);

part_end = eq_set->GetPartEndIndex(it);

(idx, part_end, make_type, used_equivs);

equiv.

().push_back(part_loc);

( idx < idx_end ) {

loc2 =

(idx, idx_end, make_type, used_equivs);

( loc2->

() ) {

);

( idx_begin == idx_end ) {

idx_end - idx_begin > 1 ) {

(

idx = idx_begin; idx < idx_end; ++idx ) {

( range.first < idx || range.second > idx_end ||

!

(range.first, range.second) ) {

idx = range.second-1;

( (!

.m_Loc ||

.m_Loc->IsInt()) &&

: m_Impl(iter.m_Impl),

: m_Impl(iter.m_Impl),

m_Index(iter.m_Index)

!(*

== iter);

pair<CSeq_loc_CI, CSeq_loc_CI>

make_pair(

(*

, indexes.first),

pair<CSeq_loc_CI, CSeq_loc_CI>

make_pair(

(*

, indexes.first),

pair<CSeq_loc_CI, CSeq_loc_CI>

make_pair(

(*

, indexes.first),

);

(

.m_Loc ) {

(

.m_Loc->Which() ) {

);

;

<<pos<<

<<

());

:

(loc, eEmpty_Allow, eOrder_Biological)

;

.m_Id =

.GetSeqId();

.m_IdHandle = id;

.m_Range.SetFrom(pos).SetLength(1);

.SetStrand(strand);

.m_Range = range;

.SetStrand(strand);

(

.m_IdHandle !=

) {

(

.m_Range != range ) {

.m_Range = range;

(

.m_Range.GetFrom() != from ) {

.m_Range.SetFrom(from);

(

.m_Range.GetTo() != to ) {

.m_Range.SetTo(to);

(

.m_IsSetStrand ) {

.m_IsSetStrand =

;

( !

.m_IsSetStrand ||

.m_Strand != strand ) {

.SetStrand(strand);

(

.m_Fuzz.first ) {

.m_Fuzz.first =

;

( !

.m_Fuzz.first || !

.m_Fuzz.first->Equals(fuzz) ) {

(

.m_Fuzz.second ) {

.m_Fuzz.second =

;

( !

.m_Fuzz.second || !

.m_Fuzz.second->Equals(fuzz) ) {

(

.m_Fuzz.first ||

.m_Fuzz.second ) {

.m_Fuzz.first =

.m_Fuzz.second =

;

( !

.m_Fuzz.first || !

.m_Fuzz.first->Equals(fuzz) ||

.m_Fuzz.first !=

.m_Fuzz.second ) {

pair<CSeq_loc_I, CSeq_loc_I>

make_pair(

(*

, indexes.first),

pair<CSeq_loc_I, CSeq_loc_I>

make_pair(

(*

, indexes.first),

.WriteAsFasta(os);

( !last_id || !last_id->

(pnt.

()) ) {

*

+= GetTypeInfo_enum_ENa_strand()

last_id = &pnt.

();

(!last_id || !last_id->

(itval.

())) {

last_id = &itval.

();

=

);

(loc.

()) {

( !

.empty() ) {

*

+=

;

*

+=

;

(

()) {

(

()) {

(

()) {

(

()) {

(

()) {

(

()) {

(

()) {

(

()) {

(

()) {

(*iter)->SetId(

);

(*iter)->SetId(

);

(*iter)->SetId(

);

<<

);

(

() ) {

( !(*li)->CheckId(

, may_throw) ) {

( !(*li)->CheckId(

, may_throw) ) {

<<

(

() ) {

mix.

().push_back(ival);

(

() ) {

(

().IsSetFuzz()) {

vector<CRef<CSeq_loc> > sub_locs;

new_sub_loc->

(**orig_sub_loc);

sub_locs.push_back(new_sub_loc);

((*sub_loc)->GetPacked_int().Get().begin(),

(*sub_loc)->GetPacked_int().Get().end(),

<<

( other.

() ) {

( other.

() ) {

<

T1,

T2>

* id1 = obj1.CanGetId() ? &obj1.GetId() : 0;

* id2 = obj2.CanGetId() ? &obj2.GetId() : 0;

(id1 == 0 && id2 == 0)

;

(id1 == 0 || id2 == 0 || !id1->

(*id2) ) {

* f1 = obj1.CanGetFuzz() ? &obj1.GetFuzz() : 0;

* f2 = obj2.CanGetFuzz() ? &obj2.GetFuzz() : 0;

(f1 == 0 && f2 == 0)

;

(f1 == 0 || f2 == 0 || !f1->

(*f2)) {

( loc1.

() ) {

( loc2.

() ) {

( loc2.

() ) {

(

() ) {

( other.

() ) {

( other.

() ) {

<<

(

() ) {

(old_from == rg.GetFrom()) {

(old_to !=

()) {

(old_to == rg.GetTo()) {

(old_to !=

()) {

copy_from_cref;

(copy_from == fuzz) copy_from_cref.

(copy_from);

new_fuzz->

(*copy_from);

fuzz.

(new_fuzz);

& other,

( fz.

() ) {

other_rev =

(other_strand);

( fz.

() ) {

((!this_rev && other_lt) ||

(this_rev && other_gt)) {

((!this_rev && other_gt) ||

(this_rev && other_lt)) {

(other_lim == this_lim) {

new_fuzz->

().insert(

new_fuzz->

().end(),

(min1 > min2 || max1 < max2) {

(fz.

() < pm) {

(fz.

() < pct) {

CSeq_id_Handle_Wrapper

(

.IsLocal() &&

.GetLocal().IsStr()) {

== handle.m_Handle;

!= handle.m_Handle;

(

CSeq_id_Handle_Wrapper& handle)

( rg1.IsWhole() ) {

!rg2.IsWhole();

( rg1.Empty() ) {

!rg2.Empty() && !rg2.IsWhole();

!rg2.IsWhole() && !rg2.Empty() && rg1 < rg2;

( rg1.IsWhole() ) {

!rg2.IsWhole();

( rg1.Empty() ) {

!rg2.Empty() && !rg2.IsWhole();

( rg2.IsWhole() || rg2.Empty() ) {

(rg1.GetTo() != rg2.GetTo()) {

rg1.GetTo() > rg2.GetTo();

rg1.GetFrom() < rg2.GetFrom();

(rg1.GetFrom() <= rg2.GetFrom() && rg1.GetTo() >= rg2.GetTo()) {

(rg1.GetFrom() == rg2.GetFrom()) {

rg1.AddFuzzFrom(rg2);

(rg1.GetTo() == rg2.GetTo()) {

(rg1.GetFrom() >= rg2.GetFrom() && rg1.GetTo() <= rg2.GetTo()) {

same_from = rg1.GetFrom() == rg2.GetFrom();

same_to = rg1.GetTo() == rg2.GetTo();

rg1.AddFuzzFrom(rg2);

rg1.IntersectingWith(rg2) ) {

( rg1.GetToOpen() == rg2.GetFrom() ) {

(rg1.GetFrom() == rg2.GetToOpen()) {

CSeq_id_Handle_Wrapper& idh,

( !dst.

() ) {

(dst.

()) {

->Assign(*idh.GetSeqId());

( rg.IsWhole() ) {

(dst.

()) {

->SetWhole(*

);

( rg.Empty() ) {

(dst.

()) {

->SetEmpty(*

);

( rg.GetLength() == 1 &&

rg.IsSetFuzzFrom() == rg.IsSetFuzzTo() &&

( !rg.IsSetFuzzFrom() ||

rg.GetFuzzFrom().Equals(rg.GetFuzzTo()) ) )

pnt->

(*

);

( rg.IsSetFuzzFrom() ) {

pnt->

().Assign(rg.GetFuzzFrom());

}

( rg.IsSetFuzzTo() ) {

pnt->

().Assign(rg.GetFuzzTo());

(dst.

()) {

dst.

().Set().push_back(pnt_loc);

(dst.

()) {

ival.

(rg.GetTo());

ival.

().Assign(*

);

( rg.IsSetFuzzFrom() ) {

( rg.IsSetFuzzTo() ) {

dst.

().Set().push_back(int_loc);

( rg.IsSetFuzzFrom() ) {

( rg.IsSetFuzzTo() ) {

interval->

().Assign(rg.GetFuzzTo());

CSeq_id_Handle_Wrapper first_id;

CSeq_id_Handle_Wrapper next_id(syn_mapper.

(it.GetSeq_id()), it.GetSeq_id());

(next_id && first_id != next_id) {

);

first_strand = it.GetStrand();

->Assign(*first_id.GetSeqId());

( total_rg.IsSetFuzzFrom() ) {

interval->

().Assign(total_rg.GetFuzzFrom());

( total_rg.IsSetFuzzTo() ) {

interval->

().Assign(total_rg.GetFuzzTo());

( !id_it->first ) {

->Assign(*id_it->first.GetSeqId());

& ranges = id_it->second;

have_range =

;

*rg, default_strand,

(dst, id_it->first, last_rg, default_strand);

(dst, id_it->first, last_rg, default_strand);

CSeq_id_Handle_Wrapper last_id;

have_range =

;

CSeq_id_Handle_Wrapper idh(syn_mapper.

(it.GetSeq_id()), it.GetSeq_id());

( have_range && last_id == idh ) {

last_strand = it.GetStrand();

unique_ptr<TIdToRangeMap> pid_map_minus(use_strand ?

*pid_map_minus.get() : id_map_plus;

CSeq_id_Handle_Wrapper idh(syn_mapper.

(it.GetSeq_id()), it.GetSeq_id());

default_minus = strand;

(default_minus != strand) {

default_plus = strand;

(default_plus != strand) {

CSeq_id_Handle_Wrapper first_id;

CSeq_id_Handle_Wrapper next_id(syn_mapper.

(it.GetSeq_id()), it.GetSeq_id());

(next_id && first_id != next_id) {

);

first_strand = it.GetStrand();

(it_range.GetFrom() >= total_rg.GetFrom() &&

it_range.GetTo() <= total_rg.GetTo()) {

( it_range.IsWhole() ) {

it_range.SetOpen(0, len_getter.

(it.GetSeq_id()));

it_range.ResetFuzzFrom();

it_range.ResetFuzzTo();

rg_coll_minus : rg_coll_plus;

(id_it != rg_coll.

()) {

it_rg_coll -= id_it->second;

(curr_rg.GetFrom() == it_range.GetFrom()) {

curr_rg.AddFuzzFrom(it_range);

(curr_rg.GetTo() == it_range.GetTo()) {

curr_rg.AddFuzzTo(it_range);

& fm_from =

(it.GetStrand()) ? fuzz_from_minus : fuzz_from_plus;

(subtr_fuzz != fm_from.

()) {

curr_rg.AddFuzzTo(*subtr_fuzz->second, it.GetStrand());

& fm_to =

(it.GetStrand()) ? fuzz_to_minus : fuzz_to_plus;

subtr_fuzz = fm_to.

(curr_rg.GetFrom());

(subtr_fuzz != fm_to.

()) {

curr_rg.AddFuzzFrom(*subtr_fuzz->second, it.GetStrand());

total_rg += curr_rg;

->Assign(*first_id.GetSeqId());

( total_rg.IsSetFuzzFrom() ) {

fuzz->

(total_rg.GetFuzzFrom());

( total_rg.IsSetFuzzTo() ) {

fuzz->

(total_rg.GetFuzzTo());

CSeq_id_Handle_Wrapper last_id;

have_range =

;

CSeq_id_Handle_Wrapper idh(syn_mapper.

(it.GetSeq_id()), it.GetSeq_id());

( it_range.IsWhole() ) {

it_range.SetOpen(0, len_getter.

(it.GetSeq_id()));

rg_coll_minus : rg_coll_plus;

list<TRangeWithFuzz> result_ranges;

modified =

;

(id_it != rg_coll.

()) {

it_rg_coll -= id_it->second;

result_ranges.push_front(*result_it);

result_ranges.push_back(*result_it);

(list<TRangeWithFuzz>, rg_it, result_ranges) {

(curr_rg.GetFrom() == it_range.GetFrom()) {

curr_rg.AddFuzzFrom(it_range);

(curr_rg.GetTo() == it_range.GetTo()) {

curr_rg.AddFuzzTo(it_range);

& fm_from =

(it.GetStrand()) ? fuzz_from_minus : fuzz_from_plus;

(subtr_fuzz != fm_from.

()) {

curr_rg.AddFuzzTo(*subtr_fuzz->second, it.GetStrand());

& fm_to =

(it.GetStrand()) ? fuzz_to_minus : fuzz_to_plus;

subtr_fuzz = fm_to.

(curr_rg.GetFrom());

(subtr_fuzz != fm_to.

()) {

curr_rg.AddFuzzFrom(*subtr_fuzz->second, it.GetStrand());

( have_range && last_id == idh ) {

last_strand = it.GetStrand();

merged =

;

(last_id == idh) {

last_strand = it.GetStrand();

unique_ptr<TIdToRangeMap> p_id_map_minus(use_strand ?

*p_id_map_minus.get() : id_map_plus;

CSeq_id_Handle_Wrapper idh(syn_mapper.

(it.GetSeq_id()), it.GetSeq_id());

( it_range.IsWhole() ) {

it_range.SetOpen(0, len_getter.

(it.GetSeq_id()));

it_range.ResetFuzzFrom();

it_range.ResetFuzzTo();

id_map_minus[idh] : id_map_plus[idh];

rg_coll_minus : rg_coll_plus;

modified =

;

(id_it != rg_coll.

()) {

it_rg_coll -= id_it->second;

(curr_rg.GetFrom() == it_range.GetFrom()) {

curr_rg.AddFuzzFrom(it_range);

(curr_rg.GetTo() == it_range.GetTo()) {

curr_rg.AddFuzzTo(it_range);

& fm_from =

(it.GetStrand()) ? fuzz_from_minus : fuzz_from_plus;

(subtr_fuzz != fm_from.

()) {

curr_rg.AddFuzzTo(*subtr_fuzz->second, it.GetStrand());

& fm_to =

(it.GetStrand()) ? fuzz_to_minus : fuzz_to_plus;

subtr_fuzz = fm_to.

(curr_rg.GetFrom());

(subtr_fuzz != fm_to.

()) {

curr_rg.AddFuzzFrom(*subtr_fuzz->second, it.GetStrand());

rg_map.push_back(curr_rg);

rg_map.push_back(it_range);

unique_ptr<CDummySynonymMapper> p_mapper;

( !syn_mapper ) {

syn_mapper = p_mapper.get();

unique_ptr<CDummySynonymMapper> p_mapper;

( !syn_mapper ) {

syn_mapper = p_mapper.get();

.SetMix().AddSeqLoc(

&

(*

));

.SetMix().AddSeqLoc(

&

(other));

unique_ptr<CDummySynonymMapper> p_mapper;

( !syn_mapper ) {

syn_mapper = p_mapper.get();

unique_ptr<CDummyLengthGetter> p_getter;

( !len_getter ) {

len_getter = p_getter.get();

unique_ptr<TIdToRangeColl> p_rg_coll_minus(use_strand ?

*p_rg_coll_minus.get() : rg_coll_plus;

fuzz_from_plus, fuzz_from_minus, fuzz_to_plus, fuzz_to_minus;

( it.IsEmpty() ) {

CSeq_id_Handle_Wrapper idh(syn_mapper->

(it.GetSeq_id()), it.GetSeq_id());

rg_coll_minus[idh] : rg_coll_plus[idh];

* fuzz = it.GetFuzzFrom();

(it.IsSetStrand() &&

(it.GetStrand())) {

fuzz_from_minus[it.GetRange().GetFrom()].Reset(fuzz);

fuzz_from_plus[it.GetRange().GetFrom()].Reset(fuzz);

fuzz = it.GetFuzzTo();

(it.IsSetStrand() &&

(it.GetStrand())) {

fuzz_to_minus[it.GetRange().GetToOpen()].Reset(fuzz);

fuzz_to_plus[it.GetRange().GetToOpen()].Reset(fuzz);

fuzz_from_plus, fuzz_from_minus, fuzz_to_plus, fuzz_to_minus,

fuzz_from_plus, fuzz_from_minus, fuzz_to_plus, fuzz_to_minus,

fuzz_from_plus, fuzz_from_minus, fuzz_to_plus, fuzz_to_minus,

syn_mapper, len_getter.get());

(

() ) {

(

() ) {

User-defined methods of the data storage class.

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'

EIsSetStrand

Flag used by IsSetStrand() to switch between any/all modes.

User-defined methods of the data storage class.

void x_Assign(CInt_fuzz &dst, const CInt_fuzz &src)

int s_CompareIntervals(const Container1 &container1, const Container2 &container2, bool minus_strand, const CSeq_loc::ISubLocFilter *filter)

static void x_RangesToSeq_loc(CSeq_loc &dst, TIdToRangeMap &id_map, ENa_strand default_strand, CSeq_loc::TOpFlags flags)

static bool x_MatchStrand(ENa_strand str1, ENa_strand str2, CSeq_loc::TOpFlags flags)

map< CSeq_id_Handle_Wrapper, TRanges > TIdToRangeMap

static void x_SubAndSort(CSeq_loc &dst, const CSeq_loc &minuend, const TFuzzMap &fuzz_from_plus, const TFuzzMap &fuzz_from_minus, const TFuzzMap &fuzz_to_plus, const TFuzzMap &fuzz_to_minus, TIdToRangeColl &rg_coll_plus, TIdToRangeColl &rg_coll_minus, ISynonymMapper &syn_mapper, ILengthGetter &len_getter, CSeq_loc::TOpFlags flags)

vector< TRangeWithFuzz > TRanges

static bool s_InsertExpands(size_t idx, size_t start, size_t end)

map< TSeqPos, CConstRef< CInt_fuzz > > TFuzzMap

static void x_MergeNoSort(CSeq_loc &dst, const CSeq_loc &src, CSeq_loc::TOpFlags flags, ISynonymMapper &syn_mapper)

CRangeWithFuzz TRangeWithFuzz

void s_GetLabel(const CSeq_id &id, string *label)

static int s_CompareRanges(const COpenRange< TSeqPos > &x_rng, const COpenRange< TSeqPos > &y_rng, bool minus_strand)

static void x_SubNoSort(CSeq_loc &dst, const CSeq_loc &minuend, const TFuzzMap &fuzz_from_plus, const TFuzzMap &fuzz_from_minus, const TFuzzMap &fuzz_to_plus, const TFuzzMap &fuzz_to_minus, TIdToRangeColl &rg_coll_plus, TIdToRangeColl &rg_coll_minus, ISynonymMapper &syn_mapper, ILengthGetter &len_getter, CSeq_loc::TOpFlags flags)

static CRef< CSeq_id > MakeId(const SSeq_loc_CI_RangeInfo &info)

static void s_ReserveMore(Container &cont, size_t add_size)

static void x_MergeAndSort(CSeq_loc &dst, const CSeq_loc &src, CSeq_loc::TOpFlags flags, ISynonymMapper &syn_mapper)

static bool s_CheckIfMatchesBioseq(const CSeq_loc &loc, const CSeq_loc::ISubLocFilter *filter)

static void AddLoc(CRef< CSeq_loc > &loc, CRef< CSeq_loc > loc2)

map< CSeq_id_Handle_Wrapper, TRangeColl > TIdToRangeColl

CRangeCollection< TSeqPos > TRangeColl

bool s_CanAdd(const T1 &obj1, const T2 &obj2)

static bool x_MergeRanges(TRangeWithFuzz &rg1, ENa_strand str1, const TRangeWithFuzz &rg2, ENa_strand str2, CSeq_loc::TOpFlags flags)

static CRange< TSeqPos > s_LocToRange(const CSeq_loc &loc)

static void x_SingleRange(CSeq_loc &dst, const CSeq_loc &src, ISynonymMapper &syn_mapper)

static void x_PushRange(CSeq_loc &dst, const CSeq_id_Handle_Wrapper &idh, const TRangeWithFuzz &rg, ENa_strand strand)

virtual ~CDummyLengthGetter(void)

virtual TSeqPos GetLength(const CSeq_id &)

virtual CSeq_id_Handle GetBestSynonym(const CSeq_id &id)

CDummySynonymMapper(void)

virtual ~CDummySynonymMapper(void)

void GetLabel(string *label, TSeqPos pos, bool right=true) const

CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:

void ResetStrand(void)

Reset the strand to 'not set'.

bool IsPartialStop(ESeqLocExtremes ext) const

void SetPartialStart(bool val, ESeqLocExtremes ext)

TSeqPos GetStop(ESeqLocExtremes ext) const

void SetTruncatedStart(bool val, ESeqLocExtremes ext)

set / remove e_Lim fuzz on start or stop (tl/tr - indicating removed parts of the seq-loc)

void FlipStrand(void)

Flip the strand (e.g. plus to minus)

bool IsTruncatedStart(ESeqLocExtremes ext) const

check if parts of the seq-loc are missing

void AddIntervals(const CPacked_seqint &ivals)

void SetTruncatedStop(bool val, ESeqLocExtremes ext)

TSeqPos GetStart(ESeqLocExtremes ext) const

void SetPartialStop(bool val, ESeqLocExtremes ext)

bool IsPartialStart(ESeqLocExtremes ext) const

bool IsSetStrand(EIsSetStrand flag=eIsSetStrand_Any) const

bool IsTruncatedStop(ESeqLocExtremes ext) const

ENa_strand GetStrand(void) const

void SetStrand(ENa_strand strand)

Set the strand for all of the location's ranges.

void AddInterval(const CSeq_interval &ival)

for convenience

bool IsTruncatedStop(ESeqLocExtremes ext) const

void SetPartialStop(bool val, ESeqLocExtremes ext)

void SetPartialStart(bool val, ESeqLocExtremes ext)

void SetTruncatedStart(bool val, ESeqLocExtremes ext)

set / remove e_Lim fuzz on start or stop (tl/tr - indicating removed parts of the seq-loc)

bool IsPartialStop(ESeqLocExtremes ext) const

TSeqPos GetStop(ESeqLocExtremes ext) const

void AddPoint(TSeqPos point)

bool IsPartialStart(ESeqLocExtremes ext) const

void SetTruncatedStop(bool val, ESeqLocExtremes ext)

void AddPoints(const TPoints &points)

bool IsTruncatedStart(ESeqLocExtremes ext) const

check if parts of the seq-loc are missing

TSeqPos GetStart(ESeqLocExtremes ext) const

bool IntersectingWith(const TRange &r) const

void AddFuzzFrom(const CRangeWithFuzz &rg)

void AddFuzzFrom(const CInt_fuzz &fuzz, ENa_strand strand)

CConstRef< CInt_fuzz > TFuzz

bool IsSetFuzzFrom(void) const

CRef< CInt_fuzz > x_SetFuzz(TFuzz &fuzz, const CInt_fuzz *copy_from)

const CInt_fuzz & GetFuzzTo(void) const

void x_AddFuzz(TFuzz &fuzz, const TFuzz &other, ENa_strand other_strand)

const CInt_fuzz & GetFuzzFrom(void) const

bool IsSetFuzzTo(void) const

CRangeWithFuzz(const TParent &rg)

void AddFuzzTo(const CRangeWithFuzz &rg)

void CopyTo(const CRangeWithFuzz &rg)

CRangeWithFuzz(const CSeq_loc_CI &it)

void AddFuzzTo(const CInt_fuzz &fuzz, ENa_strand strand)

void CopyFrom(const CRangeWithFuzz &rg)

bool operator()(const TRangeWithFuzz &rg1, const TRangeWithFuzz &rg2) const

bool operator()(const TRangeWithFuzz &rg1, const TRangeWithFuzz &rg2) const

bool IsSetStrand(EIsSetStrand flag=eIsSetStrand_Any) const

TSeqPos GetStop(ESeqLocExtremes ext) const

ENa_strand GetStrand(void) const

TSeqPos GetStart(ESeqLocExtremes ext) const

CSeq_id_Handle_Wrapper(const CSeq_id_Handle &idh, const CSeq_id &id)

const CSeq_id_Handle & GetHandle(void) const

CConstRef< CSeq_id > GetSeqId(void) const

CConstRef< CSeq_id > m_Id

DECLARE_OPERATOR_BOOL(m_Handle)

CSeq_id_Handle_Wrapper(void)

bool IsTruncatedStop(ESeqLocExtremes ext) const

bool IsPartialStop(ESeqLocExtremes ext) const

void SetTruncatedStart(bool val, ESeqLocExtremes ext)

set / remove e_Lim fuzz on start or stop (tl/tr - indicating removed parts of the seq-loc)

TSeqPos GetStart(ESeqLocExtremes ext) const

bool IsPartialStart(ESeqLocExtremes ext) const

bool IsTruncatedStart(ESeqLocExtremes ext) const

check if parts of the seq-loc are missing

TSeqPos GetStop(ESeqLocExtremes ext) const

void SetTruncatedStop(bool val, ESeqLocExtremes ext)

void SetPartialStart(bool val, ESeqLocExtremes ext)

void SetPartialStop(bool val, ESeqLocExtremes ext)

Used as a helper for determining which pieces of a CSeq_loc to compare.

bool IsInBond(size_t idx) const

CRef< CSeq_loc > MakeLocPacked_int(size_t idx_begin, size_t idx_end) const

CSeq_loc_I::EEquivMode m_EquivMode

CRef< CSeq_loc > MakeLoc(CSeq_loc_I::EMakeType make_type) const

void MakeBondB(size_t idx)

pair< size_t, size_t > GetEquivPartRange(size_t idx, size_t level) const

bool IsEnd(size_t idx) const

bool CanBePoint(size_t idx) const

pair< size_t, size_t > GetBondRange(size_t idx) const

void x_AddBondPartB(size_t idx)

void MakeBondAB(size_t idx)

size_t HasEquivBreak(size_t begin, size_t end) const

void RemoveBond(size_t idx)

CRef< CSeq_loc > MakeRangeLoc(const SSeq_loc_CI_RangeInfo &info) const

vector< SSeq_loc_CI_RangeInfo > TRanges

CRef< CSeq_loc > MakeLocOther(const SSeq_loc_CI_RangeInfo &info) const

void x_ProcessLocation(const CSeq_loc &loc)

CConstRef< CSeq_loc > m_Location

CRef< CSeq_loc > MakeLocBond(size_t idx_begin, size_t idx_end) const

vector< SEquivSet > TEquivSets

void x_CreateBond(size_t idx)

bool CanBePoint(const SSeq_loc_CI_RangeInfo &info) const

static void x_SetId(SSeq_loc_CI_RangeInfo &info, const CSeq_id &id)

CRef< CSeq_loc > MakeLocPoint(const SSeq_loc_CI_RangeInfo &info) const

void UpdatePoint(CSeq_point &pnt, const SSeq_loc_CI_RangeInfo &info) const

CSeq_loc_I::EEquivMode GetEquivMode(void) const

bool CanBeBond(size_t idx_begin, size_t idx_end) const

void SetEquivMode(CSeq_loc_I::EEquivMode mode)

bool WasPoint(const SSeq_loc_CI_RangeInfo &info) const

TRanges & GetRanges(void)

void UpdateLoc(SSeq_loc_CI_RangeInfo &info)

const TRanges & GetRanges(void) const

size_t GetBondBegin(size_t idx) const

virtual ~CSeq_loc_CI_Impl(void)

void SetPoint(SSeq_loc_CI_RangeInfo &info)

void x_ProcessInterval(const CSeq_interval &seq_int, const CSeq_loc &loc)

void x_ProcessPoint(const CSeq_point &seq_pnt, const CSeq_loc &loc)

void x_BreakBond(size_t idx)

CSeq_loc_CI_Impl & operator=(const CSeq_loc_CI_Impl &)

set< const SEquivSet * > TUsedEquivs

CRef< CSeq_interval > MakeInterval(const SSeq_loc_CI_RangeInfo &info) const

void DeleteRange(size_t idx)

bool CanBePacked_int(size_t idx_begin, size_t idx_end) const

bool CanBeInterval(const SSeq_loc_CI_RangeInfo &info) const

pair< size_t, size_t > GetEquivSetRange(size_t idx, size_t level) const

bool IsBondPartB(size_t idx) const

bool IsInEquivSet(size_t idx) const

const SEquivSet * FindInnerEquivSet(size_t begin, size_t end, const TUsedEquivs &used_equivs) const

CSeq_loc_CI::EEmptyFlag m_EmptyFlag

CSeq_loc_CI_Impl(const CSeq_loc_CI_Impl &)

void MakeBondA(size_t idx)

bool CanBePacked_pnt(size_t idx_begin, size_t idx_end) const

bool HasEquivSets(void) const

SSeq_loc_CI_RangeInfo::TRange TRange

const SEquivSet & GetEquivSet(size_t idx, size_t level) const

bool ShouldBePoint(const SSeq_loc_CI_RangeInfo &info) const

bool IsBondPartA(size_t idx) const

CRef< CSeq_point > MakePoint(const SSeq_loc_CI_RangeInfo &info) const

bool IsInBond(const SSeq_loc_CI_RangeInfo &info) const

CRef< CInt_fuzz > MakeFuzz(const CInt_fuzz &fuzz) const

CRef< CSeq_loc > MakeLocPacked_pnt(size_t idx_begin, size_t idx_end) const

SSeq_loc_CI_RangeInfo & InsertRange(size_t idx, CSeq_loc::E_Choice type)

size_t GetBondEnd(size_t idx) const

bool CanBeInterval(size_t idx) const

CRef< CSeq_loc > MakeLocInterval(const SSeq_loc_CI_RangeInfo &info) const

size_t GetEquivSetsCount(size_t idx) const

bool HasChanges(void) const

Seq-loc iterator class – iterates all intervals from a seq-loc in the correct order.

Seq-loc iterator class – iterates all intervals from a seq-loc in the correct order.

void Add(const CSeq_loc &loc)

void SetPartialStart(bool val, ESeqLocExtremes ext)

bool IsTruncatedStop(ESeqLocExtremes ext) const

void SetPartialStop(bool val, ESeqLocExtremes ext)

void ResetStrand(void)

Reset the strand to 'not set'.

bool IsSetStrand(EIsSetStrand flag=eIsSetStrand_Any) const

void SetTruncatedStart(bool val, ESeqLocExtremes ext)

set / remove e_Lim fuzz on start or stop (tl/tr - indicating removed parts of the seq-loc)

TSeqPos GetStop(ESeqLocExtremes ext) const

void AddSeqLoc(const CSeq_loc &other)

bool IsPartialStart(ESeqLocExtremes ext) const

ENa_strand GetStrand(void) const

TSeqPos GetStart(ESeqLocExtremes ext) const

bool IsPartialStop(ESeqLocExtremes ext) const

void SetStrand(ENa_strand strand)

Set the strand for all of the location's ranges.

bool IsTruncatedStart(ESeqLocExtremes ext) const

check if parts of the seq-loc are missing

void FlipStrand(void)

Flip the strand (e.g. plus to minus)

void SetTruncatedStop(bool val, ESeqLocExtremes ext)

bool IsPartialStart(ESeqLocExtremes ext) const

void SetTruncatedStart(bool val, ESeqLocExtremes ext)

set / remove e_Lim fuzz on start or stop (tl/tr - indicating removed parts of the seq-loc)

bool IsTruncatedStop(ESeqLocExtremes ext) const

bool IsPartialStop(ESeqLocExtremes ext) const

bool IsTruncatedStart(ESeqLocExtremes ext) const

check if parts of the seq-loc are missing

void SetPartialStart(bool val, ESeqLocExtremes ext)

void SetTruncatedStop(bool val, ESeqLocExtremes ext)

void SetPartialStop(bool val, ESeqLocExtremes ext)

Base class for all serializable objects.

Interface for getting bioseq length.

Interface for mapping IDs to the best synonym.

container_type::const_iterator const_iterator

const_iterator end() const

const_iterator find(const key_type &key) const

iterator_bool insert(const value_type &val)

const_iterator find(const key_type &key) const

const_iterator end() const

bool operator<(const CEquivRange &A, const CEquivRange &B)

bool operator==(const CEquivRange &A, const CEquivRange &B)

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static const char * str(char *buf, int n)

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define ERASE_ITERATE(Type, Var, Cont)

Non-constant version with ability to erase current element, if container permits.

#define VECTOR_ERASE(Var, Cont)

Use this macro inside body of ERASE_ITERATE cycle to erase from vector-like container.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

const TSeqPos kInvalidSeqPos

Define special value for invalid sequence position.

#define INT_ID_TO(T, id)

Convert gi-compatible int to/from other types.

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

void Error(CExceptionArgs_Base &args)

TErrCode GetErrCode(void) const

Get error code.

#define NCBI_THROW(exception_class, err_code, message)

Generic macro to throw an exception, given the exception class, error code and message string.

#define NCBI_THROW_FMT(exception_class, err_code, message)

The same as NCBI_THROW but with message processed as output to ostream.

virtual const char * GetErrCodeString(void) const

Get error code interpreted as text.

ESerialRecursionMode

How to assign and compare child sub-objects of serial objects.

virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)

Set object to copy of another one.

virtual const CTypeInfo * GetThisTypeInfo(void) const =0

C * SerialClone(const C &src)

Create on heap a clone of the source object.

virtual bool Equals(const CSerialObject &object, ESerialRecursionMode how=eRecursive) const

Check if both objects contain the same values.

@ eShallow

Assign/Compare pointers only.

const string AsFastaString(void) const

virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)

Optimized implementation of CSerialObject::Assign, which is not so efficient.

CConstRef< CSeq_id > GetSeqId(void) const

int CompareOrdered(const CSeq_id &sid2) const

bool Match(const CSeq_id &sid2) const

Match() - TRUE if SeqIds are equivalent.

static CSeq_id_Handle GetHandle(const CSeq_id &id)

Normal way of getting a handle, works for any seq-id.

void SetRange(const TRange &range)

Set the range.

bool IsBondA(void) const

Return true if current position is A part of a bond.

CRef< CSeq_loc > MakeSeq_loc(EMakeType make_type=eMake_CompactType) const

return constructed CSeq_loc with all changes

void SetTruncatedStart(bool val, ESeqLocExtremes ext)

set / remove e_Lim fuzz on start or stop (tl/tr - indicating removed parts of the seq-loc)

void SetPacked_int(TPacked_int &v)

size_t GetEquivSetsCount(void) const

Return number of recursuve equiv parts current position in.

virtual const char * x_GetIteratorType(void) const

void SetFrom(TSeqPos from)

Set the range from position.

void ResetFuzz(void)

Reset fuzz of a point.

void InvalidateCache(void) const

Combine invalidation of all cached values.

bool x_IsValid(void) const

CSeq_loc_CI(void)

constructors

void SetTo(TSeqPos to)

Set the range to position.

CSeq_loc_I InsertPoint(const CSeq_id_Handle &id, TSeqPos pos, ENa_strand strand=eNa_strand_unknown)

Insert new element before the current one (.

void SetPacked_pnt(TPacked_pnt &v)

bool IsPartialStart(ESeqLocExtremes ext) const

check start or stop of location for e_Lim fuzz

void Delete(void)

Delete current element, and make iterator to point to the next element.

void x_ChangeToPackedPnt(const CSeq_loc &other)

ENa_strand GetStrand(void) const

Get the location's strand.

void x_CheckValidForInsert(const char *where) const

CRange< TSeqPos > TRange

See related functions in objmgr/util/seq_loc_util.hpp:

void ChangeToPackedInt(void)

Works only if location is currently an interval, point, packed-int (handled trivially),...

bool x_UpdateId(const CSeq_id *&total_id, const CSeq_id *id, bool may_throw=true) const

TPacked_int & SetPacked_int(void)

bool IsReverseStrand(void) const

Return true if all ranges have reverse strand.

CSeq_loc_CI & operator=(const CSeq_loc_CI &iter)

EEmptyFlag

Options for empty locations processing.

void FlipStrand(void)

Flip the strand (e.g. plus to minus)

void MakeBondA(void)

Make bond at current position (only A) The current part must be a point If current posision is alread...

virtual void Assign(const CSerialObject &source, ESerialRecursionMode how=eRecursive)

Override Assign() to incorporate cache invalidation.

void SetId(CSeq_id &id)

set the 'id' field in all parts of this location

bool IsInEquivSet(void) const

Return true if current position is in some equiv part.

CSeq_loc_I(void)

constructors

atomic< TSeqPos > m_TotalRangeCacheFrom

void ResetStrand(void)

Reset the range strand.

void ResetFuzzTo(void)

Reset fuzz to.

void x_CheckValid(const char *where) const

EMakeType

Options for creation modified locations Bond and equiv types are preserved if possible.

void ResetFuzzFrom(void)

Reset fuzz from.

TRange GetTotalRange(void) const

virtual CSeq_id_Handle GetBestSynonym(const CSeq_id &id)=0

TSeqPos GetStart(ESeqLocExtremes ext) const

Return start and stop positions of the seq-loc.

pair< CSeq_loc_CI, CSeq_loc_CI > GetBondRange(void) const

Return iterators that cover bond of current position result.first is the first segment in the equiv s...

CConstRef< CSeq_loc > GetRangeAsSeq_loc(void) const

Get seq-loc for the current iterator position.

void MakeBondB(void)

Make bond at previous position with the current position (A and B) The current and previous parts mus...

pair< CConstRef< CInt_fuzz >, CConstRef< CInt_fuzz > > m_Fuzz

CRef< CSeq_loc > Merge(TOpFlags flags, ISynonymMapper *syn_mapper) const

All functions create and return a new seq-loc object.

void SetStrand(ENa_strand strand)

Set the range strand.

const CSeq_loc & GetSeq_loc(void) const

void MakeBondAB(void)

Make bond at current position with the next position (A and B) The current and next parts must be poi...

bool HasEquivSets(void) const

Return true if location has equiv parts.

TRange x_CalculateTotalRangeCheckId(const CSeq_id *&id) const

const_iterator end(void) const

const_iterator begin(void) const

void x_ChangeToMix(const CSeq_loc &other)

bool HasChanges(void) const

return true of any part was changed since initialization

int Compare(const CSeq_loc &loc) const

bool IsTruncatedStop(ESeqLocExtremes ext) const

void x_ChangeToPackedInt(const CSeq_interval &other)

int CompareSubLoc(const CSeq_loc &loc, ENa_strand strand, const ISubLocFilter *filter=NULL) const

Compare first-level sub-locations sequentially to order them by biological "complexity".

bool x_IsValidForInsert(void) const

void SetSeq_id_Handle(const CSeq_id_Handle &id)

Set seq_id of the current location.

void SetFuzz(CInt_fuzz &fuzz)

Change fuzz of a point.

void x_SetSeq_id_Handle(SSeq_loc_CI_RangeInfo &info, const CSeq_id_Handle &id)

void SetFuzzTo(CInt_fuzz &fuzz)

Change fuzz to values.

bool IsInBond(void) const

Location of type equiv define set of equivalent locations.

void Add(const CSeq_loc &other)

Simple adding of seq-locs.

void SetPoint(TSeqPos pos)

Set the range from and to positions.

~SSeq_loc_CI_RangeInfo(void)

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.

bool operator==(const CSeq_loc_CI &iter) const

bool IsTruncatedStart(ESeqLocExtremes ext) const

check if parts of the seq-loc are missing

TPacked_pnt & SetPacked_pnt(void)

bool IsSetStrand(EIsSetStrand flag=eIsSetStrand_Any) const

Check if strand is set for any/all part(s) of the seq-loc depending on the flag.

TSeqPos GetCircularLength(TSeqPos seq_len) const

Special case for circular sequences.

const CSeq_loc & GetEmbeddingSeq_loc(void) const

Get the nearest seq-loc containing the current range.

CSeq_loc_I InsertInterval(const CSeq_id_Handle &id, const TRange &range, ENa_strand strand=eNa_strand_unknown)

Insert new element before the current one (.

pair< CSeq_loc_CI, CSeq_loc_CI > GetEquivSetRange(size_t level=0) const

Return iterators that cover equiv set of current position result.first is the first segment in the eq...

void SetPos(size_t pos)

Set iterator's position.

CRef< CSeq_loc_CI_Impl > m_Impl

pair< CSeq_loc_I, CSeq_loc_I > GetEquivPartRange(size_t level=0) const

Return iterators that cover equiv part of current position result.first is the first segment in the e...

CPacked_seqint::TRanges TRanges

const CSeq_id * GetId(void) const

Get the id of the location return NULL if has multiple ids or no id at all.

void PostRead(void) const

Invalidate id/range cache after deserialization.

CPacked_seqpnt_Base::TPoints TPoints

atomic< const CSeq_id * > m_IdCache

size_t GetSize(void) const

Get number of ranges.

CSeq_id_Handle m_IdHandle

bool IsBondB(void) const

Return true if current position is B part of a bond.

void ResetStrand(void)

Reset the strand on this location.

void SetPartialStart(bool val, ESeqLocExtremes ext)

set / remove e_Lim fuzz on start or stop (lt/gt - indicating partial interval)

virtual TSeqPos GetLength(const CSeq_id &id)=0

void x_ThrowNotValid(const char *where) const

virtual const char * x_GetIteratorType(void) const

pair< CSeq_loc_CI, CSeq_loc_CI > GetEquivPartRange(size_t level=0) const

Return iterators that cover equiv part of current position result.first is the first segment in the e...

CSeq_loc_I InsertWhole(const CSeq_id_Handle &id)

Insert new element before the current one (.

const SSeq_loc_CI_RangeInfo & x_GetRangeInfo(void) const

void SetFuzzFrom(CInt_fuzz &fuzz)

Change fuzz from.

void RemoveBond(void)

Remove bond at current position - it may be either A or B part.

CRef< CSeq_loc > Intersect(const CSeq_loc &other, TOpFlags flags, ISynonymMapper *syn_mapper) const

Find the intersection with the seq-loc, merge/sort resulting ranges depending on flags.

bool operator!=(const CSeq_loc_CI &iter) const

EEquivMode

This enum defines a way equiv sets are expanded or created when one of Insert*() methods is called.

CSeq_loc_I InsertEmpty(const CSeq_id_Handle &id)

Insert new element before the current one (.

pair< CSeq_loc_I, CSeq_loc_I > GetEquivSetRange(size_t level=0) const

Return iterators that cover equiv set of current position result.first is the first segment in the eq...

const CSeq_id & GetSeq_id(void) const

Get seq_id of the current location.

TRange x_UpdateTotalRange(void) const

SSeq_loc_CI_RangeInfo(void)

void GetLabel(string *label) const

Appends a label suitable for display (e.g., error messages) label must point to an existing string ob...

void SetStrand(ENa_strand strand)

Set the strand for all of the location's ranges.

void SetEquivMode(EEquivMode mode)

Change equiv modification mode.

void SetPartialStop(bool val, ESeqLocExtremes ext)

CSeq_loc(void)

constructors

atomic< TSeqPos > m_TotalRangeCacheToOpen

int x_CompareSingleId(const CSeq_loc &loc, const CSeq_id *id1, const CSeq_id *id2, TCompareFlags flags) const

Compare single-id locations, or throw an exception if any location is multi-id.

SSeq_loc_CI_RangeInfo & x_GetRangeInfo(void)

virtual ~CSeq_loc_I(void)

destructor

EEquivMode GetEquivMode(void) const

Get equiv modification mode.

void SetNull(void)

Override all setters to incorporate cache invalidation.

bool IsPartialStop(ESeqLocExtremes ext) const

void SetTruncatedStop(bool val, ESeqLocExtremes ext)

virtual ~CSeq_loc_CI(void)

destructor

CSeq_loc_I InsertNull(void)

Set of Insert*() methods.

CConstRef< CSeq_loc > m_Loc

bool x_CheckId(const CSeq_id *&id, bool may_throw=true) const

TSeqPos GetStop(ESeqLocExtremes ext) const

virtual const char * GetErrCodeString(void) const override

Get error code interpreted as text.

@ eEmpty_Allow

ignore empty locations

@ eMake_PreserveType

use most compact Seq-loc type (default)

@ eEquiv_prepend

If the insertion point is just before any equiv part, including the first one in an equiv,...

@ eEquiv_new_part

New equiv part will be started with the inserted element.

@ eEquiv_new_equiv

A new equiv set will be created, even if the insertion point is already inside of an existing equiv,...

@ eEquiv_append

If the insertion point is just after any equiv part, including the last one in an equiv,...

@ eMultipleId

Seq-loc on multiple ids when one id is required.

@ eNotSet

Seq-loc is not set.

@ eIncomatible

Seq-loc type is incompatible with operation.

@ eBadLocation

Seq-loc is incorrectly formed.

@ eOutOfRange

parameter is out of valid range

@ eBadIterator

Seq-loc iterator is in bad state.

@ eUnsupported

Seq-loc has data that is not supported yet.

ENa_strand GetStrand(const CSeq_loc &loc, CScope *scope=0)

Returns eNa_strand_unknown if multiple Bioseqs in loc Returns eNa_strand_other if multiple strands in...

CConstRef< C > ConstRef(const C *object)

Template function for conversion of const object pointer to CConstRef.

CRef< C > Ref(C *object)

Helper functions to get CRef<> and CConstRef<> objects.

void Reset(void)

Reset reference object.

TObjectType * GetPointerOrNull(void) const THROWS_NONE

Get pointer value.

TObjectType * Release(void)

Release a reference to the object and return a pointer to the object.

position_type GetLength(void) const

position_type GetTo(void) const

position_type GetToOpen(void) const

position_type GetFrom(void) const

static TThisType GetEmpty(void)

TThisType & operator+=(const TThisType &r)

TThisType & Set(position_type from, position_type to)

static position_type GetWholeToOpen(void)

static TThisType GetWhole(void)

TParent::position_type position_type

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

bool operator!=(const CNCBI_IPAddr &lhs, unsigned int rhs)

static string IntToString(int value, TNumToStringFlags flags=0, int base=10)

Convert int to string.

static const char label[]

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.

void SetTo(TTo value)

Assign a value to To data member.

void SetMin(TMin value)

Assign a value to Min data member.

bool IsLim(void) const

Check if variant Lim is selected.

TRange & SetRange(void)

Select the variant.

TAlt & SetAlt(void)

Select the variant.

TPct GetPct(void) const

Get the variant data.

virtual void Reset(void)

Reset the whole object.

TLim GetLim(void) const

Get the variant data.

TP_m & SetP_m(void)

Select the variant.

TMin GetMin(void) const

Get the Min member data.

void SetMax(TMax value)

Assign a value to Max data member.

E_Choice Which(void) const

Which variant is currently selected.

TLim & SetLim(void)

Select the variant.

const TAlt & GetAlt(void) const

Get the variant data.

TPct & SetPct(void)

Select the variant.

TMax GetMax(void) const

Get the Max member data.

TP_m GetP_m(void) const

Get the variant data.

const TRange & GetRange(void) const

Get the variant data.

@ eLim_tl

space to left of position

@ eLim_tr

space to right of position

@ e_not_set

No variant selected.

@ e_Pct

% plus or minus (x10) 0-1000

@ e_Alt

set of alternatives for the integer

@ e_P_m

plus or minus fixed amount

void SetTo(TTo value)

Assign a value to To data member.

const TFuzz_from & GetFuzz_from(void) const

Get the Fuzz_from member data.

void SetPoint(TPoint value)

Assign a value to Point data member.

void SetId(TId &value)

Assign a value to Id data member.

void SetA(TA &value)

Assign a value to A data member.

bool IsSetId(void) const

WARNING: this used to be optional Check if a value has been assigned to Id data member.

void ResetFuzz_to(void)

Reset Fuzz_to data member.

bool IsMix(void) const

Check if variant Mix is selected.

const TFeat & GetFeat(void) const

Get the variant 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.

void ResetStrand(void)

Reset Strand data member.

bool IsPacked_pnt(void) const

Check if variant Packed_pnt is selected.

Tdata & Set(void)

Assign a value to data member.

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.

const TWhole & GetWhole(void) const

Get the variant data.

void SetId(TId &value)

Assign a value to Id data member.

void SetStrand(TStrand value)

Assign a value to Strand data member.

bool IsSetStrand(void) const

Check if a value has been assigned to Strand data member.

TFrom GetFrom(void) const

Get the From member data.

void SetFuzz(TFuzz &value)

Assign a value to Fuzz data member.

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.

void ResetFuzz(void)

Reset Fuzz data member.

bool CanGetA(void) const

Check if it is safe to call GetA method.

E_Choice Which(void) const

Which variant is currently selected.

const TId & GetId(void) const

Get the Id member data.

E_Choice Which(void) const

Which variant is currently selected.

const TId & GetId(void) const

Get the Id member data.

void SetFrom(TFrom value)

Assign a value to From data member.

TStrand GetStrand(void) const

Get the Strand member data.

bool IsBond(void) const

Check if variant Bond is selected.

void SetStrand(TStrand value)

Assign a value to Strand data member.

bool IsSetFuzz(void) const

Check if a value has been assigned to Fuzz data member.

const Tdata & Get(void) const

Get the member data.

void ResetFuzz(void)

Reset Fuzz data member.

const TPacked_pnt & GetPacked_pnt(void) const

Get the variant data.

void SetFuzz(TFuzz &value)

Assign a value to Fuzz data member.

void ResetStrand(void)

Reset Strand data member.

void SetId(TId &value)

Assign a value to Id data member.

const Tdata & Get(void) const

Get the member data.

void ResetFuzz_from(void)

Reset Fuzz_from data member.

const TEquiv & GetEquiv(void) const

Get the variant data.

TPoints & SetPoints(void)

Assign a value to Points data member.

list< CRef< CSeq_loc > > Tdata

vector< TSeqPos > TPoints

virtual void Reset(void)

Reset the whole object.

void SetFuzz_to(TFuzz_to &value)

Assign a value to Fuzz_to data member.

void SetFuzz_from(TFuzz_from &value)

Assign a value to Fuzz_from data member.

bool IsPacked_int(void) const

Check if variant Packed_int is selected.

const TA & GetA(void) const

Get the A member data.

static string SelectionName(E_Choice index)

Retrieve selection name (for diagnostic purposes).

bool CanGetB(void) const

Check if it is safe to call GetB method.

const TEmpty & GetEmpty(void) const

Get the variant data.

bool IsSetStrand(void) const

Check if a value has been assigned to Strand data member.

Tdata & Set(void)

Assign a value to data member.

bool IsSetFuzz_to(void) const

Check if a value has been assigned to Fuzz_to data member.

Tdata & Set(void)

Assign a value 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 IsInt(void) const

Check if variant Int is selected.

const TInt & GetInt(void) const

Get the variant data.

void SetB(TB &value)

Assign a value to B data member.

bool IsSetFuzz_from(void) const

Check if a value has been assigned to Fuzz_from data member.

void SetStrand(TStrand value)

Assign a value to Strand data member.

void ResetStrand(void)

Reset Strand data member.

E_Choice

Choice variants.

const TFuzz & GetFuzz(void) const

Get the Fuzz member data.

const TMix & GetMix(void) const

Get the variant data.

void ResetB(void)

Reset B data member.

bool IsPnt(void) const

Check if variant Pnt is selected.

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 TBond & GetBond(void) const

Get the variant data.

@ eNa_strand_both_rev

in reverse orientation

@ 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

Definition of all error codes used in objects libraries.

where boath are integers</td > n< td ></td > n</tr > n< tr > n< td > tse</td > n< td > optional</td > n< td > String</td > n< td class=\"description\"> TSE option controls what blob is whole

CNcbiMatrix< T > & operator+=(CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global addition: matrix += matrix

const TYPE & Get(const CNamedParameterList *param)

constexpr auto sort(_Init &&init)

constexpr bool empty(list< Ts... >) noexcept

const struct ncbi::grid::netcache::search::fields::SIZE size

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

bool operator()(const SEquivSet *e1, const SEquivSet *e2) const

size_t GetPartStartIndex(TPart_CI part) const

size_t GetPartEndOffset(TPart_CI part) const

size_t GetStartIndex(void) const

size_t GetElementsCount(void) const

size_t GetPartsCount(void) const

TPart_CI FindPartByElementIndex(size_t idx) const

size_t GetPartStartOffset(TPart_CI part) const

bool Contains(size_t idx) const

size_t GetPartEndIndex(TPart_CI part) const

size_t GetEndIndex(void) const

TPart_I FindPartByElementIndex(size_t idx)

TParts::const_iterator TPart_CI

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