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

NCBI C++ ToolKit: src/objects/seq/seq_loc_mapper_base.cpp Source File

( GetErrCode() ) {

eBadLocation:

;

eUnknownLength:

;

eBadAlignment:

;

eBadFeature:

;

eCanNotMap:

;

eOtherError:

;

CSeq_loc_Mapper_Base basic approaches.

The mapper parses input data (two seq-locs, seq-alignment) and stores

mappings in a collection of CMappingRange objects. Each mapping range

contains source (id, start, stop, strand) and destination (id, start,

All coordinates are converted to genomic with one exception: if

source and destination locations have the same length and the mapper

can not obtain real sequence types, it assumes that both sequences

are nucleotides even if they are proteins. See x_AdjustSeqTypesToProt()

for more info on this special case.

The mapper uses several methods to check sequence types: by comparing

source and destination lengths, by calling GetSeqType() which is

overriden in CSeq_loc_Mapper to provide the correct information, using

some information from alignments (e.g. spiced-segs contain explicit

sequence types). If all these methods fail, the mapper may still

successfully do its job. E.g. if mapping is between two whole seq-locs,

it may be done with the assumption that both sequences have the same

The order of mapping ranges is not preserved, they are sorted by

source seq-id and start position.

When parsing input locations the mapper also tries to create equivalent

mappings for all synonyms of the source sequence id. The base class

does not provide synonyms, buy CSeq_loc_Mapper does override

CollectSynonyms() method to implement this.

In some situations (like mapping between a bioseq and its segments),

the mapper also creates dummy mappings from destination to itself,

so that during the mapping any ranges already on the destination

sequence are not truncated. See x_PreserveDestinationLocs().

Mapping of seq-locs is done range-by-range, the original seq-loc

is not parsed completely before mapping. Each original interval is

mapped through all matching mapping ranges, some parts may be mapped

The mapped ranges are first stored in a container of SMappedRange

structures. This is done to simplify merging ranges. If no merge

flag is set or the new range can not be merged with the collected

set, all ranges from the container are moved (pushed) to the

destination seq-loc and the new range starts the new collection.

This is done by x_PushMappedRange method (adding a new range) and

x_PushRangesToDstMix (pushing the collected mapped ranges to the

destination seq-loc).

The pushing also occurs in the following situations:

- When a source range is discarded (not just clipped) - see

- When a non-mapping range is copied to the destination mix (in fact,

in this case pushing is usually done by the truncation described

- When a new complex seq-loc is started (e.g. a new mix or equiv)

to preserve the structure of the source location.

Since merging is done only among the temporary collection, any

of the above conditions breaks merging. Examples:

- The original seq-loc is a mix, containing two other mixes A and B,

which contain overlapping ranges. These ranges will not be merged,

since they originate from different complex locations.

- If the original seq-loc contains three ranges A, B and C, which are

mapped so that A' and C' overlap or abut, but B is discarded, the

A' and C' will not be merged. Depending on the flags, B may be

also included in the mapped location between A' and C' (see

KeepNonmappingRanges).

TODO: Is the above behavior expected or should it be changed so that

merging can be done at least in some of the described cases?

After mapping the destination seq-loc may be a simple interval or

a mix of sub-locations. This mix can be optimized when the mapping

is finished: null locations are removed (if no GapPreserve is set),

as well as empty mixes etc. Mixes with a single element are replaced

with this element. Mixes which contain only intervals are converted

{ synonyms.

(

); }

: m_Src_id_Handle(src_id),

m_Src_from(src_from),

m_Src_to(src_from + src_length - 1),

m_Src_strand(src_strand),

m_Dst_id_Handle(dst_id),

m_Dst_from(dst_from),

m_Dst_strand(dst_strand),

m_Src_bioseq_len(src_bioseq_len),

partial_from = fuzz && fuzz->first && fuzz->first->IsLim() &&

partial_to = fuzz && fuzz->second && fuzz->second->IsLim() &&

( (frame_shift > 0) && partial_from && (from == 0) && (

== 0) ) {

( ((

)new_dst_end - (

)src_to_dst_end) >= 0 && (new_dst_end - src_to_dst_end) <= 2 ) {

ret.

( new_dst_end );

( (frame_shift > 0) && partial_from && (from == 0) && (

== 0) ) {

ret.

( new_dst_end + frame_shift );

( !fuzz )

;

( fuzz->

() ) {

fuzz->

( *oldFuzz );

( !alt.empty() ) {

( !rg.

() ) {

fuzz->

( *oldFuzz );

( rg.

() ) {

: m_ReverseSrc(

),

m_ReverseDst(

)

(cvt->m_Src_from, cvt->m_Src_to), cvt));

src_id, src_from, src_length, src_strand,

dst_id, dst_from, dst_strand,

ext_to, frame, src_bioseq_len, dst_len ));

ranges->second.begin(

(from, to));

(

() ) {

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_MapOptions(options)

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_Mappings(mapping_ranges),

m_MapOptions(options)

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_MapOptions(options)

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_MapOptions(options)

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_MapOptions(options)

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_MapOptions(options)

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_MapOptions(options)

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_MapOptions(options)

: m_MergeFlag(eMergeNone),

m_GapFlag(eGapPreserve),

m_MiscFlags(fTrimSplicedSegs),

m_LastTruncated(

),

m_MapOptions(seq_info, opts)

known_dst_types =

(target, dst_type, dst_total_len);

);

);

known_types = known_src_types && known_dst_types;

( !known_types ) {

);

(src_total_len == dst_total_len) {

src_type = dst_type;

(src_total_len/3 == dst_total_len || src_total_len == (dst_total_len + 1)*3) {

);

(dst_total_len/3 == src_total_len || dst_total_len == (src_total_len + 1)*3) {

);

);

multiseq_src = !

.GetId();

multiseq_dst = !target.

();

( src_frame ) src_total_len -= src_frame - 1;

( dst_frame ) dst_total_len -= dst_frame - 1;

(src_total_len == (dst_total_len + 1)*3 && !multiseq_dst) {

(src_total_len/3 == dst_total_len && src_total_len % 3 != 0) {

<< src_total_len % 3 <<

);

(dst_total_len*3 >= src_total_len + 3 ||

dst_total_len*3 + 3 <= src_total_len) {

);

(dst_total_len == (src_total_len + 1)*3 && !multiseq_src) {

(dst_total_len/3 == src_total_len && dst_total_len % 3 != 0) {

<< dst_total_len % 3 <<

);

(src_total_len*3 >= dst_total_len + 3 ||

src_total_len*3 + 3 <= dst_total_len) {

);

(src_total_len != dst_total_len) {

);

src_width = (src_type ==

) ? 3 : 1;

dst_width = (dst_type ==

) ? 3 : 1;

( !rg.

() ) {

( !rg.

() ) {

(src_frame) <= src_len ) {

( !

.IsReverseStrand() ) {

src_start += src_frame - 1;

src_len -= src_frame - 1;

(dst_frame) <= dst_len ) {

dst_start += dst_frame - 1;

dst_len -= dst_frame - 1;

src_bioseq_len = src_width*src_bioseq_len;

last_src_start = 0, last_src_len = 0;

last_dst_start = 0, last_dst_len = 0;

last_src_reverse =

, last_dst_reverse =

;

(src_it && dst_it) {

( !last_src_reverse ) {

(last_src_start + last_src_len != src_start) {

(src_start + src_len != last_src_start) {

( !last_dst_reverse ) {

(last_dst_start + last_dst_len != dst_start) {

(dst_start + dst_len != last_dst_start) {

last_src_start = src_start;

last_src_len = src_len;

last_dst_start = dst_start;

last_dst_len = dst_len;

src_frame ? src_frame : dst_frame,

(src_len == 0 && ++src_it) {

(

.IsWhole() ) {

(dst_len == 0 && ++dst_it) {

(

.IsWhole() ) {

(idh == *it)

;

unique_ptr<IMapper_Sequence_Info::TSynonyms> from_syn;

(

= 0;

< (*diag_it)->GetIds().

(); ++

) {

(

(*(*diag_it)->GetIds()[

], to_ids) ) {

(!from_ids || from_row !=

)

;

(from_ids &&

(*(*diag_it)->GetIds()[

], *from_ids)) {

);

);

(!from_ids || from_row !=

)

;

);

);

((*std_seg)->IsSetIds() && !(*std_seg)->GetIds().empty()) {

(

= 0;

< (*std_seg)->GetIds().

(); ++

) {

(

(*(*std_seg)->GetIds()[

], to_ids) ) {

(

= 0;

< (*std_seg)->GetLoc().

(); ++

) {

* row_id = (*std_seg)->GetLoc()[

]->GetId();

);

(!from_ids || from_row !=

)

;

);

);

(

((*it)->GetFirst_id(), to_ids) ) {

(

((*it)->GetSecond_id(), to_ids) ) {

);

(to_row == 0 || to_row == 1) {

);

);

dim = diag.

();

(dim != diag.

().size()) {

dim =

(dim, diag.

().size());

(have_strands && dim != diag.

().size()) {

dst_width = (dst_type ==

) ? 3 : 1;

(

= 0;

< dim; ++

) {

(

= 0;

< dim; ++

) {

(

== to_row) {

src_width = (src_type ==

) ? 3 : 1;

dst_id, dst_start, dst_len, dst_strand, 0, 0);

(!src_len && !dst_len);

dim = denseg.

();

(numseg != denseg.

().size()) {

numseg =

(numseg, denseg.

().size());

(dim != denseg.

().size()) {

dim =

(dim, denseg.

().size());

(dim*numseg != denseg.

().size()) {

dim =

(dim*numseg, denseg.

().size()) / numseg;

(have_strands && dim*numseg != denseg.

().size()) {

dim =

(dim*numseg, denseg.

().size()) / numseg;

(

= 0;

< dim; ++

) {

dst_width = (dst_type ==

) ? 3 : 1;

(

= 0;

< dim; ++

) {

(

== to_row) {

src_width = (src_type ==

) ? 3 : 1;

(src_len != dst_len) {

);

src_id, src_start, src_len, src_strand,

dst_id, dst_start, dst_len, dst_strand,

(src_len != 0 || dst_len != 0) {

(

seg = 0; seg < numseg; ++seg) {

i_src_start = denseg.

()[seg*dim +

];

i_dst_start = denseg.

()[seg*dim + to_row];

(i_src_start < 0 || i_dst_start < 0) {

dst_id, dst_start, dst_len, dst_strand, 0, 0);

(!src_len && !dst_len);

dim = sseg.

();

(dim != sseg.

().size()) {

dim =

(dim, sseg.

().size());

&& dim != sseg.

().size()) {

dim =

(dim, sseg.

().size());

(

= 0;

< dim; ++

) {

(

== to_row) {

dim = pseg.

();

(numseg != pseg.

().size()) {

numseg =

(numseg, pseg.

().size());

(dim != pseg.

().size()) {

dim =

(dim, pseg.

().size());

(dim*numseg != pseg.

().size()) {

dim =

(dim*numseg, pseg.

().size()) / numseg;

(have_strands && dim*numseg != pseg.

().size()) {

dim =

(dim*numseg, pseg.

().size()) / numseg;

(

= 0;

< dim; ++

) {

dst_width = (dst_type ==

) ? 3 : 1;

(

= 0;

< dim; ++

) {

(

== to_row) {

src_width = (src_type ==

) ? 3 : 1;

(

seg = 0; seg < numseg; ++seg) {

src_id, src_start, src_len, src_strand,

dst_id, dst_start, dst_len, dst_strand,

(!src_len && !dst_len);

( part.

() ) {

(mapping_len == 0)

;

rev_prod =

(prod_strand);

pgen_len = mapping_len;

pprod_len = mapping_len;

pgen_start = rev_gen ?

gen_start + gen_len - mapping_len : gen_start;

pprod_start = rev_prod ?

prod_start + prod_len - mapping_len : prod_start;

gen_id, pgen_start, pgen_len, gen_strand,

prod_id, pprod_start, pprod_len, prod_strand,

prod_id, pprod_start, pprod_len, prod_strand,

gen_id, pgen_start, pgen_len, gen_strand,

(pgen_len == 0 && pprod_len == 0);

gen_start += mapping_len;

gen_len -= mapping_len;

prod_start += mapping_len;

prod_len -= mapping_len;

rev_prod =

(prod_strand);

mapping_len += plen;

gen_id, gen_start, gen_len, gen_strand,

prod_id, prod_start, prod_len, prod_strand);

gen_id, gen_start, gen_len, gen_strand,

prod_id, prod_start, prod_len, prod_strand);

prod_is_prot =

;

prod_is_prot =

;

(!ex_gen_id || !ex_prod_id) {

);

);

gen_len = gen_to - gen_from + 1;

prod_len = prod_to - prod_from + 1;

*ex_gen_id, gen_from, gen_len, ex_gen_strand,

*ex_prod_id, prod_from, prod_len, ex_prod_strand);

*ex_gen_id, gen_from, gen_len, ex_gen_strand,

*ex_prod_id, prod_from, prod_len, ex_prod_strand,

*ex_prod_id, prod_from, prod_len, ex_prod_strand,

*ex_gen_id, gen_from, gen_len, ex_gen_strand,

(gen_len || prod_len) {

);

numseg =

.GetNumseg();

(numseg !=

.GetFirst_starts().size()) {

);

numseg =

(numseg,

.GetFirst_starts().size());

(numseg !=

.GetSecond_starts().size()) {

);

numseg =

(numseg,

.GetSecond_starts().size());

(numseg !=

.GetLens().size()) {

numseg =

(numseg,

.GetLens().size());

have_strands =

.IsSetSecond_strands();

(have_strands && numseg !=

.GetSecond_strands().size()) {

);

numseg =

(numseg,

.GetSecond_strands().size());

& first_id =

.GetFirst_id();

& second_id =

.GetSecond_id();

first_width = (first_type ==

) ? 3 : 1;

second_width = (second_type ==

) ? 3 : 1;

(

= 0;

< numseg;

++) {

first_start = first_starts[

]*first_width;

second_start = second_starts[

]*second_width;

first_len = lens[

]*len_width;

second_len = first_len;

second_id, second_start, second_len, strand,

second_id, second_start, second_len, strand,

(!first_len && !second_len);

primary_it !=

.

() ? primary_it->second : synonym;

found->second;

( synonyms.

() ) {

primary_it->second;

(it->second != seqtype) {

);

found_type =

;

( !idh )

;

(seqtype != it_type) {

( it.GetRange().IsWhole() ) {

+= it.GetRange().GetLength();

( !idh )

;

(ret !=

->second) {

);

have_id =

;

have_known =

;

(id_it->first == primary_id) {

( !have_id )

;

);

new_rg->SetGroup(mrg.

());

( rg_it->IsWhole() ) {

( !rg_it->Empty() ) {

from = rg_it->GetFrom()*3;

to = rg_it->GetToOpen()*3;

rg_it->SetOpen(from, to);

cvt_src_start = src_start;

cvt_dst_start = dst_start;

original_dst_len = dst_len;

(src_len == dst_len) {

src_len -= src_start;

dst_len -= dst_start;

cvt_length = src_len;

(src_len > dst_len) {

cvt_src_start += src_len - dst_len;

src_start += dst_len;

cvt_length = dst_len;

src_len -= cvt_length;

cvt_dst_start += dst_len - src_len;

dst_start += src_len;

cvt_length = src_len;

dst_len -= cvt_length;

ext_to =

;

(

(dst_strand) && fuzz_from ) {

ext_to = fuzz_from &&

fuzz_from->

() &&

( !

(dst_strand) && fuzz_to ) {

fuzz_to->

() &&

dst_id, cvt_dst_start, dst_strand, cvt_length, ext_to, frame,

src_bioseq_len, original_dst_len);

(

.size() <=

(dst_strand)) {

(length > src_seq_len - src_start) {

trim = length - src_seq_len + src_start;

(length > dst_seq_len - dst_start) {

trim = length - dst_seq_len + dst_start;

dst_len = dst_len > trim ? dst_len - trim : 0;

(length == 0)

;

main_id, src_start, length, src_strand,

dst_idh, dst_start, dst_strand,

.push_back(

(dst_start, dst_start + length - 1));

(

str_idx = 0; str_idx <

.size(); str_idx++) {

id_it->second.sort();

dst_width = (dst_type ==

) ? 3 : 1;

( rg_it->IsWhole() ) {

( !rg_it->Empty() ) {

rg_start = rg_it->GetFrom()*dst_width;

rg_stop = rg_it->GetTo()*dst_width;

dst_start = rg_start;

dst_stop =

(dst_stop, rg_stop);

id_it->first, dst_start,

(str_idx));

dst_start = dst_stop;

dst_start = rg_start;

(dst_start < dst_stop) {

id_it->first, dst_start,

(str_idx));

is_first =

;

( ; loc_iter; ++loc_iter ) {

is_last = ( ++

(loc_iter) == loc->

() );

new_loc_piece->

( *loc_piece );

new_loc->

( *new_loc_piece );

new_loc->

( *loc_piece );

( loc_piece->

() ) {

from_fuzz_is_bad =

to_fuzz_is_bad =

( from_fuzz_is_bad || to_fuzz_is_bad ) {

new_loc->

( *loc_piece );

( from_fuzz_is_bad ) {

new_loc->

().ResetFuzz_from();

( to_fuzz_is_bad ) {

new_loc->

().ResetFuzz_to();

is_fuzz_range =

( is_fuzz_range ) {

new_loc->

( *loc_piece );

new_loc->

().ResetFuzz();

(loc->

()) {

have_null =

;

(mix_locs.size() > 1 &&

mix_locs.back()->IsNull())

mix_locs.pop_back();

mix_locs.size() > 0 && !mix_locs.back()->IsNull()) {

mix_locs.push_back(null_loc);

( loc->

().

().size() ) {

( !(*it)->IsInt() ) {

push_back(

(&(*it)->SetInt()));

);

partial_left =

;

partial_right =

;

trimmed_left, trimmed_right;

(left != *last_src_to + 1);

partial_left = (cvt_idx == mappings.size() - 1) ||

(mappings[cvt_idx + 1]->m_Src_to + 1 != left);

partial_right = (cvt_idx == mappings.size() - 1) ||

(mappings[cvt_idx + 1]->m_Src_from != right + 1);

(right + 1 != *last_src_to);

( partial_left ) {

( partial_right ) {

( partial_left ) err_msg +=

;

*last_src_to = reverse ? left : right;

( partial_left ) {

( (!reverse && cvt_idx == 0) ||

(reverse && cvt_idx == mappings.size() - 1) ) {

fuzz.first = src_fuzz.first;

( partial_right ) {

( (reverse && cvt_idx == 0) ||

(!reverse && cvt_idx == mappings.size() - 1) ) {

fuzz.second = src_fuzz.second;

(reverse && !fuzz.second) {

(!reverse && !fuzz.first) {

is_set_dst_strand = cvt.

(is_set_strand,

src_strand, &dst_strand);

);

( ; rg_it; ++rg_it) {

mappings.push_back(rg_it->second);

( r_it && r_it->second ) {

shift = ( mappings[0]->m_Frame - 1 );

( src_rg.

() != 0 ) {

(

idx = 0; idx < mappings.size(); ++idx) {

is_set_strand, src_strand,

);

(

.IsSetFuzz_from() ) {

fuzz.first->Assign(

.GetFuzz_from());

(

.IsSetFuzz_to() ) {

fuzz.second->Assign(

.GetFuzz_to());

rg, fuzz,

, 0);

fuzz.first->Assign(pp.

());

rg, fuzz,

, 0);

( src_loc.

() ) {

( ; mit; ++mit) {

fuzz.second->Assign(pnt.

());

fuzz.first->Assign(pnt.

());

fuzzA.first->Assign(src_bond.

().

());

( src_bond.

() ) {

fuzzB.first->Assign(src_bond.

().

());

( src_bond.

() ) {

dst_mix.

().push_back(pntA);

dst_mix.

().push_back(null_loc);

dst_mix.

().push_back(pntB);

);

(*total_range);

aln_mapper->Convert(*

);

aln_mapper->Convert();

aln_mapper->GetDstAlign();

(from == to && (!rg_fuzz.first && !rg_fuzz.second) &&

loc->

().SetPoint(from);

(strand_idx > 0) {

( rg_fuzz.first ) {

loc->

().SetFuzz(*rg_fuzz.first);

( rg_fuzz.second ) {

loc->

().SetFuzz(*rg_fuzz.second);

loc->

().SetFrom(from);

loc->

().SetTo(to);

(strand_idx > 0) {

( rg_fuzz.first ) {

loc->

().SetFuzz_from(*rg_fuzz.first);

( rg_fuzz.second ) {

loc->

().SetFuzz_to(*rg_fuzz.second);

strand_idx)

(str_vec.size() <= strand_idx) {

str_vec.resize(strand_idx + 1);

str_vec[strand_idx];

);

reverse = (strand_idx > 0) &&

( push_reverse ) {

( push_reverse ) {

no_merge = no_merge ||

(it->second.size() <= strand_idx) || it->second.empty();

& mrg = it->second[strand_idx].front();

no_merge = no_merge ||

no_merge = no_merge || (mrg.

!= group);

& mrg = it->second[strand_idx].back();

no_merge = no_merge ||

no_merge = no_merge || (mrg.

!= group);

( push_reverse ) {

& last_rg = it->second[strand_idx].front();

last_rg.

.first = fuzz.first;

& last_rg = it->second[strand_idx].back();

last_rg.

.second = fuzz.second;

( range.

() ) {

( range.

() ) {

seq_width = (seq_type ==

) ? 3 : 1;

loc->

().SetId(*

);

(src_strand > 0) {

push_reverse = !push_reverse;

( push_reverse ) {

( !loc->

() ) {

( mix.size() > 0 && (*mix.rbegin())->IsNull() ) {

( !id_it->first ) {

dst_mix.push_back(null_loc);

(

= 0;

< (

)id_it->second.size(); ++

) {

(id_it->second[

].size() == 0) {

id_it->second[

].sort();

( rg_it->range.Empty() ) {

loc->

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

dst_mix.push_front(loc);

dst_mix.push_back(loc);

from = rg_it->range.GetFrom();

to = rg_it->range.GetTo();

group = rg_it->group;

(rg_it->range.GetFrom() == to + 1) {

to = rg_it->range.GetTo();

fuzz.second = rg_it->fuzz.second;

(rg_it->range.GetTo() <= to) {

(rg_it->range.GetFrom() == from) {

to = rg_it->range.GetTo();

fuzz.second = rg_it->fuzz.second;

(rg_it->range.GetFrom() <= to + 1) {

(rg_it->range.GetTo() > to) {

to = rg_it->range.GetTo();

fuzz.second = rg_it->fuzz.second;

from = rg_it->range.GetFrom();

to = rg_it->range.GetTo();

group = rg_it->group;

(from < src.size() && to <= src.size());

dst.insert(dst.end(), src.begin() + from, src.begin() + to);

( !mapped_loc ) {

ret->

(src_graph);

ret->

(*mapped_loc);

src_type_set =

;

( !src_type_set ) {

src_type_set =

;

(src_type != it_type) {

);

dst_type_set =

;

( !dst_type_set ) {

dst_type_set =

;

(dst_type != it_type) {

);

(src_type != dst_type &&

(comp % 3 == 0) {

);

( src_data.

() ) {

(TGraphRanges, it, ranges) {

from = it->GetFrom()/comp_div;

to = it->GetTo()/comp_div + 1;

numval += to - from;

(TGraphRanges, it, ranges) {

from = it->GetFrom()/comp_div;

to = it->GetTo()/comp_div + 1;

numval += to - from;

(TGraphRanges, it, ranges) {

from = it->GetFrom()/comp_div;

to = it->GetTo()/comp_div + 1;

numval += to - from;

mapped_count = 0;

non_mapped_count = 0;

mapped =

;

( loc && !loc->

() ) {

( loc && !loc->

() ) {

.empty() ?

:

,

.empty() ?

(

) :

);

.empty() ?

:

,

.SetAlign(**it);

.empty() ?

(

) :

);

.empty() ?

:

,

.SetGraph(**it);

.empty() ?

(

) :

);

);

( mapped_count ) {

MAPPER_NONMAPPING_AS_NULL);

TNonMappingAsNullParam::GetDefault();

User-defined methods of the data storage class.

bool IsReverse(ENa_strand s)

ENa_strand Reverse(ENa_strand s)

ESeqLocExtremes

Used to determine the meaning of a location's Start/Stop positions.

@ eExtreme_Biological

5' and 3'

bool SameOrientation(ENa_strand a, ENa_strand b)

Seq-loc and seq-align mapper exceptions.

virtual void CollectSynonyms(const CSeq_id_Handle &id, TSynonyms &synonyms)

Collect all synonyms for the id including the id itself.

virtual TSeqPos GetSequenceLength(const CSeq_id_Handle &)

Get sequence length or kInvalidSeqPos.

virtual TSeqType GetSequenceType(const CSeq_id_Handle &)

Get information about sequence type (nuc or prot).

CRange< TSeqPos > GetSeqRange(TDim row) const

Helper class for mapping graphs.

CMappingRange - describes a single interval to interval mapping.

Storage for multiple mapping ranges.

Default IMessage implementation: text and severity only.

Class used to map seq-alignments.

namespace ncbi::objects::

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

CSeq_loc_Mapper_Options –.

virtual CSeq_id_Handle GetBestSynonym(const CSeq_id &id)

CTotalRangeSynonymMapper(const TSynonymMap &syn_map)

virtual ~CTotalRangeSynonymMapper(void)

CSeq_loc_Mapper_Base::TSynonymMap TSynonymMap

const TSynonymMap & m_Map

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

iterator_bool insert(const value_type &val)

const_iterator find(const key_type &key) const

iterator_bool insert(const value_type &val)

static const char si[8][64]

std::ofstream out("events_result.xml")

main entry point for tests

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

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 NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

const TSeqPos kInvalidSeqPos

Define special value for invalid sequence position.

#define ERR_POST_X(err_subcode, message)

Error posting with default error code and given error subcode.

EDiagSev

Severity level for the posted diagnostics.

@ eDiag_Error

Error message.

void Error(CExceptionArgs_Base &args)

#define NCBI_THROW(exception_class, err_code, message)

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

const string & GetMsg(void) const

Get message string.

void Warning(CExceptionArgs_Base &args)

virtual const char * GetErrCodeString(void) const

Get error code interpreted as text.

void Info(CExceptionArgs_Base &args)

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

Set object to copy of another one.

#define MSerial_AsnText

I/O stream manipulators –.

static bool HaveListeners(void)

Check if there are any listeners installed in the current thread.

static EPostResult Post(const IMessage &message)

Post the message to listener(s), if any.

virtual void Write(CNcbiOstream &out) const

Print the message and any additional information to the stream.

CConstRef< CSeq_id > GetSeqId(void) const

static CSeq_id_Handle GetHandle(const CSeq_id &id)

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

string AsString(void) const

void GetMatchingIds(TSeqIdHandles &matches) const

Collect partially matching seq-ids: no-version, no-name etc.

void SetPacked_int(TPacked_int &v)

bool IsPartialStart(ESeqLocExtremes ext) const

check start or stop of location for e_Lim fuzz

bool IsReverseStrand(void) const

Return true if all ranges have reverse strand.

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

Override Assign() to incorporate cache invalidation.

CConstRef< CSeq_loc > GetRangeAsSeq_loc(void) const

Get seq-loc for the current iterator position.

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

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

const_iterator end(void) const

CSeq_id_Handle GetSeq_id_Handle(void) const

bool IsWhole(void) const

True if the current location is a whole sequence.

const CInt_fuzz * GetFuzzFrom(void) const

const CInt_fuzz * GetFuzzTo(void) const

void Add(const CSeq_loc &other)

Simple adding of seq-locs.

const CSeq_id * GetId(void) const

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

TRange GetRange(void) const

Get the range.

void SetPartialStart(bool val, ESeqLocExtremes ext)

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

ENa_strand GetStrand(void) const

const CSeq_id & GetSeq_id(void) const

Get seq_id of the current location.

void SetStrand(ENa_strand strand)

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

void SetPartialStop(bool val, ESeqLocExtremes ext)

void SetNull(void)

Override all setters to incorporate cache invalidation.

bool IsPartialStop(ESeqLocExtremes ext) const

void SetTruncatedStop(bool val, ESeqLocExtremes ext)

@ eOrder_Biological

Iterate sub-locations in positional order.

@ eEmpty_Allow

ignore empty locations

void x_InitializeAlign(const CSeq_align &map_align, const CSeq_id &to_id, const CSeq_id *from_id=nullptr)

CRef< IMapper_Sequence_Info > m_SeqInfo

TSeqPos x_GetRangeLength(const CSeq_loc_CI &it)

TRange Map_Range(TSeqPos from, TSeqPos to, const TRangeFuzz *fuzz=0) const

Map an interval, set fuzz when the mapping truncates the original range.

pair< TFuzz, TFuzz > TRangeFuzz

TDstStrandMap m_DstRanges

bool x_CheckSeqTypes(const CSeq_loc &loc, ESeqType &seqtype, TSeqPos &len)

CRef< CSeq_loc > x_RangeToSeq_loc(const CSeq_id_Handle &idh, TSeqPos from, TSeqPos to, size_t strand_idx, TRangeFuzz rg_fuzz)

void x_SetMiscFlag(EMiscFlags flag, bool value)

CRef< CSeq_loc > Map(const CSeq_loc &src_loc)

Map seq-loc.

TSeqPos GetSequenceLength(const CSeq_id &id)

virtual void CollectSynonyms(const CSeq_id_Handle &id, TSynonyms &synonyms)=0

Collect all synonyms for the id including the id itself.

CSeq_loc_Mapper_Base(CMappingRanges *mapping_ranges, CSeq_loc_Mapper_Options options=CSeq_loc_Mapper_Options())

Mapping through a pre-filled CMappipngRanges.

ESeqType GetSeqTypeById(const CSeq_id_Handle &idh) const

Methods for getting sequence types, use cached types (m_SeqTypes) if possible.

TRangeMap::const_iterator TRangeIterator

void x_AddExonPartsMapping(TSeqPos &mapping_len, ESplicedRow to_row, const CSeq_id &gen_id, TSeqPos &gen_start, TSeqPos &gen_len, ENa_strand gen_strand, const CSeq_id &prod_id, TSeqPos &prod_start, TSeqPos &prod_len, ENa_strand prod_strand)

CRef< CGraphRanges > m_GraphRanges

void x_PushMappedRange(const CSeq_id_Handle &id, size_t strand_idx, const TRange &range, const TRangeFuzz &fuzz, bool push_reverse, int group)

CMappingRange(CSeq_id_Handle src_id, TSeqPos src_from, TSeqPos src_length, ENa_strand src_strand, CSeq_id_Handle dst_id, TSeqPos dst_from, ENa_strand dst_strand, bool ext_to=false, int frame=0, TSeqPos src_bioseq_len=kInvalidSeqPos, TSeqPos dst_len=kInvalidSeqPos)

EMapResult

Result of seq-annot mapping.

CSeq_id_Handle m_Dst_id_Handle

void x_Map_Fuzz(TFuzz &fuzz) const

void AddRange(const TRange &rg)

const CSeq_id_Handle & GetDstIdHandle(void) const

CSeq_align::C_Segs::TDendiag TDendiag

list< SMappedRange > TMappedRanges

const TIdMap & GetIdMap() const

CSeq_loc_Mapper_Message(const string &msg, EDiagSev sev, int err_code=0, int sub_code=0)

ESplicedRow

Spliced-seg row indexing constants.

virtual TSeqPos GetSequenceLength(const CSeq_id_Handle &idh)=0

Get sequence length or kInvalidSeqPos.

const CSeq_graph * GetGraph(void) const

Get seq-graph object or null.

bool GetTrimMappedLocation(void) const

Mapped location trimming at sequence end.

void x_InitializeFeat(const CSeq_feat &map_feat, EFeatMapDirection dir)

void SetSeqTypeById(const CSeq_id_Handle &idh, ESeqType seqtype) const

Methods for setting sequence types.

IMapper_Sequence_Info & GetSeqInfo(void) const

CSeq_loc_Mapper_Options –.

EFeatMapDirection

Mapping direction used when initializing the mapper with a feature.

void x_StripExtraneousFuzz(CRef< CSeq_loc > &loc) const

vector< TMappedRanges > TRangesByStrand

CSeq_loc_Mapper_Options m_MapOptions

const CSeq_id_Handle & CollectSynonyms(const CSeq_id_Handle &id) const

void ResetObject(void)

Set the stored object to null.

CRef< CSeq_loc > MapTotalRange(const CSeq_loc &seq_loc)

Take the total range from the location and run it through the mapper.

const CSeq_loc * GetLoc(void) const

Get seq-loc object or null.

bool CanMap(TSeqPos from, TSeqPos to, bool is_set_strand, ENa_strand strand) const

Check if the interval can be mapped through this mapping range.

void x_InitSparse(const CSparse_seg &sparse, size_t to_row)

void SetReverseSrc(bool value=true)

CSeq_loc_Mapper_Options & SetAlign_Sparse_ToFirst(bool value=true)

CSeq_align::C_Segs::TStd TStd

bool GoodSrcId(const CSeq_id &id) const

Check if the id is on the source sequence.

void AddConversion(CRef< CMappingRange > cvt)

Add new mapping range to the proper place.

void x_Map_PackedPnt_Element(const CPacked_seqpnt &pp, TSeqPos p)

void x_NextMappingRange(const CSeq_id &src_id, TSeqPos &src_start, TSeqPos &src_len, ENa_strand src_strand, const CSeq_id &dst_id, TSeqPos &dst_start, TSeqPos &dst_len, ENa_strand dst_strand, const CInt_fuzz *fuzz_from=0, const CInt_fuzz *fuzz_to=0, int frame=0, TSeqPos src_bioseq_len=kInvalidSeqPos)

const CSeq_align * GetAlign(void) const

Get seq-align object or null.

bool x_ReverseRangeOrder(int str) const

TRangeFuzz Map_Fuzz(const TRangeFuzz &fuzz) const

Map fuzz if one is set in the original location.

ESeqType x_ForceSeqTypes(const CSeq_loc &loc) const

void SetFeat(const CSeq_feat &feat)

Set seq-feat object (copy into the message).

void SetReverseDst(bool value=true)

bool Map_Strand(bool is_set_strand, ENa_strand src, ENa_strand *dst) const

Map the strand, return true if the destination strand should be set (even if it's eNa_strand_unknown ...

void x_PushSourceRange(const CSeq_id_Handle &idh, size_t src_strand, size_t dst_strand, const TRange &range, bool push_reverse)

void x_IterateExonParts(const CSpliced_exon::TParts &parts, ESplicedRow to_row, const CSeq_id &gen_id, TSeqPos &gen_start, TSeqPos &gen_len, ENa_strand gen_strand, const CSeq_id &prod_id, TSeqPos &prod_start, TSeqPos &prod_len, ENa_strand prod_strand)

void SetAlign(const CSeq_align &align)

Set seq-align object (copy into the message).

EObjectType Which(void) const

Check type of the object stored in the message.

void x_InitSpliced(const CSpliced_seg &spliced, const TSynonyms &to_ids)

list< TRange > TDstRanges

virtual void Write(CNcbiOstream &out) const

Print the message and any additional information to the stream.

bool GetAlign_Dense_seg_TotalRange(void) const

Dense-seg mapping option.

TSeqPos Map_Pos(TSeqPos pos) const

Map a single point.

void x_InitAlign(const CDense_diag &diag, size_t to_row, size_t from_row)

CMappingRange::TRange TRange

CRef< CSeq_loc > x_GetMappedSeq_loc(void)

TSeqPos GetOffset(void) const

void x_SetLastTruncated(void)

void x_PushLocToDstMix(CRef< CSeq_loc > loc)

void x_PushRangesToDstMix(void)

bool GetReverseSrc(void) const

CRef< CSeq_loc > m_Dst_loc

void IncOffset(TSeqPos inc)

const CSeq_feat * GetFeat(void) const

Get seq-feat object or null.

void x_InitializeLocs(const CSeq_loc &source, const CSeq_loc &target, int src_frame=0, int dst_frame=0)

bool x_IsSetMiscFlag(EMiscFlags flag) const

static TSeqPos sx_GetExonPartLength(const CSpliced_exon_chunk &part)

virtual CSeq_loc_Mapper_Message * Clone(void) const

Create a copy of the message.

void x_Map_PackedInt_Element(const CSeq_interval &si)

bool GetReverseDst(void) const

void SetLoc(const CSeq_loc &loc)

Set seq-loc object (copy into the message).

void x_MapSeq_loc(const CSeq_loc &src_loc)

CRef< CSeq_loc > m_SrcLocs

void x_PreserveDestinationLocs(void)

CMappingRange::TRange TRange

vector< TRange > TGraphRanges

CRef< CSeq_align > x_MapSeq_align(const CSeq_align &src_align, size_t *row)

virtual TSeqType GetSequenceType(const CSeq_id_Handle &idh)=0

Get information about sequence type (nuc or prot).

bool x_IsSynonym(const CSeq_id &id, const TSynonyms &synonyms) const

CRef< CMappingRanges > m_Mappings

void x_OptimizeSeq_loc(CRef< CSeq_loc > &loc) const

const CSeq_id_Handle & x_GetPrimaryId(const CSeq_id_Handle &synonym) const

TMappedRanges & x_GetMappedRanges(const CSeq_id_Handle &id, size_t strand_idx) const

const TGraphRanges & GetRanges(void) const

CInt_fuzz::ELim x_ReverseFuzzLim(CInt_fuzz::ELim lim) const

ESeqType GetSeqType(const CSeq_id_Handle &idh) const

TRangeIterator BeginMappingRanges(CSeq_id_Handle id, TSeqPos from, TSeqPos to) const

Get mapping ranges iterator for the given seq-id and range.

CMappingRanges::TSortedMappings TSortedMappings

CSeq_id_Handle m_Src_id_Handle

CConstRef< CSeq_loc > x_FixNonsenseFuzz(CConstRef< CSeq_loc > loc_piece) const

bool x_MapNextRange(const TRange &src_rg, bool is_set_strand, ENa_strand src_strand, const TRangeFuzz &src_fuzz, TSortedMappings &mappings, size_t cvt_idx, TSeqPos *last_src_to)

void SetGraph(const CSeq_graph &graph)

Set seq-graph object (copy into the message).

friend class CSeq_align_Mapper_Base

bool GetAlign_Sparse_ToSecond(void) const

pair< TFuzz, TFuzz > TRangeFuzz

void SetFuzzOption(TFuzzOption newOption)

virtual ~CSeq_loc_Mapper_Message(void)

void x_AddConversion(const CSeq_id &src_id, TSeqPos src_start, ENa_strand src_strand, const CSeq_id &dst_id, TSeqPos dst_start, ENa_strand dst_strand, TSeqPos length, bool ext_right, int frame, TSeqPos src_bioseq_len, TSeqPos dst_length)

static bool GetNonMappingAsNull(void)

void x_AdjustSeqTypesToProt(const CSeq_id_Handle &idh)

virtual CSeq_align_Mapper_Base * InitAlignMapper(const CSeq_align &src_align)

vector< TDstIdMap > TDstStrandMap

bool x_MapInterval(const CSeq_id &src_id, TRange src_rg, bool is_set_strand, ENa_strand src_strand, TRangeFuzz orig_fuzz)

~CSeq_loc_Mapper_Base(void)

CSeq_loc_Mapper_Options & SetAlign_Sparse_ToSecond(bool value=true)

void SetOffset(TSeqPos offset)

@ eMapped_All

All annotations were mapped, none was removed.

@ eMapped_None

No annotation was mapped, the input seq-annot is unchanged.

@ eMapped_Some

Some (not all) annotations were mapped.

@ fAnnotMap_RemoveNonMapping

Remove annotations which can not be mapped with this mapper.

@ fAnnotMap_ThrowOnFailure

Throw exception if an annotation can not be mapped.

@ fAnnotMap_Location

Map seq-feat locations.

@ fAnnotMap_Product

Map seq-feat products.

@ fFuzzOption_RemoveLimTlOrTr

@ eLocationToProduct

Map from the feature's location to product.

CRef< C > Ref(C *object)

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

void Reset(void)

Reset reference object.

TObjectType * GetPointerOrNull(void) THROWS_NONE

Get pointer value.

bool Empty(void) const THROWS_NONE

Check if CRef is empty – not pointing to any object, which means having a null value.

@ eParam_NoThread

Do not use per-thread values.

position_type GetLength(void) const

TParent::value_type value_type

position_type GetTo(void) const

position_type GetToOpen(void) const

position_type GetFrom(void) const

static TThisType GetEmpty(void)

TThisType & SetLength(position_type length)

TThisType & Set(position_type from, position_type to)

TThisType & SetOpen(position_type from, position_type toOpen)

static TThisType GetWhole(void)

static position_type GetWholeTo(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.

IO_PREFIX::ostream CNcbiOstream

Portable alias for ostream.

static enable_if< is_arithmetic< TNumeric >::value||is_convertible< TNumeric, Int8 >::value, string >::type NumericToString(TNumeric value, TNumToStringFlags flags=0, int base=10)

Convert numeric value to string.

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.

bool IsLim(void) const

Check if variant Lim is selected.

TRange & SetRange(void)

Select the variant.

TAlt & SetAlt(void)

Select the variant.

TLim GetLim(void) const

Get the variant data.

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.

bool IsRange(void) const

Check if variant Range is selected.

const TRange & GetRange(void) const

Get the variant data.

@ eLim_tl

space to left of position

@ eLim_tr

space to right of position

@ e_Alt

set of alternatives for the integer

bool IsSetProduct_strand(void) const

should be 'plus' or 'minus' Check if a value has been assigned to Product_strand data member.

const TDenseg & GetDenseg(void) const

Get the variant data.

bool IsProtpos(void) const

Check if variant Protpos is selected.

vector< CRef< CSparse_align > > TRows

const TGenomic_id & GetGenomic_id(void) const

Get the Genomic_id member data.

E_Choice Which(void) const

Which variant is currently selected.

bool IsSetParts(void) const

basic seqments always are in biologic order Check if a value has been assigned to Parts data member.

const TLoc & GetLoc(void) const

Get the Loc member data.

TMatch GetMatch(void) const

Get the variant data.

bool IsSetStrands(void) const

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

bool IsSetProduct_strand(void) const

should be 'plus' or 'minus' Check if a value has been assigned to Product_strand data member.

const TStarts & GetStarts(void) const

Get the Starts member data.

const TStarts & GetStarts(void) const

Get the Starts member data.

const TProduct_id & GetProduct_id(void) const

Get the Product_id member data.

TGenomic_start GetGenomic_start(void) const

Get the Genomic_start member data.

const TProduct_id & GetProduct_id(void) const

Get the Product_id member data.

bool IsMismatch(void) const

Check if variant Mismatch is selected.

static string SelectionName(E_Choice index)

Retrieve selection name (for diagnostic purposes).

const TLens & GetLens(void) const

Get the Lens member data.

const TIds & GetIds(void) const

Get the Ids member data.

TDiag GetDiag(void) const

Get the variant data.

TNumseg GetNumseg(void) const

Get the Numseg member data.

TLen GetLen(void) const

Get the Len member data.

TProduct_type GetProduct_type(void) const

Get the Product_type member data.

TMismatch GetMismatch(void) const

Get the variant data.

TGenomic_strand GetGenomic_strand(void) const

Get the Genomic_strand member data.

bool IsSetStrands(void) const

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

bool IsSetGenomic_strand(void) const

genomic-strand represents the strand of translation Check if a value has been assigned to Genomic_str...

bool IsSetProduct_id(void) const

product is either protein or transcript (cDNA) Check if a value has been assigned to Product_id data ...

const TParts & GetParts(void) const

Get the Parts member data.

const TProduct_start & GetProduct_start(void) const

Get the Product_start member data.

TDim GetDim(void) const

Get the Dim member data.

const TIds & GetIds(void) const

Get the Ids member data.

const TProduct_end & GetProduct_end(void) const

Get the Product_end member data.

bool IsSetProduct_id(void) const

product is either protein or transcript (cDNA) Check if a value has been assigned to Product_id data ...

const TSpliced & GetSpliced(void) const

Get the variant data.

bool IsSetIds(void) const

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

TDim GetDim(void) const

Get the Dim member data.

const TLens & GetLens(void) const

Get the Lens member data.

bool IsGenomic_ins(void) const

Check if variant Genomic_ins is selected.

const TPacked & GetPacked(void) const

Get the variant data.

bool IsMatch(void) const

Check if variant Match is selected.

TGenomic_ins GetGenomic_ins(void) const

Get the variant data.

bool IsSetGenomic_strand(void) const

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

const TStd & GetStd(void) const

Get the variant data.

const TIds & GetIds(void) const

Get the Ids member data.

list< CRef< CSpliced_exon > > TExons

const TExons & GetExons(void) const

Get the Exons member data.

vector< int > TSecond_starts

TDim GetDim(void) const

Get the Dim member data.

const TDendiag & GetDendiag(void) const

Get the variant data.

TGenomic_strand GetGenomic_strand(void) const

Get the Genomic_strand member data.

bool IsSetStrands(void) const

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

const TPresent & GetPresent(void) const

Get the Present member data.

TProduct_strand GetProduct_strand(void) const

Get the Product_strand member data.

bool IsDiag(void) const

Check if variant Diag is selected.

const TStrands & GetStrands(void) const

Get the Strands member data.

const TIds & GetIds(void) const

Get the Ids member data.

const TStrands & GetStrands(void) const

Get the Strands member data.

list< CRef< CSpliced_exon_chunk > > TParts

vector< int > TFirst_starts

TGenomic_end GetGenomic_end(void) const

Get the Genomic_end member data.

const TStarts & GetStarts(void) const

Get the Starts member data.

TNumseg GetNumseg(void) const

Get the Numseg member data.

TProduct_strand GetProduct_strand(void) const

Get the Product_strand member data.

list< CRef< CSeq_align > > Tdata

const TSparse & GetSparse(void) const

Get the variant data.

bool IsSetGenomic_id(void) const

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

bool IsProduct_ins(void) const

Check if variant Product_ins is selected.

TDim GetDim(void) const

Get the Dim member data.

const TRows & GetRows(void) const

Get the Rows member data.

TProduct_ins GetProduct_ins(void) const

Get the variant data.

vector< ENa_strand > TSecond_strands

const TDisc & GetDisc(void) const

Get the variant data.

const TStrands & GetStrands(void) const

Get the Strands member data.

const Tdata & Get(void) const

Get the member data.

const TSegs & GetSegs(void) const

Get the Segs member data.

const TGenomic_id & GetGenomic_id(void) const

Get the Genomic_id member data.

bool IsSetGenomic_id(void) const

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

E_Choice Which(void) const

Which variant is currently selected.

@ e_Product_ins

insertion in product sequence (i.e. gap in the genomic sequence)

@ e_Diag

both sequences are represented, there is sufficient similarity between product and genomic sequences....

@ e_Genomic_ins

insertion in genomic sequence (i.e. gap in the product sequence)

@ e_Match

both sequences represented, product and genomic sequences match

@ e_Mismatch

both sequences represented, product and genomic sequences do not match

@ eProduct_type_transcript

E_Choice Which(void) const

Which variant is currently selected.

void SetLocation(TLocation &value)

Assign a value to Location data member.

bool IsCdregion(void) const

Check if variant Cdregion is selected.

void SetProduct(TProduct &value)

Assign a value to Product data member.

const TLocation & GetLocation(void) const

Get the Location member data.

TFrame GetFrame(void) const

Get the Frame member data.

const TData & GetData(void) const

Get the Data member data.

const TCdregion & GetCdregion(void) const

Get the variant data.

const TProduct & GetProduct(void) const

Get the Product member data.

bool IsSetProduct(void) const

product of process Check if a value has been assigned to Product data member.

const TFuzz_from & GetFuzz_from(void) const

Get the Fuzz_from member data.

void SetA(TA &value)

Assign a value to A data member.

bool IsMix(void) const

Check if variant Mix is selected.

const TB & GetB(void) const

Get the B member data.

bool IsEmpty(void) const

Check if variant Empty is selected.

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.

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.

const Tdata & Get(void) const

Get the member data.

const TEquiv & GetEquiv(void) const

Get the variant data.

list< CRef< CSeq_loc > > Tdata

vector< TSeqPos > TPoints

const TA & GetA(void) const

Get the A member data.

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.

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.

const TInt & GetInt(void) const

Get the variant data.

bool IsNull(void) const

Check if variant Null is selected.

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.

const TFuzz & GetFuzz(void) const

Get the Fuzz member data.

const TMix & GetMix(void) const

Get the variant data.

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.

@ 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 IsSetComp(void) const

compression (residues/value) Check if a value has been assigned to Comp data member.

void SetMin(TMin value)

Assign a value to Min data member.

void SetAxis(TAxis value)

Assign a value to Axis data member.

TValues & SetValues(void)

Assign a value to Values data member.

void SetAxis(TAxis value)

Assign a value to Axis data member.

TByte & SetByte(void)

Select the variant.

TMin GetMin(void) const

Get the Min member data.

const TInt & GetInt(void) const

Get the variant data.

void SetNumval(TNumval value)

Assign a value to Numval data member.

void SetComp(TComp value)

Assign a value to Comp data member.

TAxis GetAxis(void) const

Get the Axis member data.

TReal & SetReal(void)

Select the variant.

TInt & SetInt(void)

Select the variant.

const TGraph & GetGraph(void) const

Get the Graph member data.

TValues & SetValues(void)

Assign a value to Values data member.

const TValues & GetValues(void) const

Get the Values member data.

TMin GetMin(void) const

Get the Min member data.

TMax GetMax(void) const

Get the Max member data.

const TByte & GetByte(void) const

Get the variant data.

void SetGraph(TGraph &value)

Assign a value to Graph data member.

void SetMax(TMax value)

Assign a value to Max data member.

const TReal & GetReal(void) const

Get the variant data.

void SetMax(TMax value)

Assign a value to Max data member.

TAxis GetAxis(void) const

Get the Axis member data.

TMin GetMin(void) const

Get the Min member data.

TMax GetMax(void) const

Get the Max member data.

void SetMax(TMax value)

Assign a value to Max data member.

const TValues & GetValues(void) const

Get the Values member data.

E_Choice Which(void) const

Which variant is currently selected.

const TValues & GetValues(void) const

Get the Values member data.

void SetLoc(TLoc &value)

Assign a value to Loc data member.

const TLoc & GetLoc(void) const

Get the Loc member data.

void SetAxis(TAxis value)

Assign a value to Axis data member.

void Reset(void)

Reset the whole object.

void SetMin(TMin value)

Assign a value to Min data member.

TComp GetComp(void) const

Get the Comp member data.

TMax GetMax(void) const

Get the Max member data.

void SetMin(TMin value)

Assign a value to Min data member.

TValues & SetValues(void)

Assign a value to Values data member.

TAxis GetAxis(void) const

Get the Axis member data.

void SetData(TData &value)

Assign a value to Data data member.

list< CRef< CSeq_graph > > TGraph

list< CRef< CSeq_align > > TAlign

list< CRef< CSeq_feat > > TFtable

const TData & GetData(void) const

Get the Data member data.

E_Choice Which(void) const

Which variant is currently selected.

unsigned int

A callback function used to compare two keys in a database.

Definition of all error codes used in objects libraries.

constexpr auto sort(_Init &&init)

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

const GenericPointer< typename T::ValueType > T2 value

const CharType(& source)[N]

double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)

NCBI_PARAM_DECL(bool, Mapper, NonMapping_As_Null)

#define INDEX_TO_STRAND(idx)

#define STRAND_TO_INDEX(is_set, strand)

const CMappingRange::TFuzz kEmptyFuzz(0)

typedef NCBI_PARAM_TYPE(Mapper, NonMapping_As_Null) TNonMappingAsNullParam

ENa_strand s_IndexToStrand(size_t idx)

void CopyGraphData(const TData &src, TData &dst, TSeqPos from, TSeqPos to)

NCBI_PARAM_DEF_EX(bool, Mapper, NonMapping_As_Null, false, eParam_NoThread, MAPPER_NONMAPPING_AS_NULL)

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

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

#define row(bind, expected)

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