Struct noodles_fasta::record::sequence::Sequence

pub struct Sequence(/* private fields */);

A FASTA record sequence.

Implementations

impl Sequence

pub fn len(&self) -> usize

Returns the length of the sequence.

Examples

use noodles_fasta::record::Sequence;
let sequence = Sequence::default();
assert_eq!(sequence.len(), 0);

pub fn is_empty(&self) -> bool

Returns whether the sequence is empty.

Examples

use noodles_fasta::record::Sequence;
let sequence = Sequence::default();
assert!(sequence.is_empty());

pub fn get<I>(&self, index: I) -> Option<&I::Output>

where I: SequenceIndex<u8>,

Returns a reference to a base at or slice of bases between the given index.

Examples

use noodles_core::Position;
use noodles_fasta::record::Sequence;

let sequence = Sequence::from(b"ACGT".to_vec());

let start = Position::try_from(2)?;
assert_eq!(sequence.get(start), Some(&b'C'));

assert_eq!(sequence.get(start..), Some(&b"CGT"[..]));

let end = Position::try_from(3)?;
assert_eq!(sequence.get(start..=end), Some(&b"CG"[..]));

pub fn slice<I>(&self, interval: I) -> Option<Self>

where I: Into<Interval>,

Returns a subset of the sequence within the given range.

Unlike Self::get, this returns the slice as a Sequence.

Examples

use noodles_core::Position;
use noodles_fasta::record::Sequence;

let sequence = Sequence::from(b"ACGT".to_vec());

let start = Position::try_from(2)?;
let end = Position::try_from(3)?;
let actual = sequence.slice(start..=end);

let expected = Sequence::from(b"CG".to_vec());

assert_eq!(actual, Some(expected));

pub fn complement(&self) -> Complement<'_>

Returns an iterator that complements the sequence.

Examples

Complement a sequence

use noodles_fasta::record::Sequence;
let sequence = Sequence::from(b"ACGT".to_vec());
let actual: Sequence = sequence.complement().collect::<Result<_, _>>()?;
let expected = Sequence::from(b"TGCA".to_vec());
assert_eq!(actual, expected);

Reverse complement a sequence

use noodles_fasta::record::Sequence;
let sequence = Sequence::from(b"ACGT".to_vec());
let actual: Sequence = sequence.complement().rev().collect::<Result<_, _>>()?;
let expected = sequence.clone();
assert_eq!(actual, expected);

Trait Implementations

impl AsRef<[u8]> for Sequence

fn as_ref(&self) -> &[u8]

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

impl Clone for Sequence

fn clone(&self) -> Sequence

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Sequence

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

Formats the value using the given formatter.

impl Default for Sequence

fn default() -> Sequence

Returns the “default value” for a type.

impl From<Bytes> for Sequence

fn from(data: Bytes) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for Sequence

fn from(data: Vec<u8>) -> Self

Converts to this type from the input type.

impl FromIterator<u8> for Sequence

fn from_iter<T>(iter: T) -> Self

where T: IntoIterator<Item = u8>,

Creates a value from an iterator.

impl<I> Index<I> for Sequence

where I: SequenceIndex<u8>,

type Output = <I as SequenceIndex<u8>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl PartialEq for Sequence

fn eq(&self, other: &Sequence) -> bool

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

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

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

impl Eq for Sequence

impl StructuralPartialEq for Sequence