Struct Coordinate 

pub struct Coordinate<S>
where
    S: System,
{ /* private fields */ }

A coordinate.

Implementations

impl Coordinate<Base>

pub fn nudge_forward(self) -> Option<Coordinate<Interbase>>

Consumes self and attempts to convert the coordinate to the next interbase coordinate.

This is only useful when converting a coordinate to the other coordinate system, which is not a common operation. If, instead, you wish to move the coordinate forward within the same coordinate system, you’re almost certainly looking for move_forward().

pub fn nudge_backward(self) -> Option<Coordinate<Interbase>>

Consumes self and attempts to convert the coordinate to the previous interbase coordinate.

This is only useful when converting a coordinate to the other coordinate system, which is not a common operation. If, instead, you wish to move the coordinate backward within the same coordinate system, you’re almost certainly looking for move_backward().

impl Coordinate<Interbase>

pub fn nudge_forward(self) -> Option<Coordinate<Base>>

Consumes self and attempts converts the coordinate to the next in-base coordinate.

This is only useful when converting a coordinate to the other coordinate system, which is not a common operation. If, instead, you wish to move the coordinate forward within the same coordinate system, you’re almost certainly looking for move_forward().

pub fn nudge_backward(self) -> Option<Coordinate<Base>>

Consumes self and converts the coordinate to the previous in-base coordinate.

This is only useful when converting a coordinate to the other coordinate system, which is not a common operation. If, instead, you wish to move the coordinate backward within the same coordinate system, you’re almost certainly looking for move_backward().

impl<S> Coordinate<S>

where S: System, Position<S>: Position<S>,

pub fn new( contig: impl Into<Contig>, strand: impl Into<Strand>, position: impl Into<Position<S>>, ) -> Coordinate<S>

Creates a new coordinate;

Examples

use omics_coordinate::Contig;
use omics_coordinate::Coordinate;
use omics_coordinate::Strand;
use omics_coordinate::position::interbase::Position;
use omics_coordinate::system::Interbase;

let contig = Contig::new("chr1");
let position = Position::new(0);
let strand = Strand::Positive;

let coordinate = Coordinate::new(contig, strand, position);

pub fn try_new( contig: impl Into<Contig>, strand: impl TryInto<Strand, Error = Error>, position: u64, ) -> Result<Coordinate<S>, Error>

where Coordinate<S>: Coordinate<S>,

Attempts to create a new coordinate.

pub fn contig(&self) -> &Contig

Gets the contig for this coordinate by reference.

Examples

use omics_coordinate::Coordinate;
use omics_coordinate::system::Interbase;

let coordinate = "seq0:+:1".parse::<Coordinate<Interbase>>()?;
assert_eq!(coordinate.contig().as_str(), "seq0");

pub fn into_contig(self) -> Contig

Consumes self and returns the inner contig from this coordinate.

Examples

use omics_coordinate::Coordinate;
use omics_coordinate::system::Interbase;

let coordinate = "seq0:+:1".parse::<Coordinate<Interbase>>()?;
assert_eq!(coordinate.into_contig().into_inner(), String::from("seq0"));

pub fn strand(&self) -> Strand

Gets the strand for this coordinate by reference.

Examples

use omics_coordinate::Coordinate;
use omics_coordinate::Strand;
use omics_coordinate::system::Interbase;

let coordinate = "seq0:+:1".parse::<Coordinate<Interbase>>()?;
assert_eq!(coordinate.strand(), Strand::Positive);

pub fn position(&self) -> &Position<S>

Gets the position for this coordinate by reference.

Examples

use omics_coordinate::Coordinate;
use omics_coordinate::Position;
use omics_coordinate::system::Interbase;

let coordinate = "seq0:+:1".parse::<Coordinate<Interbase>>()?;
assert_eq!(coordinate.position().get(), 1);

pub fn into_position(self) -> Position<S>

Consumes self and returns the inner position from this coordinate.

Examples

use omics_coordinate::Coordinate;
use omics_coordinate::Strand;
use omics_coordinate::system::Interbase;

let coordinate = "seq0:+:1".parse::<Coordinate<Interbase>>()?;
assert_eq!(coordinate.into_position().get(), 1);

pub fn into_parts(self) -> (Contig, Strand, Position<S>)

Consumes self to return the parts that comprise this coordinate.

Examples

use omics_coordinate::Contig;
use omics_coordinate::Coordinate;
use omics_coordinate::Strand;
use omics_coordinate::system::Interbase;

let coordinate = "seq0:+:1".parse::<Coordinate<Interbase>>()?;

let (contig, strand, position) = coordinate.into_parts();
assert_eq!(contig.into_inner(), String::from("seq0"));
assert_eq!(strand, Strand::Positive);
assert_eq!(position.get(), 1);

pub fn move_forward(self, magnitude: u64) -> Option<Coordinate<S>>

Consumes self and attempts to move the position forward by magnitude.

This method is dependent on the strand of the coordinate:

• a coordinate on the Strand::Positive moves positively, and
• a coordinate on the Strand::Negative move negatively.

Examples

use omics_coordinate::Contig;
use omics_coordinate::Coordinate;
use omics_coordinate::Position;
use omics_coordinate::Strand;
use omics_coordinate::position::Number;
use omics_coordinate::system::Base;
use omics_coordinate::system::Interbase;

// Interbase.

let start = "seq0:+:0".parse::<Coordinate<Interbase>>()?;
let coordinate = start.clone().move_forward(10).expect("coordinate to move");
assert_eq!(coordinate.contig().as_str(), "seq0");
assert_eq!(coordinate.strand(), Strand::Positive);
assert_eq!(coordinate.position().get(), 10);

let coordinate = start.move_forward(Number::MAX).expect("coordinate to move");
assert_eq!(coordinate.contig().as_str(), "seq0");
assert_eq!(coordinate.strand(), Strand::Positive);
assert_eq!(coordinate.position().get(), Number::MAX);

let coordinate = coordinate.move_forward(1);
assert!(coordinate.is_none());

// Base.

let start = "seq0:+:1".parse::<Coordinate<Base>>()?;
let coordinate = start.clone().move_forward(10).expect("coordinate to move");
assert_eq!(coordinate.contig().as_str(), "seq0");
assert_eq!(coordinate.strand(), Strand::Positive);
assert_eq!(coordinate.position().get(), 11);

let coordinate = start
    .move_forward(Number::MAX - 1)
    .expect("coordinate to move");
assert_eq!(coordinate.contig().as_str(), "seq0");
assert_eq!(coordinate.strand(), Strand::Positive);
assert_eq!(coordinate.position().get(), Number::MAX);

let coordinate = coordinate.move_forward(1);
assert!(coordinate.is_none());

pub fn move_backward(self, magnitude: u64) -> Option<Coordinate<S>>

Consumes self and attempts to move the position backwards by magnitude.

This method is dependent on the strand of the coordinate:

• a coordinate on the Strand::Positive moves negatively, and
• a coordinate on the Strand::Negative move positively.

Examples

use omics_coordinate::Contig;
use omics_coordinate::Coordinate;
use omics_coordinate::Position;
use omics_coordinate::Strand;
use omics_coordinate::position::Number;
use omics_coordinate::system::Base;
use omics_coordinate::system::Interbase;

let value = format!("seq0:+:{}", Number::MAX);

// Interbase.

let start = value.clone().parse::<Coordinate<Interbase>>()?;
let coordinate = start.clone().move_backward(10).expect("coordinate to move");
assert_eq!(coordinate.contig().as_str(), "seq0");
assert_eq!(coordinate.strand(), Strand::Positive);
assert_eq!(coordinate.position().get(), Number::MAX - 10);

let coordinate = start
    .move_backward(Number::MAX)
    .expect("coordinate to move");
assert_eq!(coordinate.contig().as_str(), "seq0");
assert_eq!(coordinate.strand(), Strand::Positive);
assert_eq!(coordinate.position().get(), 0);

let coordinate = coordinate.move_backward(1);
assert!(coordinate.is_none());

// Base.

let start = value.parse::<Coordinate<Base>>()?;
let coordinate = start.clone().move_backward(10).expect("coordinate to move");
assert_eq!(coordinate.contig().as_str(), "seq0");
assert_eq!(coordinate.strand(), Strand::Positive);
assert_eq!(coordinate.position().get(), Number::MAX - 10);

let coordinate = start
    .move_backward(Number::MAX - 1)
    .expect("coordinate to move");
assert_eq!(coordinate.contig().as_str(), "seq0");
assert_eq!(coordinate.strand(), Strand::Positive);
assert_eq!(coordinate.position().get(), 1);

let coordinate = coordinate.move_backward(1);
assert!(coordinate.is_none());

pub fn swap_strand(self) -> Coordinate<S>

Swaps the strand of the coordinate.

Examples

use omics_coordinate::Coordinate;
use omics_coordinate::Strand;
use omics_coordinate::system::Base;
use omics_coordinate::system::Interbase;

//===========//
// Interbase //
//===========//

let coordinate = Coordinate::<Interbase>::try_new("seq0", "+", 10)?;
let swapped = coordinate.swap_strand();
assert_eq!(swapped.contig().as_str(), "seq0");
assert_eq!(swapped.strand(), Strand::Negative);
assert_eq!(swapped.position().get(), 10);

//======//
// Base //
//======//

let coordinate = Coordinate::<Base>::try_new("seq0", "-", 10)?;
let swapped = coordinate.swap_strand();
assert_eq!(swapped.contig().as_str(), "seq0");
assert_eq!(swapped.strand(), Strand::Positive);
assert_eq!(swapped.position().get(), 10);

Trait Implementations

impl<S> Clone for Coordinate<S>

where S: Clone + System,

fn clone(&self) -> Coordinate<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Coordinate<Base> for Coordinate<Base>

fn try_new( contig: impl Into<Contig>, strand: impl TryInto<Strand, Error = Error>, position: u64, ) -> Result<Coordinate<Base>, Error>

Attempts to create a new coordinate.

impl Coordinate<Interbase> for Coordinate<Interbase>

fn try_new( contig: impl Into<Contig>, strand: impl TryInto<Strand, Error = Error>, position: u64, ) -> Result<Coordinate<Interbase>, Error>

Attempts to create a new coordinate.

impl<S> Debug for Coordinate<S>

where S: Debug + System,

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

Formats the value using the given formatter.

impl<S> Display for Coordinate<S>

where S: System,

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

Formats the value using the given formatter.

impl<S> FromStr for Coordinate<S>

where S: System, Position<S>: Position<S>,

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Coordinate<S>, Error>

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

impl<S> Ord for Coordinate<S>

where S: Ord + System,

fn cmp(&self, other: &Coordinate<S>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<S> PartialEq for Coordinate<S>

where S: PartialEq + System,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S> PartialOrd for Coordinate<S>

where S: PartialOrd + System,

fn partial_cmp(&self, other: &Coordinate<S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<S> Eq for Coordinate<S>

where S: Eq + System,

impl<S> StructuralPartialEq for Coordinate<S>

where S: System,