pub struct SeqSlice<A: Codec> { /* private fields */ }
Expand description
A lightweight, read-only window into part of a sequence
Implementations§
source§impl<A: Codec> SeqSlice<A>
impl<A: Codec> SeqSlice<A>
sourcepub fn kmers<const K: usize>(&self) -> KmerIter<'_, A, K> ⓘ
pub fn kmers<const K: usize>(&self) -> KmerIter<'_, A, K> ⓘ
Iterate over sliding windows of size K
sourcepub fn windows(&self, width: usize) -> SeqChunks<'_, A> ⓘ
pub fn windows(&self, width: usize) -> SeqChunks<'_, A> ⓘ
Iterate over the sequence in overlapping windows of a specified width
This will panic if the length of the window is greater than the length of the sequence.
Example:
use bio_seq::prelude::*;
let seq: Seq<Dna> = "ACTGATCG".try_into().unwrap();
let windows: Vec<Seq<Dna>> = seq.windows(3).collect();
assert_eq!(windows, vec!["ACT", "CTG", "TGA", "GAT", "ATC", "TCG"]);
sourcepub fn chunks(&self, width: usize) -> SeqChunks<'_, A> ⓘ
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.
Example:
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!["ACT", "GAT"]);
Trait Implementations§
source§impl<A: Codec> AsRef<SeqSlice<A>> for Seq<A>
impl<A: Codec> AsRef<SeqSlice<A>> for Seq<A>
A Seq can be borrowed as a SeqSlice through generic constraints.
use bio_seq::prelude::*;
fn count_bases<S: AsRef<SeqSlice<Dna>>>(s: S) -> usize {
s.as_ref().len()
}
let seq: Seq<Dna> = dna!("CATCGATCGATC");
let count = count_bases(seq); // the AsRef implementation allows us to directly pass a Seq
assert_eq!(count, 12);
source§impl<A: Codec> Borrow<SeqSlice<A>> for Seq<A>
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 bio_seq::prelude::*;
use std::borrow::Borrow;
let seq: Seq<Dna> = dna!("CTACGTACGATCATCG");
let slice: &SeqSlice<Dna> = seq.borrow();
source§impl<'a, A: Codec> IntoIterator for &'a SeqSlice<A>
impl<'a, A: Codec> IntoIterator for &'a SeqSlice<A>
source§impl<A: Codec> PartialEq<&Seq<A>> for SeqSlice<A>
impl<A: Codec> PartialEq<&Seq<A>> for SeqSlice<A>
source§impl<A: Codec> PartialEq<&SeqSlice<A>> for Seq<A>
impl<A: Codec> PartialEq<&SeqSlice<A>> for Seq<A>
source§impl<A: Codec> PartialEq<&SeqSlice<A>> for SeqSlice<A>
impl<A: Codec> PartialEq<&SeqSlice<A>> for SeqSlice<A>
source§impl<A: Codec> PartialEq<Seq<A>> for &SeqSlice<A>
impl<A: Codec> PartialEq<Seq<A>> for &SeqSlice<A>
source§impl<A: Codec> PartialEq<Seq<A>> for SeqSlice<A>
impl<A: Codec> PartialEq<Seq<A>> for SeqSlice<A>
source§impl<A: Codec> PartialEq<SeqSlice<A>> for &SeqSlice<A>
impl<A: Codec> PartialEq<SeqSlice<A>> for &SeqSlice<A>
source§impl<A: Codec> PartialEq<SeqSlice<A>> for Seq<A>
impl<A: Codec> PartialEq<SeqSlice<A>> for Seq<A>
source§impl<A: Codec> PartialEq for SeqSlice<A>
impl<A: Codec> PartialEq for SeqSlice<A>
source§impl<A: PartialOrd + Codec> PartialOrd for SeqSlice<A>
impl<A: PartialOrd + Codec> PartialOrd for SeqSlice<A>
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for
self
and other
) and is used by the <=
operator. Read moresource§impl<A: Codec + Complement> ReverseComplement for SeqSlice<A>
impl<A: Codec + Complement> ReverseComplement for SeqSlice<A>
source§impl<A: Codec> ToOwned for SeqSlice<A>
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]);
impl<A: Eq + Codec> Eq for SeqSlice<A>
Auto Trait Implementations§
impl<A> Freeze for SeqSlice<A>
impl<A> RefUnwindSafe for SeqSlice<A>where
A: RefUnwindSafe,
impl<A> Send for SeqSlice<A>where
A: Send,
impl<A> !Sized for SeqSlice<A>
impl<A> Sync for SeqSlice<A>where
A: Sync,
impl<A> Unpin for SeqSlice<A>where
A: Unpin,
impl<A> UnwindSafe for SeqSlice<A>where
A: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
source§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
source§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
source§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
Borrows
self
and passes that borrow into the pipe function. Read moresource§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
Mutably borrows
self
and passes that borrow into the pipe function. Read moresource§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
source§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R
source§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
Borrows
self
, then passes self.as_ref()
into the pipe function.source§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
Mutably borrows
self
, then passes self.as_mut()
into the pipe
function.source§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
Borrows
self
, then passes self.deref()
into the pipe function.