Struct fxread::record::Record

pub struct Record { /* private fields */ }

An instance of a Fastx Record. This is a two attribute object containing the sequence ID and the Sequence.

Implementations

impl Record

pub fn new() -> Self

Usage

Creates a new instance of a [Record]

let record = fxread::Record::new();
assert!(record.empty());

pub fn new_fasta(data: Vec<u8>, id: usize, seq: usize) -> Self

Usage

Creates a new instance of a [Record] from a preinitialized [Vec<u8>] with the id and seq endpoints calculated. These endpoints are inclusive of the ‘\n’ terminator and the data is expected to exclude the prefix ‘>’ marker.

let data = b">seq.0\nACGT\n".to_vec();
let id = 6;
let seq = 5;
let fasta = fxread::Record::new_fasta(data, id, seq);
assert_eq!(fasta.id(), b"seq.0");
assert_eq!(fasta.seq(), b"ACGT");

pub fn new_fastq( data: Vec<u8>, id: usize, seq: usize, plus: usize, qual: usize ) -> Self

Usage

Creates a new instance of a [Record] from a preinitialized [Vec<u8>] with the id, seq, plus, and qual endpoints calculated. These endpoints are inclusive of the ‘\n’ terminator and the data is expected to exclude the prefix ‘@’ marker.

let data = b"@seq.0\nACGT\n+\n1234\n".to_vec();
let id = 6;
let seq = 5;
let plus = 2;
let qual = 5;
let fasta = fxread::Record::new_fastq(data, id, seq, plus, qual);
assert_eq!(fasta.id(), b"seq.0");
assert_eq!(fasta.seq(), b"ACGT");
assert_eq!(fasta.plus().unwrap(), b"+");
assert_eq!(fasta.qual().unwrap(), b"1234");

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

Usage

Creates a new instance of a [Record] from its raw parts and calculates the endpoints. The id and seq are required and expected to be the raw data excluding the prefix ‘>’ marker.

let id = b"seq.0";
let seq = b"ACGT";
let record = fxread::Record::new_fasta_from_parts(id, seq).unwrap();
assert_eq!(record.id(), b"seq.0");
assert_eq!(record.seq(), b"ACGT");

pub fn new_fastq_from_parts(id: &[u8], seq: &[u8], qual: &[u8]) -> Result<Self>

Usage

Creates a new instance of a [Record] from its raw parts and calculates the endpoints. The id and seq and qual are required and expected to be the raw data excluding the prefix ‘>’ or ‘@’ markers. The plus is not required and is expected to be the raw data excluding the prefix ‘+’.

let id = b"seq.0";
let seq = b"ACGT";
let qual = b"1234";
let record = fxread::Record::new_fastq_from_parts(id, seq, qual).unwrap();
assert_eq!(record.id(), b"seq.0");
assert_eq!(record.seq(), b"ACGT");
assert_eq!(record.qual().unwrap(), b"1234");

pub fn is_fasta(&self) -> bool

Checks if [Record] is a fasta

pub fn is_fastq(&self) -> bool

Checks if [Record] is a fastq

pub fn valid_header(&self) -> bool

Checks if [Record] has a valid header

pub fn empty(&self) -> bool

Checks if [Record] is empty

pub fn id_range(&self) -> Range<usize>

Returns the Range of the ID

pub fn seq_range(&self) -> Range<usize>

Returns the Range of the sequence

pub fn plus_range(&self) -> Option<Range<usize>>

Returns the Range of the ‘+’ region of a fastq

pub fn qual_range(&self) -> Option<Range<usize>>

Returns the Range of the quality score if it exists

pub fn id(&self) -> &[u8]

Returns a reference of the sequence ID

pub fn seq(&self) -> &[u8]

Returns a reference of the sequence

pub fn seq_mut(&mut self) -> &mut [u8]

Returns a mutable reference of the sequence

pub fn plus(&self) -> Option<&[u8]>

Returns a reference of the ‘+’ region of a fastq

pub fn qual(&self) -> Option<&[u8]>

Returns a reference of the sequence

pub fn qual_mut(&mut self) -> Option<&mut [u8]>

Returns a mutable reference of the quality score if it exists

pub fn data(&self) -> &[u8]

Returns a reference to the raw data underlying the record

pub fn valid(&self) -> bool

Validates that the record is not partially constructed or composed of unexpected nucleotides

pub fn seq_upper(&self) -> Vec<u8>

Converts the sequence to uppercase

pub fn seq_rev_comp(&self) -> Vec<u8>

Reverse Complements the sequence

pub fn fix(&mut self)

Converts all non-ACGTN nucleotides to N

pub fn upper(&mut self)

Converts the sequence to uppercase in place

pub fn rev_comp(&mut self)

Reverse Complements the sequence in place Also reverses the quality scores if present

pub fn insert_seq(&mut self, seq: &[u8], pos: usize) -> Result<()>

Inserts nucleotides into the sequence at the specified index and the corresponding quality scores if present Returns an error if the index is greater than the sequence length

pub fn insert_seq_left(&mut self, seq: &[u8]) -> Result<()>

Convenience function to insert nucleotides at the beginning of a sequence

pub fn insert_seq_right(&mut self, seq: &[u8]) -> Result<()>

Convenience function to insert nucleotides at the end of a sequence

pub fn trim_left(&mut self, size: usize) -> Result<()>

Trims the nucleotides from the left of the sequence and the corresponding quality scores if present Returns an error if the size is greater than the sequence length

pub fn trim_right(&mut self, size: usize) -> Result<()>

Trims the nucleotides from the right of the sequence and the corresponding quality scores if present Returns an error if the size is greater than the sequence length

pub fn as_str_checked(&self) -> Result<&str, Utf8Error>

Underlying record as str

pub fn id_str_checked(&self) -> Result<&str, Utf8Error>

ID as str

pub fn seq_str_checked(&self) -> Result<&str, Utf8Error>

Sequence as str

pub fn qual_str_checked(&self) -> Option<Result<&str, Utf8Error>>

Quality as str

pub fn as_str(&self) -> &str

Underlying record as str unchecked (may panic if invalid utf8)

pub fn id_str(&self) -> &str

ID as str unchecked (may panic if invalid utf8)

pub fn seq_str(&self) -> &str

Sequence as str unchecked (may panic if invalid utf8)

pub fn qual_str(&self) -> Option<&str>

Quality as str unchecked (may panic if invalid utf8)

Trait Implementations

impl Debug for Record

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

Formats the value using the given formatter.

impl Default for Record

fn default() -> Self

Returns the “default value” for a type.

impl Into<String> for Record

fn into(self) -> String

Converts this type into the (usually inferred) input type.