Struct bio_types::annot::pos::Pos

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

Position 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 Pos is chr:pos(+/-). A stranded position must have a (+) or a (-), while an unstranded position does not.

use bio_types::annot::pos::Pos;
use bio_types::strand::ReqStrand;
let start = Pos::new("chrIV".to_owned(), 683946, ReqStrand::Reverse);
let start_str = start.to_string();
assert_eq!(start_str, "chrIV:683946(-)");
let start_str_pos = start_str.parse()?;
assert_eq!(start, start_str_pos);

Methods

impl<R, S> Pos<R, S>

pub fn new(refid: R, pos: isize, strand: S) -> Self

Construct a new sequence position

use std::rc::Rc;
use bio_types::annot::pos::Pos;
use bio_types::strand::ReqStrand;
let chr = Rc::new("chrIV".to_owned());
let start = Pos::new(chr, 683946, ReqStrand::Reverse);

pub fn pos(&self) -> isize

Position on the reference sequence (0-based).

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

Convert into a stranded sequence position on the specified strand

Trait Implementations

impl<R, S> Loc for Pos<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, S> Same for Pos<R, S> where
    R: Eq,
    S: Same, 

fn same(&self, p: &Self) -> bool

Indicate when two positions are the "same" -- when positions have unknown/unspecified strands they can be the "same" but not equal.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

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

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

This method tests for !=.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<R, S> FromStr for Pos<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, T> AddAssign<T> for Pos<R, ReqStrand> where
    isize: AddAssign<T>,
    isize: SubAssign<T>, 

fn add_assign(&mut self, dist: T)

Slide the reference position by an offset on the strand of the annotation.

Arguments

• dist specifies the offset for sliding the position. A positive dist will numerically increase the position for forward-strand features and decrease it for reverse-strand features.

use bio_types::annot::pos::Pos;
use bio_types::strand::ReqStrand;
let mut start = Pos::new("chrIV".to_owned(), 683946, ReqStrand::Reverse);
assert_eq!(start.to_string(), "chrIV:683946(-)");
start += 100;
assert_eq!(start.to_string(), "chrIV:683846(-)");

impl<R, T> SubAssign<T> for Pos<R, ReqStrand> where
    isize: AddAssign<T>,
    isize: SubAssign<T>, 

fn sub_assign(&mut self, dist: T)

Slide the reference position by an offset on the strand of the annotation.

Arguments

• dist specifies the offset for sliding the position. A positive dist will numerically decrease the position for forward-strand features and increase it for reverse-strand features.

use bio_types::annot::pos::Pos;
use bio_types::strand::ReqStrand;
let mut start = Pos::new("chrIV".to_owned(), 683946, ReqStrand::Reverse);
assert_eq!(start.to_string(), "chrIV:683946(-)");
start -= 100;
assert_eq!(start.to_string(), "chrIV:684046(-)");

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

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

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