noodles_vcf/
record.rs

1//! VCF record.
2
3mod alternate_bases;
4pub(crate) mod fields;
5mod filters;
6mod ids;
7mod info;
8pub mod samples;
9
10use std::{fmt, io};
11
12use noodles_core::Position;
13
14use self::fields::Fields;
15pub use self::{
16    alternate_bases::AlternateBases, filters::Filters, ids::Ids, info::Info, samples::Samples,
17};
18use super::Header;
19
20/// A VCF record.
21#[derive(Clone, Default, Eq, PartialEq)]
22pub struct Record(Fields);
23
24impl Record {
25    #[cfg(test)]
26    pub(crate) fn fields(&self) -> &Fields {
27        &self.0
28    }
29
30    pub(crate) fn fields_mut(&mut self) -> &mut Fields {
31        &mut self.0
32    }
33
34    /// Returns the reference sequence name.
35    pub fn reference_sequence_name(&self) -> &str {
36        self.0.reference_sequence_name()
37    }
38
39    /// Returns the variant start position.
40    pub fn variant_start(&self) -> Option<io::Result<Position>> {
41        self.0.variant_start()
42    }
43
44    /// Returns the IDs.
45    pub fn ids(&self) -> Ids<'_> {
46        self.0.ids()
47    }
48
49    /// Returns the reference bases.
50    pub fn reference_bases(&self) -> &str {
51        self.0.reference_bases()
52    }
53
54    /// Returns the alternate bases.
55    pub fn alternate_bases(&self) -> AlternateBases<'_> {
56        self.0.alternate_bases()
57    }
58
59    /// Returns the quality score.
60    pub fn quality_score(&self) -> Option<io::Result<f32>> {
61        self.0.quality_score()
62    }
63
64    /// Returns the filters.
65    pub fn filters(&self) -> Filters<'_> {
66        self.0.filters()
67    }
68
69    /// Returns the info.
70    pub fn info(&self) -> Info<'_> {
71        self.0.info()
72    }
73
74    /// Returns the samples.
75    pub fn samples(&self) -> Samples<'_> {
76        self.0.samples()
77    }
78}
79
80impl fmt::Debug for Record {
81    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
82        f.debug_struct("Record")
83            .field("reference_sequence_name", &self.reference_sequence_name())
84            .field("variant_start", &self.variant_start())
85            .field("ids", &self.ids())
86            .field("reference_bases", &self.reference_bases())
87            .field("alternate_bases", &self.alternate_bases())
88            .field("quality_score", &self.quality_score())
89            .field("filters", &self.filters())
90            .field("info", &self.info())
91            .field("samples", &self.samples())
92            .finish()
93    }
94}
95
96impl TryFrom<&[u8]> for Record {
97    type Error = io::Error;
98
99    fn try_from(buf: &[u8]) -> Result<Self, Self::Error> {
100        use crate::io::Reader;
101
102        let mut reader = Reader::new(buf);
103        let mut record = Self::default();
104        reader.read_record(&mut record)?;
105        Ok(record)
106    }
107}
108
109impl crate::variant::Record for Record {
110    fn reference_sequence_name<'a, 'h: 'a>(&'a self, _: &'h Header) -> io::Result<&'a str> {
111        Ok(self.reference_sequence_name())
112    }
113
114    fn variant_start(&self) -> Option<io::Result<Position>> {
115        self.variant_start()
116    }
117
118    fn ids(&self) -> Box<dyn crate::variant::record::Ids + '_> {
119        Box::new(self.ids())
120    }
121
122    fn reference_bases(&self) -> Box<dyn crate::variant::record::ReferenceBases + '_> {
123        Box::new(self.reference_bases())
124    }
125
126    fn alternate_bases(&self) -> Box<dyn crate::variant::record::AlternateBases + '_> {
127        Box::new(self.alternate_bases())
128    }
129
130    fn quality_score(&self) -> Option<io::Result<f32>> {
131        self.quality_score()
132    }
133
134    fn filters(&self) -> Box<dyn crate::variant::record::Filters + '_> {
135        Box::new(self.filters())
136    }
137
138    fn info(&self) -> Box<dyn crate::variant::record::Info + '_> {
139        Box::new(self.info())
140    }
141
142    fn samples(&self) -> io::Result<Box<dyn crate::variant::record::Samples + '_>> {
143        Ok(Box::new(self.samples()))
144    }
145}