Struct PackedSequence

Source

pub struct PackedSequence { /* private fields */ }

Implementations§

Source §

impl PackedSequence

Source

pub fn new(seq: &[u8]) -> Result<Self, NucleotideError>

Creates a new PackedSequence from a byte slice containing nucleotides.

The input sequence must contain only valid nucleotides (A, C, G, T, case insensitive).

§Examples

use bitnuc::PackedSequence;

let seq = PackedSequence::new(b"ACGT")?;
assert_eq!(seq.len(), 4);

§Errors

Returns NucleotideError::InvalidBase if the input contains non-ACGT characters:

use bitnuc::PackedSequence;

let result = PackedSequence::new(b"ACGN");
assert!(result.is_err());

Source

pub fn len(&self) -> usize

Returns the number of bases in the sequence.

§Examples

use bitnuc::PackedSequence;

let seq = PackedSequence::new(b"ACGT")?;
assert_eq!(seq.len(), 4);

Source

pub fn is_empty(&self) -> bool

Returns true if the sequence contains no bases.

§Examples

use bitnuc::PackedSequence;

let seq = PackedSequence::new(b"")?;
assert!(seq.is_empty());

Source

pub fn get(&self, index: usize) -> Result<u8, NucleotideError>

Returns the nucleotide at the given position.

§Examples

use bitnuc::PackedSequence;

let seq = PackedSequence::new(b"ACGT")?;
assert_eq!(seq.get(0)?, b'A');
assert_eq!(seq.get(3)?, b'T');

§Errors

Returns NucleotideError::IndexOutOfBounds if the index is past the end of the sequence:

use bitnuc::PackedSequence;

let result = seq.get(4);
assert!(result.is_err());

Source

pub fn slice(&self, range: Range<usize>) -> Result<Vec<u8>, NucleotideError>

Returns a subsequence within the given range.

The range is exclusive of the end bound, matching Rust’s standard range behavior.

§Examples

Basic slicing:

use bitnuc::PackedSequence;

let seq = PackedSequence::new(b"ACGTACGT")?;

// Get middle section
assert_eq!(seq.slice(1..5)?, b"CGTA");

// Get prefix
assert_eq!(seq.slice(0..3)?, b"ACG");

// Get suffix
assert_eq!(seq.slice(5..8)?, b"CGT");

Empty slices are allowed:

use bitnuc::PackedSequence;

let seq = PackedSequence::new(b"ACGT")?;
assert_eq!(seq.slice(2..2)?, b"");

§Errors

Returns NucleotideError::InvalidRange in these cases:

Start index greater than end index:

use bitnuc::PackedSequence;

let result = seq.slice(3..2);
assert!(result.is_err());

Range extends past end of sequence:

use bitnuc::PackedSequence;

let result = seq.slice(2..5);
assert!(result.is_err());

Source

pub fn to_vec(&self) -> Result<Vec<u8>, NucleotideError>

Converts the entire packed sequence back to a vector of bytes.

This is equivalent to slice(0..len()) but may be more efficient for full sequence conversion.

§Examples

Basic conversion:

use bitnuc::PackedSequence;

let seq = PackedSequence::new(b"ACGT")?;
assert_eq!(seq.to_vec()?, b"ACGT");

Working with longer sequences:

use bitnuc::PackedSequence;

let original = b"ACGTACGTACGTACGT".to_vec();
let seq = PackedSequence::new(&original)?;
assert_eq!(seq.to_vec()?, original);

Empty sequences:

use bitnuc::PackedSequence;

let seq = PackedSequence::new(b"")?;
assert_eq!(seq.to_vec()?, b"");

§Performance

This method allocates a new vector and performs a full copy of the sequence. For frequent access to subsequences, consider using slice() or individual base access via get() instead.