noodles_vcf/variant/record_buf/
convert.rs

1use std::io;
2
3use super::RecordBuf;
4use crate::{variant::Record, Header};
5
6impl RecordBuf {
7    /// Converts a variant record to a buffer.
8    pub fn try_from_variant_record<R>(header: &Header, record: &R) -> io::Result<Self>
9    where
10        R: Record,
11    {
12        use super::Samples;
13
14        let mut record_buf = RecordBuf::default();
15
16        *record_buf.reference_sequence_name_mut() = record.reference_sequence_name(header)?.into();
17        *record_buf.variant_start_mut() = record.variant_start().transpose()?;
18        *record_buf.ids_mut() = record.ids().iter().map(String::from).collect();
19
20        let raw_reference_bases: Vec<_> =
21            record.reference_bases().iter().collect::<io::Result<_>>()?;
22        *record_buf.reference_bases_mut() = String::from_utf8(raw_reference_bases)
23            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
24
25        let raw_alternate_bases: Vec<_> = record
26            .alternate_bases()
27            .iter()
28            .map(|result| result.map(String::from))
29            .collect::<io::Result<_>>()?;
30        *record_buf.alternate_bases_mut() = raw_alternate_bases.into();
31
32        *record_buf.quality_score_mut() = record.quality_score().transpose()?;
33
34        *record_buf.filters_mut() = record
35            .filters()
36            .iter(header)
37            .map(|result| result.map(String::from))
38            .collect::<io::Result<_>>()?;
39
40        *record_buf.info_mut() = record
41            .info()
42            .iter(header)
43            .map(|result| {
44                result.and_then(|(key, value)| {
45                    let v = value.map(|v| v.try_into()).transpose()?;
46                    Ok((String::from(key), v))
47                })
48            })
49            .collect::<io::Result<_>>()?;
50
51        let samples = record.samples()?;
52
53        let keys = samples
54            .column_names(header)
55            .map(|result| result.map(String::from))
56            .collect::<io::Result<_>>()?;
57
58        let values = samples
59            .iter()
60            .map(|sample| {
61                sample
62                    .iter(header)
63                    .map(|result| {
64                        result.and_then(|(_, value)| value.map(|v| v.try_into()).transpose())
65                    })
66                    .collect()
67            })
68            .collect::<io::Result<_>>()?;
69
70        *record_buf.samples_mut() = Samples::new(keys, values);
71
72        Ok(record_buf)
73    }
74}