noodles_fasta/
record.rs

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