Struct bio_types::annot::contig::Contig

pub struct Contig<R, S> { /* fields omitted */ }

Contiguous sequence region 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 Contig is chr:start-end(+/-/.). The boundaries are given as a half-open 0-based interval, like the Rust Range and BED format.

use bio_types::annot::contig::Contig;
use bio_types::strand::ReqStrand;
let tma19 = Contig::new("chrXI".to_owned(), 334412, (334916 - 334412), ReqStrand::Reverse);
let tma19_str = tma19.to_string();
assert_eq!(tma19_str, "chrXI:334412-334916(-)");
let tma19_str_loc = tma19_str.parse()?;
assert_eq!(tma19, tma19_str_loc);

Implementations

impl<R, S> Contig<R, S>

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

Construct a new sequence contig location

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

pub fn with_first_length(
    pos: &Pos<R, S>,
    length: usize
) -> Result<Self, AnnotError> where
    R: Clone,
    S: Into<Option<ReqStrand>> + Copy, 

Construct a new sequence contig location from a starting position and length.

In general, the starting position must have a "strandedness", and reverse-strand starting positions will extend towards lower coordinates from the starting position.

use bio_types::annot::contig::Contig;
use bio_types::annot::pos::Pos;
use bio_types::strand::ReqStrand;

let tma22_first = Pos::new("chrX".to_string(), 461829, ReqStrand::Forward);
let tma22 = Contig::with_first_length(&tma22_first, 462426 - 461829)?;
assert_eq!(tma22.to_string(), "chrX:461829-462426(+)");

let tma19_first = Pos::new("chrXI".to_string(), 335015, ReqStrand::Reverse);
let tma19 = Contig::with_first_length(&tma19_first, 335016 - 334412)?;
assert_eq!(tma19.to_string(), "chrXI:334412-335016(-)");

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

Convert into a stranded sequence location on the specified strand

impl<R> Contig<R, ReqStrand>

pub fn extend_upstream(&mut self, dist: usize)

Extend the annotation by dist in the upstream direction on the annotated strand.

Arguments

• dist specifies the offset for sliding the position. The left, 5'-most end of the contig will expand for forward-strand annotations and the right, 3'-most end will expand for reverse-strand annotations.

use bio_types::annot::contig::Contig;
use bio_types::strand::ReqStrand;
let mut tma22 = Contig::new("chrX".to_owned(), 461829, 462426 - 461829, ReqStrand::Forward);
tma22.extend_upstream(100);
assert_eq!(tma22.to_string(), "chrX:461729-462426(+)");
let mut tma19 = Contig::new("chrXI".to_owned(), 334412, 334916 - 334412, ReqStrand::Reverse);
tma19.extend_upstream(100);
assert_eq!(tma19.to_string(), "chrXI:334412-335016(-)");

pub fn extend_downstream(&mut self, dist: usize)

Extend the annotation by dist in the downstream direction on the annotated strand.

Arguments

• dist specifies the offset for sliding the position. The right, 3'-most end of the contig will expand for forward-strand annotations and the left, 5'-most end will expand for reverse-strand annotations.

use bio_types::annot::contig::Contig;
use bio_types::strand::ReqStrand;
let mut tma22 = Contig::new("chrX".to_owned(), 461829, 462426 - 461829, ReqStrand::Forward);
tma22.extend_downstream(100);
assert_eq!(tma22.to_string(), "chrX:461829-462526(+)");
let mut tma19 = Contig::new("chrXI".to_owned(), 334412, 334916 - 334412, ReqStrand::Reverse);
tma19.extend_downstream(100);
assert_eq!(tma19.to_string(), "chrXI:334312-334916(-)");

Trait Implementations

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

fn clone(&self) -> Contig<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 Contig<R, S>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

impl<R, S> FromStr for Contig<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 Contig<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 Contig<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<Contig<R, S>> for Contig<R, S>

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

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

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

This method tests for !=.

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

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