Struct bio_types::annot::spliced::Spliced

pub struct Spliced<R, S> { /* private fields */ }

Spliced sequence annotation on a particular, named sequence (e.g. a chromosome).

Parameterized over the type of the reference sequence identifier and over the strandedness of the position.

The display format for a Spliced is chr:start_0-end_0;start_1-end_1;…;start_N-end_N(+/-/.). The boundaries for each individual exon are given as a half-open 0-based interval, like the Rust Range and BED format.

let tad3 = Spliced::with_lengths_starts("chrXII".to_owned(), 765265,
                                        &vec![808,52,109], &vec![0,864,984],
                                        ReqStrand::Reverse)?;
assert_eq!(tad3.to_string(), "chrXII:765265-766073;766129-766181;766249-766358(-)");
let tad3_exons = tad3.exon_contigs();
assert_eq!(tad3_exons.len(), 3);
assert_eq!(tad3_exons[0].to_string(), "chrXII:766249-766358(-)");
assert_eq!(tad3_exons[1].to_string(), "chrXII:766129-766181(-)");
assert_eq!(tad3_exons[2].to_string(), "chrXII:765265-766073(-)");

Implementations

impl<R, S> Spliced<R, S>

pub fn new(refid: R, start: isize, exon_0_length: usize, strand: S) -> Self

Construct a new, single-exon “spliced” location

use std::rc::Rc;
use bio_types::annot::spliced::Spliced;
use bio_types::strand::ReqStrand;
let chr = Rc::new("chrX".to_owned());
let tma22 = Spliced::new(chr, 461829, 462426 - 461829, ReqStrand::Forward);

pub fn with_lengths_starts(
    refid: R,
    start: isize,
    exon_lengths: &[usize],
    exon_starts: &[usize],
    strand: S
) -> Result<Self, SplicingError>

Construct a multi-exon “spliced” location using BED-style exon starts and lengths.

pub fn exon_count(&self) -> usize

Number of exons

pub fn exon_starts(&self) -> Vec<usize>

Vector of exon starting positions, relative to the start of the location overall.

These positions run from left to right on the reference sequence, regardless of the location’s strand.

pub fn exon_lengths(&self) -> Vec<usize>

Vector of exon lengths.

Exon lengths are given from left to right on the reference sequence, regardless of the location’s strand.

pub fn exon_total_length(&self) -> usize

Total length of exons only.

The length method from the Loc trait returns the total length spanned by the annotation, including both introns and exons.

pub fn into_stranded(self, strand: ReqStrand) -> Spliced<R, ReqStrand>

Convert into a stranded sequence location on the specified strand

pub fn contig_cover(self) -> Contig<R, S>

impl<R> Spliced<R, ReqStrand>

pub fn exon_contigs(&self) -> Vec<Contig<R, ReqStrand>> where
    R: Clone, 

Trait Implementations

impl<R: Clone, S: Clone> Clone for Spliced<R, S>

fn clone(&self) -> Spliced<R, S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R: Debug, S: Debug> Debug for Spliced<R, S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R, S> Display for Spliced<R, S> where
    R: Display,
    S: Display, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R> From<Spliced<R, NoStrand>> for Spliced<R, Strand>

fn from(x: Spliced<R, NoStrand>) -> Self

Converts to this type from the input type.

impl<R> From<Spliced<R, ReqStrand>> for Spliced<R, NoStrand>

fn from(x: Spliced<R, ReqStrand>) -> Self

Converts to this type from the input type.

impl<R> From<Spliced<R, ReqStrand>> for Spliced<R, Strand>

fn from(x: Spliced<R, ReqStrand>) -> Self

Converts to this type from the input type.

impl<R> From<Spliced<R, Strand>> for Spliced<R, NoStrand>

fn from(x: Spliced<R, Strand>) -> Self

Converts to this type from the input type.

impl<R, S> FromStr for Spliced<R, S> where
    R: From<String>,
    S: FromStr<Err = StrandError>, 

type Err = ParseAnnotError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<R: Hash, S: Hash> Hash for Spliced<R, S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<R, S> Loc for Spliced<R, S>

type RefID = R

type Strand = S

fn refid(&self) -> &R

Name of the reference sequence (chromosome name, etc.)

fn start(&self) -> isize

Starting (lowest, left-most, 5’-most) position on the reference sequence (0-based).

fn length(&self) -> usize

Length of the region

fn strand(&self) -> S where
    S: Copy, 

Strand of the position

fn pos_into<T>(&self, pos: &Pos<Self::RefID, T>) -> Option<Pos<(), T>> where
    Self::RefID: Eq,
    Self::Strand: Into<ReqStrand> + Copy,
    T: Neg<Output = T> + Copy, 

Map a sequence position on a reference sequence into a relative position within an annotated location on the reference sequence.

fn pos_outof<Q, T>(&self, pos: &Pos<Q, T>) -> Option<Pos<Self::RefID, T>> where
    Self::RefID: Clone,
    Self::Strand: Into<ReqStrand> + Copy,
    T: Neg<Output = T> + Copy, 

Map a relative position within an annotated location out of that location onto the enclosing reference sequence.

fn contig_intersection<T>(&self, contig: &Contig<Self::RefID, T>) -> Option<Self> where
    Self::RefID: PartialEq + Clone,
    Self::Strand: Copy, 

fn contig(&self) -> Contig<Self::RefID, Self::Strand> where
    Self::RefID: Clone,
    Self::Strand: Copy, 

Contiguous sequence location that fully covers the location.

fn first_pos(&self) -> Pos<Self::RefID, Self::Strand> where
    Self::RefID: Clone,
    Self::Strand: Into<ReqStrand> + Copy, 

The first Pos in a location, on the annotated strand.

fn last_pos(&self) -> Pos<Self::RefID, Self::Strand> where
    Self::RefID: Clone,
    Self::Strand: Into<ReqStrand> + Copy, 

The last Pos in a location, on the annotated strand.

impl<R: PartialEq, S: PartialEq> PartialEq<Spliced<R, S>> for Spliced<R, S>

fn eq(&self, other: &Spliced<R, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Spliced<R, S>) -> bool

This method tests for !=.

impl<R: Eq, S: Eq> Eq for Spliced<R, S>

impl<R, S> StructuralEq for Spliced<R, S>

impl<R, S> StructuralPartialEq for Spliced<R, S>