noodles_fasta/
record.rs

1//! FASTA record and definition.
2
3pub mod definition;
4pub mod sequence;
5
6use bstr::BStr;
7
8pub use self::{definition::Definition, sequence::Sequence};
9
10/// A FASTA record.
11#[derive(Clone, Debug, Eq, PartialEq)]
12pub struct Record {
13    definition: Definition,
14    sequence: Sequence,
15}
16
17impl Record {
18    /// Creates a FASTA record from a definition and sequence.
19    ///
20    /// # Examples
21    ///
22    /// ```
23    /// use noodles_fasta::{self as fasta, record::{Definition, Sequence}};
24    /// let definition = Definition::new("sq0", None);
25    /// let sequence = Sequence::from(b"ACGT".to_vec());
26    /// let record = fasta::Record::new(definition, sequence);
27    /// ```
28    pub fn new(definition: Definition, sequence: Sequence) -> Self {
29        Self {
30            definition,
31            sequence,
32        }
33    }
34
35    /// Returns the record definition.
36    ///
37    /// # Examples
38    ///
39    /// ```
40    /// use noodles_fasta::{self as fasta, record::{Definition, Sequence}};
41    ///
42    /// let definition = Definition::new("sq0", None);
43    /// let sequence = Sequence::from(b"ACGT".to_vec());
44    /// let record = fasta::Record::new(definition.clone(), sequence);
45    ///
46    /// assert_eq!(record.definition(), &definition);
47    /// ```
48    pub fn definition(&self) -> &Definition {
49        &self.definition
50    }
51
52    /// Returns the record name.
53    ///
54    /// # Examples
55    ///
56    /// ```
57    /// use noodles_fasta::{self as fasta, record::{Definition, Sequence}};
58    ///
59    /// let definition = Definition::new("sq0", None);
60    /// let sequence = Sequence::from(b"ACGT".to_vec());
61    /// let record = fasta::Record::new(definition, sequence);
62    ///
63    /// assert_eq!(record.name(), b"sq0");
64    /// ```
65    pub fn name(&self) -> &[u8] {
66        self.definition.name()
67    }
68
69    /// Returns the description.
70    ///
71    /// # Examples
72    ///
73    /// ```
74    /// use bstr::{BStr, BString};
75    /// use noodles_fasta::{self as fasta, record::{Definition, Sequence}};
76    ///
77    /// let definition = Definition::new("sq0", Some(BString::from("LN:4")));
78    /// let sequence = Sequence::from(b"ACGT".to_vec());
79    /// let record = fasta::Record::new(definition, sequence);
80    ///
81    /// assert_eq!(record.description(), Some(BStr::new("LN:4")));
82    /// ```
83    pub fn description(&self) -> Option<&BStr> {
84        self.definition.description()
85    }
86
87    /// Returns the sequence.
88    ///
89    /// # Examples
90    ///
91    /// ```
92    /// use noodles_fasta::{self as fasta, record::{Definition, Sequence}};
93    ///
94    /// let definition = Definition::new("sq0", None);
95    /// let sequence = Sequence::from(b"ACGT".to_vec());
96    /// let record = fasta::Record::new(definition, sequence.clone());
97    ///
98    /// assert_eq!(record.sequence(), &sequence);
99    /// ```
100    pub fn sequence(&self) -> &Sequence {
101        &self.sequence
102    }
103}