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

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

NCBI C++ ToolKit: src/algo/sequence/project_exons.cpp Source File

CSeq_loc::TMix::Tdata::iterator dest = loc.

().Set().begin();

loc.

().Set().erase(dest, loc.

().Set().end());

loc.

(*content_loc);

}

(loc.

().

().size() == 0) {

max_start == min_stop + 1;

is_5p_partial(

);

is_3p_partial(

);

prev_exon = current_exon;

is_consensus_donor =

is_consensus_acceptor =

&& (!is_consensus_acceptor || is_consensus_donor))

is_5p_partial =

;

&& (!is_consensus_donor || is_consensus_acceptor))

is_3p_partial =

;

prev_exon = current_exon;

unaligned_ends_partialness_thr)

(!product_cds_loc) {

> unaligned_ends_partialness_thr;

> unaligned_ends_partialness_thr;

cds_stop = cds_stop*3+2;

start_covered =

;

stop_covered =

;

partialness.first = !start_covered

partialness.second = !stop_covered

(partialness.first, partialness.second);

(partialness.first) {

(partialness.second) {

(convert_overlaps) {

<< (orig_loc.

(*loc) ?

:

)

(convert_overlaps) {

<

T>

(SerialClone<T>(x));

<

iterator_t>

( (d < 0 && distance(begin, it) <

(d))

|| (d > 0 && distance(it, end) <

(d)))

<

container_t>

container_t& container,

container_t::const_iterator it,

it == container.end() ? default_value : *it;

CPacked_seqint::Tdata::const_iterator it)

CPacked_seqint::Tdata::const_iterator it)

.GetId().Equals(

.GetId())

(

% 3) == 0;

: seqint.

(pos));

);

CPacked_seqint::Tdata::iterator dest = seqints.begin();

can_subsume =

seqints.erase(seqints.end() == dest ? dest : ++dest,

}

(overlap > 2) {

}

(

->GetLength() > 3) {

CPacked_seqint::Tdata::iterator dest = seqints.begin();

seqints.erase(seqints.end() == dest ? dest : ++dest,

(packed_seqint.

().empty()) {

;

<< (d < 0 ?

:

) <<

(d)

<<

<< seqint->GetLength();

ostr << (!prev_seqint ?

:

)

<< seqint->GetId().GetSeqIdString()

<<

<< seqint->GetLength();

prev_seqint = seqint;

);

problem_str +=

;

(d != 1 && d != 2) {

(!problem_str.empty()) {

<<

<< problem_str <<

;

& aln_genomic_id,

convert_overlaps)

: aln_genomic_strand;

exon_loc->

().SetId().Assign( genomic_id);

exon_loc->

().SetStrand( genomic_strand);

vector<pair<int, int> > TExonStructure;

TExonStructure exon_structure;

last_is_diag =

;

(is_diag && last_is_diag) {

exon_structure.back().first +=

;

exon_structure.back().second +=

;

}

(is_diag) {

(exon_structure.empty()) {

: exon_structure.back().second) +=

;

last_is_diag = is_diag;

(it != exon_structure.begin()) {

it->second += (it-1)->second;

(TExonStructure, it, exon_structure) {

chunk_length = it->first;

chunk_offset = it == exon_structure.begin() ? 0 : (it-1)->second;

(chunk_length == 0) {

bio_start = exon_bio_start_pos + (chunk_offset * genomic_sign);

pos = (

)bio_start + (chunk_length - 1) * genomic_sign;

pos = ((pos % 3) + 3) % 3;

chunk->

().Assign(genomic_id);

chunk->

(genomic_sign > 0 ? bio_start : bio_stop);

chunk->

(genomic_sign > 0 ? bio_stop : bio_start);

( (q_len - s_len) % 3 ) {

last_is_diag =

;

is_diag = chunk.

()

start_new_block =

: last_is_diag ?

last_is_diag = is_diag;

(

.size() > 1

&&

.front().diag < 3)

(

[1].diag > 0) {

&&

.back().diag > 0

&&

.back().HasGap())

SBlocks::iterator dest = this->begin();

}

( !it->diag

|| !dest->IsFrameshifting()

&& &(*it) != &back()

&& &(*it) != &

() ) )

(it != this->end()) {

this->erase(it, this->end());

& aln_genomic_id,

: aln_genomic_strand;

exon_loc->

().SetId().Assign( genomic_id);

exon_loc->

().SetStrand( genomic_strand);

exon_bio_start_pos =

exon_relative_subj_start = 0;

bio_start = exon_bio_start_pos

+ (exon_relative_subj_start * genomic_sign);

= it->GetFramePreservingSubjLen();

bio_stop = bio_start + ((

- 1) * genomic_sign);

chunk->

().Assign(genomic_id);

chunk->

( genomic_sign > 0 ? bio_start : bio_stop);

chunk->

( genomic_sign > 0 ? bio_stop : bio_start);

exon_relative_subj_start += it->diag + it->s_ins;

exon_product_len =

(loc_len % 3 != exon_product_len % 3) {

);

& aln_genomic_id,

convert_overlaps)

-

(exon->GetProduct_start()) + 1;

subject_range = exon->GetGenomic_end() - exon->GetGenomic_start() + 1;

min_range =

(query_range, subject_range);

max_range =

(query_range, subject_range);

diag1->SetDiag(min_range / 2);

diag2->SetDiag(min_range - diag1->GetDiag());

(max_range == subject_range) {

gap_chunk->SetGenomic_ins(max_range - min_range);

gap_chunk->SetProduct_ins(max_range - min_range);

exon->SetParts().clear();

exon->SetParts().push_back(diag1);

exon->SetParts().push_back(gap_chunk);

exon->SetParts().push_back(diag2);

convert_overlaps)

exon_aln->ResetScore();

exon_aln->ResetExt();

exon_aln->SetSegs().SetSpliced().SetExons().clear();

exon_aln->SetSegs().SetSpliced().SetExons().push_back(

mapper->SetTrimSplicedSeg(

);

truncated_exon_aln = mapper->Map(*exon_aln);

truncated_exon_aln->

(*exon_aln);

truncated_exon_aln->

().SetSpliced().SetExons().clear();

(truncated_exon_aln->GetSegs().GetSpliced()

.GetExons().empty())

*exon_aln->SetSegs().SetSpliced().SetExons().front());

exon_aln->SetSegs().SetSpliced().SetExons().front() = collapsed_exon;

truncated_exon_aln = mapper->Map(*exon_aln);

(truncated_exon_aln->GetSegs().GetSpliced()

.GetExons().empty())

*truncated_exon_aln->GetSegs().GetSpliced().GetExons().front(),

exon_loc->SetPacked_int().Set().insert(

exon_loc->SetPacked_int().Set().end(),

(!product_cds_loc) {

(mapped_collapsed_cds_subloc->

()) {

}

(mapped_collapsed_cds_subloc->

()) {

&mapped_collapsed_cds_subloc->

());

->Set().push_back(seqint);

same_stop = src.

(ext) == dest.

(ext);

(!collapsed_genomic_cds) {

detailed_rna_exon;

(cds_exon->

()) {

out_loc->

().Set().push_back(cds_exon);

convert_overlaps,

unaligned_ends_partialness_thr = 0)

genomic_collapsed_cds);

(!product_cds_loc) {

}

(exon_loc->

()) {

start_partial = partialness.first;

stop_partial = partialness.second;

(start_partial, stop_partial);

exons_loc->

().Set().push_back(exon_loc);

unaligned_ends_partialness_thr));

(loc.

()) {

collapsed_loc->

();

collapsed_loc->

().Set().push_back(collapsed_exon_loc);

count_terminals_within_cds =

(last_interval.

() >= cds_start && last_interval.

() <= cds_stop ? 1 : 0)

+ ( interval.

() >= cds_start && interval.

() <= cds_stop ? 1 : 0)

+ (last_interval.

() >= cds_start && last_interval.

() <= cds_stop ? 1 : 0)

+ ( interval.

() >= cds_start && interval.

() <= cds_stop ? 1 : 0);

( count_terminals_within_cds <= 1

loc1.

(last_interval);

<<

<<

<< cds_start <<

<< cds_stop <<

<<

<< count_terminals_within_cds <<

collapsed_loc->

(loc);

collapsed_loc;

loc_mix.

().push_back(exons_loc);

& exons = exons_loc->

() ? exons_loc->

().Set() : loc_mix.Set();

(

it = exons.begin(); it != exons.end(); ++it) {

(

it = chunks.begin(); it != chunks.end(); ++it) {

is_overlapping = [&](

pos)

ivl->GetFrom() <= pos && pos <= ivl->GetTo();

( is_overlapping(cds_start)

&& !is_overlapping(cds_start + (is_minus_strand ? -2 : 2))

&& next_ivl->GetLength() > 3)

( is_overlapping(cds_stop)

&& !is_overlapping(cds_stop - (is_minus_strand ? -2 : 2))

&& prev_ivl->GetLength() > 3)

(orig_len == final_len);

unaligned_ends_partialness_thr)

unaligned_ends_partialness_thr);

(product_cds_loc) {

cds_start, cds_stop),

cds_start, cds_stop);

convert_overlaps)

todo: move to unit-

CollapseMatches(

& spliced_aln)

chunk2->Assign(chunk);

(current_is_diag) {

chunk2->SetDiag(

);

CFeatureGenerator::TestProjectExons(

& aln2)

aln_ref->Assign(aln2);

CollapseMatches(*aln_ref);

all_ok =

;

this_ok =

;

(covered_cds->

()) {

allowed_unaligned_ends_len = 6;

(query_sv.size() != subject_sv.size()) {

<<

<< query_sv.size()

<<

<< subject_sv.size());

aln_cds_matches(0);

aln_cds_matches += chunk.

();

seq_cds_matches(0);

(

= 0;

< query_sv.size();

++) {

seq_cds_matches += (query_sv[

] == subject_sv[

] ? 1 : 0);

(seq_cds_matches < aln_cds_matches) {

<< aln_cds_matches <<

<< seq_cds_matches <<

);

all_ok = all_ok & this_ok;

ESeqLocExtremes

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

@ eExtreme_Positional

numerical value

@ eExtreme_Biological

5' and 3'

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

User-defined methods of the data storage class.

CRef< CSpliced_exon > spliced_exon(const CModelExon &e, EStrand strand)

Seq-loc and seq-align mapper exceptions.

unique_ptr< SImplementation > m_impl

static CRef< objects::CSeq_loc > s_ProjectCDS(const objects::CSeq_align &spliced_aln, const objects::CSeq_loc &product_cds_loc, bool convert_overlaps=true)

Similar to s_ProjectRNA(...) Postcondition: seq-vector of the returned loc is of exact same length an...

static CRef< objects::CSeq_loc > s_ProjectRNA(const objects::CSeq_align &spliced_aln, CConstRef< objects::CSeq_loc > product_cds_loc=CConstRef< objects::CSeq_loc >(NULL), size_t unaligned_ends_partialness_thr=kDefaultAllowedUnaligned)

Project RNA, preserving discontinuities in the CDS.

CNcbiOstrstreamToString class helps convert CNcbiOstrstream to a string Sample usage:

CProt_pos_Base::TFrame GetFrame() const

TSeqPos GetSeqStop(TDim row) const

CRef< CSeq_loc > CreateRowSeq_loc(TDim row) const

const CSeq_id & GetSeq_id(TDim row) const

Get seq-id (the first one if segments have different ids).

TSeqPos GetSeqStart(TDim row) const

ENa_strand GetSeqStrand(TDim row) const

Get strand (the first one if segments have different strands).

TSeqPos GetStart(ESeqLocExtremes ext) const

TSeqPos GetLength(void) const

TSeqPos GetStop(ESeqLocExtremes ext) const

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

Template class for iteration on objects of class C (non-medifiable version)

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

main entry point for tests

#define test(a, b, c, d, e)

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

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

unsigned int TSeqPos

Type for sequence locations and lengths.

#define ITERATE(Type, Var, Cont)

ITERATE macro to sequence through container elements.

int TSignedSeqPos

Type for signed sequence position.

#define NON_CONST_ITERATE(Type, Var, Cont)

Non constant version of ITERATE macro.

const TSeqPos kInvalidSeqPos

Define special value for invalid sequence position.

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

#define ERR_POST(message)

Error posting with file, line number information but without error codes.

#define NCBI_USER_THROW(message)

Throw a quick-and-dirty runtime exception of type 'CException' with the given error message and error...

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_RETHROW_SAME(prev_exception, message)

Generic macro to re-throw the same exception.

void Warning(CExceptionArgs_Base &args)

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

Set object to copy of another one.

C * SerialClone(const C &src)

Create on heap a clone of the source object.

#define MSerial_AsnText

I/O stream manipulators –.

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

Check if both objects contain the same values.

const string AsFastaString(void) 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 SetPacked_int(TPacked_int &v)

bool IsPartialStart(ESeqLocExtremes ext) const

check start or stop of location for e_Lim fuzz

ENa_strand GetStrand(void) const

Get the location's strand.

void ChangeToPackedInt(void)

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

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

Override Assign() to incorporate cache invalidation.

TSeqPos GetStart(ESeqLocExtremes ext) const

Return start and stop positions of the seq-loc.

bool IsTruncatedStop(ESeqLocExtremes ext) const

bool IsTruncatedStart(ESeqLocExtremes ext) const

check if parts of the seq-loc are missing

const CSeq_id * GetId(void) const

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

void SetPartialStart(bool val, ESeqLocExtremes ext)

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

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.

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)

TSeqPos GetStop(ESeqLocExtremes ext) const

@ eOrder_Biological

Iterate sub-locations in positional order.

CBeginInfo Begin(C &obj)

Get starting point of object hierarchy.

TSeqPos GetStop(const CSeq_loc &loc, CScope *scope, ESeqLocExtremes ext=eExtreme_Positional)

If only one CBioseq is represented by CSeq_loc, returns the position at the stop of the location.

TSeqPos GetLength(const CSeq_id &id, CScope *scope)

Get sequence length if scope not null, else return max possible TSeqPos.

TSeqPos GetStart(const CSeq_loc &loc, CScope *scope, ESeqLocExtremes ext=eExtreme_Positional)

If only one CBioseq is represented by CSeq_loc, returns the position at the start of the location.

sequence::ECompare Compare(const CSeq_loc &loc1, const CSeq_loc &loc2, CScope *scope)

Returns the sequence::ECompare containment relationship between CSeq_locs.

CRef< CSeq_loc > Seq_loc_Merge(const CSeq_loc &loc, CSeq_loc::TOpFlags flags, CScope *scope)

Merge ranges in the seq-loc.

CRef< CSeq_loc > Seq_loc_Add(const CSeq_loc &loc1, const CSeq_loc &loc2, CSeq_loc::TOpFlags flags, CScope *scope)

Add two seq-locs.

@ fCompareOverlapping

Check if seq-locs are overlapping.

@ eNoOverlap

CSeq_locs do not overlap or abut.

CRef< CSeq_loc > Map(const CSeq_loc &src_loc)

Map seq-loc.

CBioseq_Handle GetBioseqHandle(const CSeq_id &id)

Get bioseq handle by seq-id.

CSeq_loc_Mapper_Base & SetTrimSplicedSeg(bool trim)

For mapping spliced-segs only: preserve or trim starting/ending indels.

@ eBadAlignment

Unsuported or invalid alignment.

@ eCoding_Iupac

Set coding to printable coding (Iupacna or Iupacaa)

const CSeq_loc & GetLocation(void) const

void Reset(void)

Reset reference object.

int64_t Int8

8-byte (64-bit) signed integer

#define END_NCBI_SCOPE

End previously defined NCBI scope.

#define BEGIN_NCBI_SCOPE

Define ncbi namespace.

const TDonor_after_exon & GetDonor_after_exon(void) const

Get the Donor_after_exon member data.

const TProtpos & GetProtpos(void) const

Get the variant data.

bool IsSetFrame(void) const

position within codon (1-based) 0 = not set (meaning 1) Check if a value has been assigned to Frame d...

bool IsProtpos(void) const

Check if variant Protpos is selected.

bool IsSetParts(void) const

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

TMatch GetMatch(void) const

Get the variant data.

TGenomic_start GetGenomic_start(void) const

Get the Genomic_start member data.

const TAcceptor_before_exon & GetAcceptor_before_exon(void) const

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

TProduct_length GetProduct_length(void) const

Get the Product_length member data.

bool IsSetPoly_a(void) const

start of poly(A) tail on the transcript For sense transcripts: aligned product positions < poly-a <= ...

TDiag GetDiag(void) const

Get the variant data.

TProduct_type GetProduct_type(void) const

Get the Product_type member data.

TMismatch GetMismatch(void) const

Get the variant data.

bool IsSetGenomic_strand(void) const

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

TAmin GetAmin(void) const

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

list< CRef< CSpliced_exon > > TExons

const TExons & GetExons(void) const

Get the Exons member data.

TGenomic_strand GetGenomic_strand(void) const

Get the Genomic_strand member data.

bool IsDiag(void) const

Check if variant Diag is selected.

const TBases & GetBases(void) const

Get the Bases member data.

list< CRef< CSpliced_exon_chunk > > TParts

bool IsSetProduct_length(void) const

length of the product, in bases/residues from this (or from poly-a if present), a 3' unaligned length...

TGenomic_end GetGenomic_end(void) const

Get the Genomic_end member 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.

bool IsNucpos(void) const

Check if variant Nucpos is selected.

TProduct_ins GetProduct_ins(void) const

Get the variant data.

TNucpos GetNucpos(void) const

Get the variant 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 IsSetDonor_after_exon(void) const

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

void SetTo(TTo value)

Assign a value to To data member.

bool IsMix(void) const

Check if variant Mix is selected.

list< CRef< CSeq_interval > > Tdata

ENa_strand

strand of nucleic acid

const Tdata & Get(void) const

Get the member data.

const TId & GetId(void) const

Get the Id member data.

Tdata & Set(void)

Assign a value to data member.

void SetId(TId &value)

Assign a value to Id data member.

TFrom GetFrom(void) const

Get the From member data.

list< CRef< CSeq_loc > > Tdata

void SetFrom(TFrom value)

Assign a value to From data member.

const Tdata & Get(void) const

Get the member data.

bool IsPacked_int(void) const

Check if variant Packed_int is selected.

bool IsSetStrand(void) const

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

Tdata & Set(void)

Assign a value to data member.

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.

bool IsNull(void) const

Check if variant Null is selected.

void SetStrand(TStrand value)

Assign a value to Strand data member.

const TMix & GetMix(void) const

Get the variant data.

const TPacked_int & GetPacked_int(void) const

Get the variant data.

constexpr auto front(list< Head, As... >, T=T()) noexcept -> Head

double value_type

The numeric datatype used by the parser.

Defines: CTimeFormat - storage class for time format.

Int4 delta(size_t dimension_, const Int4 *score_)

CRef< CPacked_seqint > ProjectAndCollapseCDS(const CSeq_align &spliced_aln, CConstRef< CSeq_loc > product_cds_loc)

static TSeqPos as_nucpos(const CProduct_pos &pos)

static CRef< CSeq_loc > PreserveTerminalCodons(CRef< CSeq_loc > exons_loc, TSeqPos cds_start, TSeqPos cds_stop)

static CRef< CSeq_loc > ProjectExon_newlogic(const CSpliced_exon &exon, const CSeq_id &aln_genomic_id, ENa_strand aln_genomic_strand)

void Canonicalize(CSeq_loc &loc)

Recursively convert empty container-locs to null-locs, drop null sublocs from containers,...

T53Partialness GetTerminalPartialness(const CSeq_align &spliced_aln, CConstRef< CSeq_loc > product_cds_loc, size_t unaligned_ends_partialness_thr)

Return whether 5' and/or 3' end of exons-loc is partial based on unaligned tails in case of RNA,...

bool AreAbuttingOnProduct(const CSpliced_exon &exon1, const CSpliced_exon &exon2)

retrun true iff abutting on query (in nucpos-coords)

CRef< CSeq_loc > ProjectExons(const CSeq_align &spliced_aln, CConstRef< CSeq_loc > product_cds_loc, bool convert_overlaps, size_t unaligned_ends_partialness_thr=0)

size_t GetUnalignedLength_3p(const CSeq_align &spliced_aln)

T53Partialness GetExonPartialness(const CSeq_align &spliced_aln, const CSpliced_exon &target_exon)

Return whether 5' and/or 3' end of exon is partial based on consensus splicing with upstream/downstre...

CRef< CSeq_loc > TruncateToCDS(CRef< CSeq_loc > detailed_rna_exon, CConstRef< CPacked_seqint > collapsed_genomic_cds)

static CRef< CSeq_loc > ProjectExon(const CSpliced_exon &exon, const CSeq_id &aln_genomic_id, ENa_strand aln_genomic_strand, bool convert_overlaps)

static CRef< CSeq_loc > ProjectExon_oldlogic(const CSpliced_exon &spliced_exon, const CSeq_id &aln_genomic_id, ENa_strand aln_genomic_strand, bool convert_overlaps)

pair< bool, bool > T53Partialness

first and ::second indicate partialness for of a loc or an exon, 5' and 3' end respectively.

void TransferPartialness(const CSeq_loc &src, CSeq_loc &dest)

CRef< CSpliced_exon > CollapseExonStructure(const CSpliced_exon &orig_exon)

Create an exon with the structure consisting of two diags extending inwards from the exon terminals w...

void AugmentPartialness(CSeq_loc &loc, T53Partialness partialness)

size_t GetUnalignedLength_5p(const CSeq_align &spliced_aln)

CRef< CSeq_loc > CollapseDiscontinuitiesInUTR(const CSeq_loc &loc, TSeqPos cds_start, TSeqPos cds_stop)

Precondition: input loc is discontinuity-preserving RNA loc Postcontition: adjacent packed-ints havin...

static bool SameIdAndStrand(const CSeq_interval &a, const CSeq_interval &b)

static void SetBioStart(CSeq_interval &seqint, TSeqPos pos)

static void Validate(const CSeq_loc &orig_loc, const CSeq_loc &final_loc)

static void AdjustBioStop(CSeq_interval &seqint, TSignedSeqPos amt)

static void CheckIdAndStrand(const CPacked_seqint &ps)

static TSignedSeqPos GetGapLength(const CSeq_interval &prev, const CSeq_interval &curr)

static void SubsumeMicroIntervals(CPacked_seqint &ps)

static bool MinusStrand(const CSeq_interval &seqint)

static void ConvertOverlapsToGaps(CPacked_seqint &ps)

static bool CanCreateNonframeshiftingGap(const CSeq_interval &prev, const CSeq_interval &curr, const CSeq_interval &next)

static void CollapseNonframeshiftting(CPacked_seqint &ps)

static CRef< T > Clone(const T &x)

static CRef< CSeq_loc > TweakExon(const CSeq_loc &orig_loc, bool convert_overlaps)

static CRef< CSeq_interval > Collapse(const CSeq_interval &a, const CSeq_interval &b)

static container_t::value_type rel_at(const container_t &container, typename container_t::const_iterator it, Int8 delta, typename container_t::value_type default_value)

static void AdjustBioStart(CSeq_interval &seqint, TSignedSeqPos amt)

static const TSeqPos k_keep_len

static void AdjustBiostops(CPacked_seqint &ps)

static string AsString(const CPacked_seqint &packed_seqint)

static void SetBioStop(CSeq_interval &seqint, TSeqPos pos)

static const TSeqPos k_min_len

static void safe_advance(iterator_t begin, iterator_t end, iterator_t &it, Int8 d)

static TSeqPos GetBiostartsDelta(const CSeq_interval &upst, const CSeq_interval &downst)

static CRef< CSeq_interval > Prev(const CPacked_seqint::Tdata &seqints, const CPacked_seqint::Tdata::const_iterator it)

static CRef< CSeq_interval > Next(const CPacked_seqint::Tdata &seqints, const CPacked_seqint::Tdata::const_iterator it)

bool IsFrameshifting() const

size_t GetFramePreservingSubjLen() const

void Add(const SBlock &other)

void EraseAfter(SBlocks::iterator it)

SBlocks(const CSpliced_exon &spliced_exon)

static DP_BlockInfo * blocks

int g(Seg_Gsm *spe, Seq_Mtf *psm, Thd_Gsm *tdg)

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