noodles_sam/header/record/value/map/
reference_sequence.rs

1//! SAM header record reference sequence map value.
2
3mod builder;
4pub mod md5_checksum;
5pub mod molecule_topology;
6pub mod tag;
7
8use std::num::NonZeroUsize;
9
10pub use self::md5_checksum::Md5Checksum;
11pub(crate) use self::tag::Tag;
12
13use self::builder::Builder;
14use super::{Inner, Map, OtherFields};
15
16/// A SAM header record reference sequence map value.
17///
18/// The reference sequence describes a sequence a read possibly mapped to. The length is guaranteed
19/// to be set.
20///
21/// A list of reference sequences creates a reference sequence dictionary.
22#[derive(Clone, Debug, Eq, PartialEq)]
23pub struct ReferenceSequence {
24    pub(crate) length: NonZeroUsize,
25}
26
27impl Inner for ReferenceSequence {
28    type StandardTag = tag::Standard;
29    type Builder = Builder;
30}
31
32impl Map<ReferenceSequence> {
33    /// Creates a reference sequence with a length.
34    ///
35    /// # Examples
36    ///
37    /// ```
38    /// use std::num::NonZeroUsize;
39    /// use noodles_sam::header::record::value::{map::ReferenceSequence, Map};
40    /// let reference_sequence = Map::<ReferenceSequence>::new(NonZeroUsize::try_from(13)?);
41    /// # Ok::<_, std::num::TryFromIntError>(())
42    /// ```
43    pub fn new(length: NonZeroUsize) -> Self {
44        Self {
45            inner: ReferenceSequence { length },
46            other_fields: OtherFields::new(),
47        }
48    }
49
50    /// Returns the reference sequence length.
51    ///
52    /// # Examples
53    ///
54    /// ```
55    /// use std::num::NonZeroUsize;
56    /// use noodles_sam::header::record::value::{map::ReferenceSequence, Map};
57    /// let reference_sequence = Map::<ReferenceSequence>::new(NonZeroUsize::try_from(13)?);
58    /// assert_eq!(usize::from(reference_sequence.length()), 13);
59    /// # Ok::<_, std::num::TryFromIntError>(())
60    /// ```
61    pub fn length(&self) -> NonZeroUsize {
62        self.inner.length
63    }
64
65    /// Returns a mutable reference to the reference sequence length.
66    ///
67    /// # Examples
68    ///
69    /// ```
70    /// use std::num::NonZeroUsize;
71    ///
72    /// use noodles_sam::header::record::value::{map::ReferenceSequence, Map};
73    ///
74    /// let length = NonZeroUsize::try_from(13)?;
75    /// let mut reference_sequence = Map::<ReferenceSequence>::new(length);
76    /// assert_eq!(reference_sequence.length(), length);
77    ///
78    /// let length = NonZeroUsize::try_from(8)?;
79    /// *reference_sequence.length_mut() = length;
80    /// assert_eq!(reference_sequence.length(), length);
81    /// # Ok::<_, std::num::TryFromIntError>(())
82    /// ```
83    pub fn length_mut(&mut self) -> &mut NonZeroUsize {
84        &mut self.inner.length
85    }
86}