Struct SeqSlice 

pub struct SeqSlice<A: Codec> { /* private fields */ }

An unsized, read-only window into part of a sequence

Implementations

impl SeqSlice<Iupac>

pub fn contains(&self, rhs: &SeqSlice<Iupac>) -> bool

impl<'a, A: Codec> SeqSlice<A>

pub fn chain( self: &'a SeqSlice<A>, second: &'a SeqSlice<A>, ) -> Chain<SeqIter<'a, A>, SeqIter<'a, A>>

pub fn iter(&'a self) -> SeqIter<'a, A>

pub fn kmers<const K: usize>(&self) -> KmerIter<'_, A, K>

Iterate over sliding windows of length K

pub fn rev_iter(&self) -> RevIter<'_, A>

Iterate over the sequence in reverse order

pub fn windows(&self, width: usize) -> SeqChunks<'_, A>

Iterate over the sequence in overlapping windows of a specified width

use bio_seq::prelude::*;

let seq: Seq<Dna> = "ACTGATCG".try_into().unwrap();
let windows: Vec<String> = seq.windows(3).map(String::from).collect();
assert_eq!(windows, vec!["ACT", "CTG", "TGA", "GAT", "ATC", "TCG"]);

pub fn chunks(&self, width: usize) -> SeqChunks<'_, A>

Iterate over the sequence in non-overlapping chunks of a specified width

The last incomplete chunk will be excluded if the sequence length is not divisible by the specified width.

use bio_seq::prelude::*;

let seq: Seq<Dna> = "ACTGATCG".try_into().unwrap();
let chunks: Vec<Seq<Dna>> = seq.chunks(3).collect();
assert_eq!(chunks, vec![dna!("ACT"), dna!("GAT")]);

impl<A: Codec> SeqSlice<A>

pub fn nth(&self, i: usize) -> A

unsafely index into the ith position of a sequence

pub fn len(&self) -> usize

pub fn get(&self, i: usize) -> Option<A>

Get the ith element of a Seq. Returns None if index out of range.

pub fn is_empty(&self) -> bool

Trait Implementations

impl<A: Codec, const K: usize> AsRef<SeqSlice<A>> for Kmer<A, K, usize>

fn as_ref(&self) -> &SeqSlice<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: Codec> AsRef<SeqSlice<A>> for Seq<A>

A Seq can be borrowed as a SeqSlice through generic constraints.

fn count_bases<S: AsRef<SeqSlice<Dna>>>(s: S) -> usize {
   s.as_ref().len()
}

let seq: Seq<Dna> = dna!("CATCGATCGATC").into();
let count = count_bases(seq); // the AsRef implementation allows us to directly pass a Seq
assert_eq!(count, 12);

fn as_ref(&self) -> &SeqSlice<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: Codec, const N: usize, const W: usize> AsRef<SeqSlice<A>> for SeqArray<A, N, W>

fn as_ref(&self) -> &SeqSlice<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: Codec> AsRef<SeqSlice<A>> for SeqSlice<A>

fn as_ref(&self) -> &SeqSlice<A>

Converts this type into a shared reference of the (usually inferred) input type.

impl<A: Codec> BitAnd for &SeqSlice<A>

type Output = Seq<A>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<A: Codec> BitOr for &SeqSlice<A>

type Output = Seq<A>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<A: Codec> Borrow<SeqSlice<A>> for &Seq<A>

fn borrow(&self) -> &SeqSlice<A>

Immutably borrows from an owned value.

impl<A: Codec> Borrow<SeqSlice<A>> for Seq<A>

Borrow a Seq<A> as a SeqSlice<A>.

The Borrow trait to is used to obtain a reference to a SeqSlice from a Seq, allowing it to be used wherever a SeqSlice is expected.

use std::collections::HashMap;
use bio_seq::prelude::*;

let reference = dna!("ACGTTCGCATGCTACGACGATC");

let mut table: HashMap<Seq<Dna>, usize> = HashMap::new();

// Associate some kind of count with sequences as keys:
table.insert(dna!("ACGTT").into(), 1);
table.insert(dna!("ACACCCCC").into(), 0);

// The query is a short window in the reference `Seq`
let query: &SeqSlice<Dna> = &reference[..5];

if let Some(value) = table.get(query) {
       // `SeqSlice` implements `Display`
       println!("{query}: {value}");
}

fn borrow(&self) -> &SeqSlice<A>

Immutably borrows from an owned value.

impl<A: Codec + ComplementMut> Complement for SeqSlice<A>

fn to_comp(&self) -> <Self as ToOwned>::Owned

impl<A: Codec + ComplementMut> ComplementMut for SeqSlice<A>

fn comp(&mut self)

impl<A: Debug + Codec> Debug for SeqSlice<A>

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

Formats the value using the given formatter.

impl<A: Codec> Display for SeqSlice<A>

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

Formats the value using the given formatter.

impl<A, B: Codec> From<&SeqSlice<A>> for Seq<B>

where A: Into<B> + Codec,

fn from(slice: &SeqSlice<A>) -> Self

Converts to this type from the input type.

impl<A: Codec> From<&SeqSlice<A>> for String

fn from(seq: &SeqSlice<A>) -> Self

Converts to this type from the input type.

impl<A: Codec> From<&SeqSlice<A>> for u8

fn from(slice: &SeqSlice<A>) -> u8

Converts to this type from the input type.

impl<'a, A: Codec> FromIterator<&'a SeqSlice<A>> for Vec<Seq<A>>

fn from_iter<T: IntoIterator<Item = &'a SeqSlice<A>>>(iter: T) -> Self

Creates a value from an iterator.

impl<A: Codec> Hash for SeqSlice<A>

Warning! hashes are not currently stable between platforms/version

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

Feeds this value into the given Hasher.

impl<A: Codec> Index<Range<usize>> for SeqSlice<A>

type Output = SeqSlice<A>

The returned type after indexing.

fn index(&self, range: Range<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: Codec> Index<RangeFrom<usize>> for SeqSlice<A>

type Output = SeqSlice<A>

The returned type after indexing.

fn index(&self, range: RangeFrom<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: Codec> Index<RangeFull> for SeqSlice<A>

type Output = SeqSlice<A>

The returned type after indexing.

fn index(&self, _range: RangeFull) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: Codec> Index<RangeInclusive<usize>> for SeqSlice<A>

type Output = SeqSlice<A>

The returned type after indexing.

fn index(&self, range: RangeInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: Codec> Index<RangeTo<usize>> for SeqSlice<A>

type Output = SeqSlice<A>

The returned type after indexing.

fn index(&self, range: RangeTo<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: Codec> Index<RangeToInclusive<usize>> for SeqSlice<A>

type Output = SeqSlice<A>

The returned type after indexing.

fn index(&self, range: RangeToInclusive<usize>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<A: Codec> Index<usize> for SeqSlice<A>

type Output = SeqSlice<A>

The returned type after indexing.

fn index(&self, i: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, A: Codec> IntoIterator for &'a SeqSlice<A>

type Item = A

The type of the elements being iterated over.

type IntoIter = SeqIter<'a, A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: Codec, const K: usize, S: KmerStorage> PartialEq<&SeqSlice<A>> for Kmer<A, K, S>

fn eq(&self, seq: &&SeqSlice<A>) -> 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<A: Codec> PartialEq<&SeqSlice<A>> for Seq<A>

fn eq(&self, other: &&SeqSlice<A>) -> 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<A: Codec> PartialEq<&str> for SeqSlice<A>

fn eq(&self, other: &&str) -> 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<A: Codec> PartialEq<Seq<A>> for &SeqSlice<A>

fn eq(&self, other: &Seq<A>) -> 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<A: Codec> PartialEq<Seq<A>> for SeqSlice<A>

fn eq(&self, other: &Seq<A>) -> 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<A: Codec> PartialEq<SeqSlice<A>> for &SeqSlice<A>

fn eq(&self, other: &SeqSlice<A>) -> 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<A: Codec, const K: usize, S: KmerStorage> PartialEq<SeqSlice<A>> for Kmer<A, K, S>

fn eq(&self, seq: &SeqSlice<A>) -> 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<A: Codec> PartialEq<SeqSlice<A>> for Seq<A>

fn eq(&self, other: &SeqSlice<A>) -> 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<A: Codec> PartialEq for SeqSlice<A>

fn eq(&self, other: &SeqSlice<A>) -> 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<A: Codec> Reverse for SeqSlice<A>

fn to_rev(&self) -> <Self as ToOwned>::Owned

impl<A: Codec + ComplementMut> ReverseComplement for SeqSlice<A>

where SeqSlice<A>: ComplementMut + ReverseMut,

fn to_revcomp(&self) -> <Self as ToOwned>::Owned

impl<A: Codec + ComplementMut> ReverseComplementMut for SeqSlice<A>

where SeqSlice<A>: ComplementMut + ReverseMut,

fn revcomp(&mut self)

Reverse complement a sequence in place

impl<A: Codec> ReverseMut for SeqSlice<A>

fn rev(&mut self)

Reverse sequence in place

impl<A: Codec> ToOwned for SeqSlice<A>

Clone a borrowed slice of a sequence into an owned version.

use bio_seq::prelude::*;

let seq = dna!("CATCGATCGATCG");
let slice = &seq[2..7]; // TCGAT
let owned = slice.to_owned();

assert_eq!(&owned, &seq[2..7]);

type Owned = Seq<A>

The resulting type after obtaining ownership.

fn to_owned(&self) -> Self::Owned

Creates owned data from borrowed data, usually by cloning.

fn clone_into(&self, target: &mut Self::Owned)

Uses borrowed data to replace owned data, usually by cloning.

impl<A: Codec, const K: usize, S: KmerStorage> TryFrom<&SeqSlice<A>> for Kmer<A, K, S>

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(seq: &SeqSlice<A>) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: Codec> TryFrom<&SeqSlice<A>> for usize

type Error = ParseBioError

The type returned in the event of a conversion error.

fn try_from(slice: &SeqSlice<A>) -> Result<usize, Self::Error>

Performs the conversion.

impl<A: Eq + Codec> Eq for SeqSlice<A>