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

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

NCBI C++ ToolKit: src/algo/align/prosplign/Info.cpp Source File

RestoreFivePrime(

beg)

;

RestoreThreePrime(

end)

;

&

= alignment_text.

();

& outp = alignment_text.

();

& orig_match = alignment_text.

();

list<CNPiece> m_AliPiece;

string::size_type n1 = outp.find_first_not_of(

);

string::size_type n2 = outp.find_last_not_of(

);

m_AliPiece.push_back(

(n1, n2+1, 0, 0));

= orig_match;

(

= 1;

<

.size()-1; ++

) {

(list<CNPiece>::iterator it = m_AliPiece.begin(); it != m_AliPiece.end(); ) {

m_AliPiece.splice(it,

);

it = m_AliPiece.erase(it);

(list<CNPiece>::iterator it = m_AliPiece.begin(); it != m_AliPiece.end(); ) {

m_AliPiece.splice(it,

);

it = m_AliPiece.erase(it);

( !m_AliPiece.empty() ) {

m_AliPiece.front().beg = trim.

(m_AliPiece.front(), m_options);

m_AliPiece.back().end = trim.

(m_AliPiece.back(), m_options);

( !m_AliPiece.empty() && m_options.

() ) {

string::size_type beg = m_AliPiece.front().beg;

string::size_type end = m_AliPiece.back().end;

m_AliPiece.push_back(

(beg, end, 0, 0));

( !m_AliPiece.empty() && m_options.

() > 0 ) {

(list<CNPiece>::iterator it = m_AliPiece.begin(); it != m_AliPiece.end(); ) {

list<CNPiece>::iterator sit = it;

(sit == m_AliPiece.end())

;

nuc_cnt = 0, prot_cnt = 0;

(

pos = hbeg; pos < hend; ++pos) {

it = m_AliPiece.erase(it);

( !m_AliPiece.empty() ) {

keep_trimming =

;

( keep_trimming ) {

& pc = *m_AliPiece.rbegin();

(;

>= pc.

; --

) {

(pc.

>= pc.

) {

m_AliPiece.pop_back();

( !m_AliPiece.empty() && m_options.

() ) {

(list<CNPiece>::iterator it = m_AliPiece.begin(); it != m_AliPiece.end(); ) {

pos = it->end - 1;

(; pos >= it->beg &&

[pos] ==

; --pos);

it = m_AliPiece.erase(it);

(list<CNPiece>::iterator it = m_AliPiece.begin(); it != m_AliPiece.end(); ) {

pos = it->end - 1;

it = m_AliPiece.erase(it);

(list<CNPiece>::iterator it = m_AliPiece.begin(); it != m_AliPiece.end(); ) {

pos = it->end - 1;

(; pos >= it->beg && (

(outp[pos]) || outp[pos] ==

) ; --pos);

it = m_AliPiece.erase(it);

(list<CNPiece>::iterator it = m_AliPiece.begin(); it != m_AliPiece.end(); ) {

(pos == it->end) {

it = m_AliPiece.erase(it);

( !m_AliPiece.empty() ) {

list<CNPiece> m_AliPiece;

&

= match_all_pos;

(

== string::npos ||

>= (

)pc.

)

m_AliPiece;

isintr =

;

string::size_type beg =

;

(;

<(unsigned)pc.

; ++

) {

m_AliPiece.push_back(

(beg,

, 0, efflen));

m_AliPiece.push_back(

(beg,

, efflen, efflen));

m_AliPiece.push_back(

(beg,

, efflen, efflen));

list<CNPiece>::iterator itb, ite, itc;

list<CNPiece>::size_type pnum = m_AliPiece.size() + 1;

(pnum > m_AliPiece.size()) {

pnum = m_AliPiece.size();

(itb = m_AliPiece.begin(); ; ) {

slen = 0, spos = 0;

(itc != m_AliPiece.end()) {

(m_options.

(itc))

;

(m_options.

(slen, spos, itb))

;

(m_options.

(itc, slen, spos, itb)) {

(m_options.

(itb, itc)) ite = itc;

m_options.

(itb, ite);

m_AliPiece.erase(itb, ite);

(itb == m_AliPiece.end())

;

itb = m_AliPiece.end();

(itb != m_AliPiece.begin()) {

slen = 0, spos = 0;

(itc != m_AliPiece.begin()) {

(m_options.

(itc))

;

(m_options.

(slen, spos, itb))

;

(m_options.

(itc, slen, spos, itb)) {

(m_options.

(itc, itb)) ite = itc;

m_options.

(ite, itb);

m_AliPiece.erase(ite, itb);

(itb == m_AliPiece.begin())

;

(list<CNPiece>::iterator it = m_AliPiece.begin(); it != m_AliPiece.end(); ) {

(it->posit == 0) it = m_AliPiece.erase(it);

(it->efflen < m_options.

()) it = m_AliPiece.erase(it);

&

= match_all_pos;

vector<pair<int, int> > exons;

in_exon =

;

(

=pc.

;

<pc.

; ) {

exons.push_back(make_pair(

, 0));

exons.back().second =

;

cur_beg = pc.

;

(vector<pair<int, int> >::iterator eit = exons.begin(); eit != exons.end(); ++eit) {

= eit->second - eit->first;

(

= eit->first; i < eit->second; ++

) {

(

= eit->first - 1;

> cur_beg; --

) {

(

> cur_beg) alip.push_back(

(cur_beg,

, 0, 0));

(

= eit->second;

< pc.

; ++

) {

(cur_beg < pc.

) alip.push_back(

(cur_beg, pc.

, 0, 0));

&

= alignment_text.

();

cnuc = 0, cprot = 0, cmax = 18;

(

= pc.

- 1;

>= pc.

; --

) {

score -= scoring.

;

score -= scoring.

;

score -= scoring.

;

(cnuc >= cmax && cprot >= cmax)

;

score -= scoring.

;

(

(efflen, posit, add))

;

(

()*(efflen+cur->efflen+add->efflen) > 100*(posit+cur->posit+add->posit))

;

posit =

->posit;

efflen =

->efflen;

(list<prosplign::CNPiece>::iterator it1 = it; it1 !=

; ++it1) {

efflen += it1->efflen;

->posit = posit;

->efflen = efflen;

->beg = it->beg;

efflen = it1->efflen;

pos = it1->posit;

(

(efflen, pos, it1))

;

efflen += it1->efflen;

efflen += it1->efflen;

efflen = it2->efflen;

pos = it2->posit;

(

(efflen, pos, it2))

;

efflen += it2->efflen;

efflen += it2->efflen;

((*field)->CanGetLabel() && (*field)->GetLabel().IsStr() && (*field)->GetLabel().GetStr()==

) {

(*field)->GetData().GetInt();

compartment_id = GetCompNum(seqalign);

nuc_from =

.GetFrom()+1;

nuc_to =

.GetTo()+1;

<<endl<<

<<endl;

<<

<<endl;

<<

<<endl;

<<compartment_id<<

<<contig_name<<

<<prot_id<<

<<nuc_from<<

<<nuc_to<<

;

<<(is_plus_strand?

:

)<<endl;

& dna = align_text.GetDNA();

& translation = align_text.GetTranslation();

= align_text.GetMatch();

& protein = align_text.GetProtein();

good_parts.append(

.size(),

);

(

= 0;

<

.size(); ++

) {

[

] = good_parts[

] =

;

npos1 = is_plus_strand?nuc_from:nuc_to;

prot_beg_pos =

(protein.find_first_not_of(

));

prot_end_pos =

(protein.find_last_not_of(

));

(

=0;

<prot_end_pos;

+=width) {

apos =

+width-1;

(apos >= (

)dna.length()) {

apos = (

)dna.length() - 1;

real_bases = width-gaps;

real_bases =

(width-

(dna.begin()+

, dna.begin()+(

+width),

));

npos2 = is_plus_strand?npos1+real_bases-1:npos1-(real_bases-1);

(apos > prot_beg_pos) {

.setf(IOS_BASE::left, IOS_BASE::adjustfield);

<<setw(12)<<npos1<<dna.substr(

, width)<<

<<npos2<<endl;

<<setw(12)<<

<<dna.substr(

, width)<<

<<

<<endl;

<<setw(12)<<

<<translation.substr(

, width)<<endl;

<<setw(12)<<

<<

.substr(

, width)<<endl;

<<setw(12)<<

<<protein.substr(

, width)<<endl;

<<setw(12)<<

<<good_parts.substr(

, width)<<endl;

npos1 = is_plus_strand?npos2+1:npos2-1;

CAliChunk(

ali_pos,

nuc_pos,

prot_pos, CSpliced_seg::TExons::iterator exon_iter, CSpliced_exon::TParts::iterator chunk_iter) :

m_nuc_pos(nuc_pos), m_prot_pos(prot_pos), m_exon_iter(exon_iter), m_chunk_iter(chunk_iter), m_bad(

)

}

(chunk.

()) {

m_ali_range =

(ali_pos, ali_pos +

(m_nuc_len,m_prot_len)-1);

CSpliced_seg::TExons::iterator m_exon_iter;

CSpliced_exon::TParts::iterator m_chunk_iter;

list<CAliChunk> TAliChunkCollection;

TAliChunkCollection::iterator TAliChunkIterator;

nuc_from =

.GetFrom();

nuc_to =

.GetTo();

alignment_pos = 0;

TAliChunkCollection chunks;

alignment_pos +=

(prot_cur_start-prot_from, nuc_cur_start-nuc_from);

nuc_from = nuc_cur_start;

alignment_pos +=

(prot_cur_start-prot_from, nuc_to-nuc_cur_end);

nuc_to = nuc_cur_end;

prot_from = prot_cur_start;

CAliChunk chunk(alignment_pos, strand ==

?nuc_from:nuc_to, prot_from, e_it, p_it);

alignment_pos = chunk.m_ali_range.GetTo()+1;

prot_from += chunk.m_prot_len;

nuc_from += chunk.m_nuc_len;

nuc_to -= chunk.m_nuc_len;

chunks.push_back(chunk);

list<TSeqRange> InvertPartList(

list<CNPiece>& good_parts,

total_range)

list<TSeqRange> bad_parts;

tail_beg = total_range.

();

tail_end = total_range.

();

(list<CNPiece>,

, good_parts) {

(tail_beg < i->beg)

bad_parts.push_back(

(tail_beg,

->beg-1));

(tail_beg <= tail_end)

bad_parts.push_back(

(tail_beg,tail_end));

}

(chunk.

()) {

( nuc_cur_end-nuc_cur_start+1 == nuc_len );

( prot_cur_end-prot_cur_start+1 == prot_len );

SplitChunk(TAliChunkCollection& chunks, TAliChunkIterator iter,

start_of_second_chunk,

genomic_plus)

( TestExonLength(**iter->m_exon_iter); );

( iter->m_ali_range.GetFrom() < start_of_second_chunk );

( start_of_second_chunk <= iter->m_ali_range.GetTo());

( iter->m_nuc_len == iter->m_prot_len );

new_chunk->Assign(**iter->m_chunk_iter);

first_len = start_of_second_chunk - iter->m_ali_range.GetFrom();

second_len = iter->m_ali_range.GetTo() - start_of_second_chunk+1;

TAliChunkIterator first_iter = chunks.insert(iter, *iter);

iter->m_nuc_pos += first_len;

iter->m_nuc_pos -= first_len;

iter->m_prot_pos += first_len;

(new_chunk->IsDiag()) {

new_chunk->SetDiag(first_len);

(*iter->m_chunk_iter)->SetDiag(second_len);

}

(new_chunk->IsMatch()) {

new_chunk->SetMatch(first_len);

(*iter->m_chunk_iter)->SetMatch(second_len);

}

(new_chunk->IsMismatch()) {

new_chunk->SetMismatch(first_len);

(*iter->m_chunk_iter)->SetMismatch(second_len);

first_iter->m_ali_range.SetTo(start_of_second_chunk-1);

iter->m_ali_range.SetFrom(start_of_second_chunk);

first_iter->m_nuc_len = first_iter->m_prot_len = first_len;

iter->m_nuc_len = iter->m_prot_len = second_len;

first_iter->m_chunk_iter = (*iter->m_exon_iter)->SetParts().insert(iter->m_chunk_iter, new_chunk);

( TestExonLength(**iter->m_exon_iter); );

exons.erase(exon_iter);

exon_iter = exons.end();

DropExonHead(TAliChunkIterator chunk_iter,

genomic_plus)

chunks_count = cur_exon->

().size();

cur_exon->

().erase(cur_exon->

().begin(), chunk_iter->m_chunk_iter);

chunks_count = cur_exon->

().size();

new_exon->Assign(*cur_exon);

CSpliced_exon::TParts::iterator new_exon_chunk = new_exon->SetParts().begin();

(old_exon_chunk==chunk_iter->m_chunk_iter)

new_exon->SetParts().erase(new_exon_chunk, new_exon->SetParts().end());

new_exon->SetGenomic_end(chunk_iter->m_nuc_pos-1);

new_exon->SetGenomic_start(chunk_iter->m_nuc_pos+1);

new_exon->SetPartial(

);

(new_exon->IsSetDonor_after_exon())

new_exon->ResetDonor_after_exon();

( new_exon->GetGenomic_start() <= new_exon->GetGenomic_end() );

( new_exon->GetProduct_start().AsSeqPos() <= new_exon->GetProduct_end().AsSeqPos() );

exons.insert(chunk_iter->m_exon_iter, new_exon);

DropExonHead(chunk_iter, genomic_plus);

( 0 < new_exon->GetParts().size() && 0 < cur_exon->

().size() );

( new_exon->GetParts().size()+cur_exon->

().size() == chunks_count );

(objects::CSeq_align& seq_align, objects::CScope& scope,

& matrix_name) {

&

= pro_text.GetProtein();

& dna = pro_text.GetDNA();

&

= pro_text.GetMatch();

pos = 0, ident = 0,

= 0, neg = 0, pgap = 0, ngap = 0;

(string::size_type

=0;

<

.size(); ++

) {

( (prot[

] !=

) && (

[

] !=

) ) {

(prot[

] ==

) {

}

(dna[

] ==

) {

(triple) ident +=3;

seq_align.SetNamedScore(

, ident);

seq_align.SetNamedScore(

, pos);

seq_align.SetNamedScore(

, neg);

seq_align.SetNamedScore(

, pgap);

seq_align.SetNamedScore(

, ngap);

seq_align.SetNamedScore(

,

);

(ibeg = 0; ibeg<(

)(

.size()) && ( (

[ibeg] ==

) || (

[ibeg] ==

) || (

[ibeg] ==

) ); ++ibeg) {}

(iend =

.size() - 1; iend >=0 && ( (

[iend] ==

) || (

[iend] ==

) || (

[iend] ==

) ); --iend) {}

(

=ibeg;

<=iend; ++

) {

( (prot[

] !=

) && (

[

] !=

) ) {

(prot[

] ==

) {

seq_align.SetNamedScore(

, ipgap);

TAliChunkCollection chunks = ExtractChunks(scope, seq_align);

list<TSeqRange> bad_parts = InvertPartList(good_parts,

(chunks.front().m_ali_range.GetFrom(),chunks.back().m_ali_range.GetTo()));

TAliChunkIterator chunk_iter = chunks.begin();

(list<TSeqRange>, bad_part, bad_parts) {

(chunk_iter != chunks.end() && chunk_iter->m_ali_range.GetTo() < bad_part->GetFrom()) {

(chunk_iter == chunks.end())

(bad_part->GetTo() < chunk_iter->m_ali_range.GetFrom())

(chunk_iter->m_ali_range.GetFrom() < bad_part->GetFrom())

SplitChunk(chunks, chunk_iter, bad_part->GetFrom(), genomic_plus);

(chunk_iter != chunks.end() && chunk_iter->m_ali_range.GetTo() <= bad_part->GetTo())

chunk_iter++->m_bad =

;

(chunk_iter != chunks.end() && chunk_iter->m_ali_range.GetFrom() <= bad_part->GetTo()) {

chunk_iter->m_bad =

;

SplitChunk(chunks, chunk_iter, bad_part->GetTo()+1, genomic_plus);

chunk_iter->m_bad =

;

CSpliced_seg::TExons::iterator prev_exon_iter = sps.

().end();

(chunk_it != chunks.end() && !chunk_it->m_bad) {

prev_exon_iter = chunk_it->m_exon_iter;

(chunk_it == chunks.end())

(prev_exon_iter != chunk_it->m_exon_iter) {

((*chunk_it->m_exon_iter)->IsSetAcceptor_before_exon())

(*chunk_it->m_exon_iter)->ResetAcceptor_before_exon();

SplitExon(sps.

(),chunk_it, genomic_plus);

prev_exon_iter = chunk_it->m_exon_iter;

TAliChunkIterator next_chunk_iter = chunk_it;

(next_chunk_iter != chunks.end() && next_chunk_iter->m_bad && next_chunk_iter->m_exon_iter==prev_exon_iter) {

chunk_it = next_chunk_iter++;

(next_chunk_iter == chunks.end() || next_chunk_iter->m_exon_iter!=prev_exon_iter) {

DropExon(sps.

(), prev_exon_iter);

DropExonHead(next_chunk_iter, genomic_plus);

TestExonLength(**e_it);

: m_alignment_text(alignment_text) {

& outp = alignment_text.

();

(

= 1;

<

.size()-1; ++

) {

(pbeg == string::npos)

beg;

( pbeg >= beg )

beg;

ali_len = (

)(beg - pbeg);

( ali_len > 36 )

beg;

mismatch_cnt = 0;

(

= pbeg;

< beg; ++

) {

( in_gap != -1 ) {

}

( dna_row[

] ==

) {

( in_gap != 1 ) {

( gap_cnt == 0 && mismatch_cnt < 10)

pbeg;

( gap_cnt < 3 && 100 * posit_cnt >= 60 * ali_len )

pbeg;

( gap_cnt < 2 && 100 * posit_cnt >= 50 * ali_len )

pbeg;

(pend == string::npos)

end;

( end >= pend )

end;

ali_len = (

)(pend-end);

( ali_len > 36 )

end;

mismatch_cnt = 0;

(

= end;

<pend; ++

) {

( tran_row[

] ==

)

end;

( in_gap != -1 ) {

}

( dna_row[

] ==

) {

( in_gap != 1 ) {

( gap_cnt == 0 && mismatch_cnt < 10)

pend;

( gap_cnt < 3 && 100 * posit_cnt >= 60 * ali_len )

pend;

( gap_cnt < 2 && 100 * posit_cnt >= 50 * ali_len )

pend;

keep_trimming =

;

( keep_trimming ) {

begpos = pc.

;

endpos = pc.

;

cur_max_drop = 0;

cur_cut = begpos;

cur_pos = begpos;

ps_dna_gap_len = 0;

ps_prot_gap_len = 0;

( cur_end >= endpos )

pc.

;

(

pos = cur_pos; pos < cur_end; ++pos ) {

( max_cut_len < cur_pos - begpos + 1 ) {

ps_len += ps_len_increment;

ps_pos += ps_len_increment;

ps_prot_gap_len = 0;

}

( dna[cur_pos] ==

) {

( ps_dna_gap_len < 3 ) {

ps_len += ps_len_increment;

ps_prot_gap_len = 0;

( ps_prot_gap_len < 3 ) {

ps_len += ps_len_increment;

ps_len += ps_len_increment;

ps_prot_gap_len = 0;

posit_drop = rposit/(double)

- ps_pos/(

)ps_len;

( posit_drop >= dropoff && ( posit_drop > cur_max_drop || cur_cut == begpos ) ) {

cur_max_drop = posit_drop;

}

( cur_end < endpos );

( cur_cut == begpos ) {

keep_trimming =

;

( ; cur_cut < endpos; ++cur_cut ) {

( cur_cut >= endpos )

pc.

;

( ; cur_cut >= begpos; --cur_cut) {

( cur_cut <= begpos )

pc.

;

keep_trimming =

;

( keep_trimming ) {

begpos = pc.

;

endpos = pc.

;

cur_max_drop = 0;

cur_cut = endpos;

win_end = endpos;

ps_dna_gap_len = 0;

ps_prot_gap_len = 0;

(

pos = win_beg; pos < win_end; ++pos ) {

( win_beg > begpos ) {

( max_cut_len < endpos - win_end ) {

cur_pos = win_end;

ps_len += ps_len_increment;

ps_pos += ps_len_increment;

ps_prot_gap_len = 0;

}

( dna[cur_pos] ==

) {

( ps_dna_gap_len < 3 ) {

ps_len += ps_len_increment;

ps_prot_gap_len = 0;

( ps_prot_gap_len < 3 ) {

ps_len += ps_len_increment;

ps_len += ps_len_increment;

ps_prot_gap_len = 0;

posit_drop = wposit/(double)

- ps_pos/(

)ps_len;

( posit_drop >= dropoff && ( posit_drop > cur_max_drop || cur_cut == endpos ) ) {

cur_max_drop = posit_drop;

( cur_cut == endpos ) {

keep_trimming =

;

( --cur_cut; cur_cut >= begpos; --cur_cut ) {

( cur_cut <= begpos )

pc.

;

( ; cur_cut < endpos; ++cur_cut ) {

(cur_cut >= endpos)

pc.

;

CRef< CProduct_pos > NultriposToProduct_pos(int nultripos)

Convert linear coordinate into (amin,frame)

list< CNPiece > ExcludeBadExons(const CNPiece pc, const string &match_all_pos, const string &protein, CProSplignOutputOptionsExt m_options)

const char BAD_OR_MISMATCH[]

list< CNPiece > FindGoodParts(const CProteinAlignText &alignment_text, CProSplignOutputOptionsExt m_options, const CProSplignScaledScoring &scoring, const CSubstMatrix &matrix)

const char BAD_PIECE_CHAR

USING_SCOPE(ncbi::objects)

bool TrimNegativeTail(CNPiece &pc, const CProteinAlignText &alignment_text, const CProSplignScaledScoring &scoring, const CSubstMatrix &matrix)

const char INTRON_OR_GAP[]

void RefineAlignment(objects::CScope &scope, objects::CSeq_align &seq_align, const list< CNPiece > &good_parts)

void SetScores(objects::CSeq_align &seq_align, objects::CScope &scope, const string &matrix_name="BLOSUM62")

CNPiece(string::size_type obeg, string::size_type oend, int oposit, int oefflen)

Extended output filtering parameters deprecated, used in older programs.

CProSplignOutputOptionsExt(const CProSplignOutputOptions &options)

bool Perc(list< prosplign::CNPiece >::iterator it, int efflen, int posit, list< prosplign::CNPiece >::iterator last)

bool ForwCheck(list< prosplign::CNPiece >::iterator it1, list< prosplign::CNPiece >::iterator it2)

void Join(list< prosplign::CNPiece >::iterator it, list< prosplign::CNPiece >::iterator last)

bool Bad(list< prosplign::CNPiece >::iterator it)

bool BackCheck(list< prosplign::CNPiece >::iterator it1, list< prosplign::CNPiece >::iterator it2)

bool Dropof(int efflen, int posit, list< prosplign::CNPiece >::iterator it)

Output filtering parameters.

bool GetCutFlankPartialCodons() const

int GetTotalPositives() const

int GetCutFlanksWithPositGapRatio() const

int GetCutFlanksWithPositWindow() const

int GetCutFlanksWithPositMaxLen() const

bool GetFillHoles() const

bool GetCutFlanksWithPositDrop() const

int GetMinHoleLen() const

int GetMinFlankingExonLen() const

int GetMinGoodLen() const

int GetFlankPositives() const

int GetCutFlanksWithPositDropoff() const

int GetMinExonPos() const

int GetStartBonus() const

bool IsPassThrough() const

static void Output(const objects::CSeq_align &seqalign, objects::CScope &scope, ostream &out, int width, const string &matrix_name="BLOSUM62")

Outputs formatted text.

size_t RestoreThreePrime(size_t end) const

CProSplignTrimmer(const CProteinAlignText &alignment_text)

CProSplignTrimmer implementation.

size_t RestoreFivePrime(size_t beg) const

checks if alignment ends should be restored beyond 'beg' or 'end' returns new flanking coord or 'beg'...

int CutFromRight(CNPiece pc, const CProSplignOutputOptionsExt &options) const

trim right flank with positives dropoff over a cutoff, iterative 'pc' should not be dropped completel...

int CutFromLeft(CNPiece pc, const CProSplignOutputOptionsExt &options) const

trim flanks with positives dropoff over a cutoff, iterative flank 'good pieces' should not be dropped...

const CProteinAlignText & m_alignment_text

Text representation of ProSplign alignment.

const string & GetDNA() const

const string & GetMatch() const

const string & GetProtein() const

static CRef< objects::CSeq_loc > GetGenomicBounds(objects::CScope &scope, const objects::CSeq_align &seqalign)

const string & GetTranslation() const

Substitution Matrix for Scoring Amino-Acid Alignments.

int ScaledScore(char amin1, char amin2) const

static const char * bounds[]

Include a standard set of the NCBI C++ Toolkit most basic headers.

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

main entry point for tests

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

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

#define _DEBUG_CODE(code)

#define NCBI_THROW(exception_class, err_code, message)

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

string GetSeqIdString(bool with_version=false) const

Return seqid string with optional version for text seqid type.

CRange< TSeqPos > TSeqRange

typedefs for sequence ranges

#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.

TTo GetTo(void) const

Get the To member data.

TFrom GetFrom(void) const

Get the From member data.

bool CanGetData(void) const

Check if it is safe to call GetData method.

const TData & GetData(void) const

Get the Data member data.

vector< CRef< CUser_field > > TData

const TGenomic_id & GetGenomic_id(void) const

Get the Genomic_id member data.

void SetProduct_start(TProduct_start &value)

Assign a value to Product_start data member.

TMatch GetMatch(void) const

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

bool IsMismatch(void) const

Check if variant Mismatch is selected.

void SetSegs(TSegs &value)

Assign a value to Segs data member.

bool IsSetAcceptor_before_exon(void) const

splice sites Check if a value has been assigned to Acceptor_before_exon data member.

TExons & SetExons(void)

Assign a value to Exons data member.

TDiag GetDiag(void) const

Get the variant data.

TMismatch GetMismatch(void) const

Get the variant data.

TGenomic_strand GetGenomic_strand(void) const

Get the Genomic_strand member data.

list< CRef< CUser_object > > TExt

void SetGenomic_start(TGenomic_start value)

Assign a value to Genomic_start data member.

const TParts & GetParts(void) const

Get the Parts member data.

const TProduct_start & GetProduct_start(void) const

Get the Product_start member data.

const TProduct_end & GetProduct_end(void) const

Get the Product_end member data.

const TSpliced & GetSpliced(void) const

Get the variant data.

bool IsGenomic_ins(void) const

Check if variant Genomic_ins is selected.

bool IsMatch(void) const

Check if variant Match is selected.

TGenomic_ins GetGenomic_ins(void) const

Get the variant data.

void SetPartial(TPartial value)

Assign a value to Partial data member.

bool CanGetExt(void) const

Check if it is safe to call GetExt method.

list< CRef< CSpliced_exon > > TExons

const TExons & GetExons(void) const

Get the Exons member data.

void ResetAcceptor_before_exon(void)

Reset Acceptor_before_exon data member.

TParts & SetParts(void)

Assign a value to Parts data member.

bool IsDiag(void) const

Check if variant Diag is selected.

void SetGenomic_end(TGenomic_end value)

Assign a value to Genomic_end data member.

const TExt & GetExt(void) const

Get the Ext member data.

list< CRef< CSpliced_exon_chunk > > TParts

TGenomic_end GetGenomic_end(void) const

Get the Genomic_end member data.

bool IsProduct_ins(void) const

Check if variant Product_ins is selected.

TProduct_ins GetProduct_ins(void) const

Get the variant data.

const TSegs & GetSegs(void) const

Get the Segs member data.

ENa_strand

strand of nucleic acid

unsigned int

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

static int match(PCRE2_SPTR start_eptr, PCRE2_SPTR start_ecode, uint16_t top_bracket, PCRE2_SIZE frame_size, pcre2_match_data *match_data, match_block *mb)

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