noodles_cram/container/block_content_encoder_map/
builder.rs

1use std::collections::HashMap;
2
3use super::BlockContentEncoderMap;
4use crate::{
5    codecs::Encoder,
6    container::{
7        block,
8        compression_header::{data_series_encodings::DataSeries, preservation_map::tag_sets},
9    },
10};
11
12/// A CRAM container block content-encoder map builder.
13#[derive(Debug)]
14pub struct Builder {
15    core_data_encoder: Option<Encoder>,
16    data_series_encoders: Vec<Option<Encoder>>,
17    tag_values_encoders: HashMap<block::ContentId, Option<Encoder>>,
18}
19
20impl Builder {
21    /// Sets the core data encoder.
22    ///
23    /// # Examples
24    ///
25    /// ```
26    /// use noodles_cram::container::BlockContentEncoderMap;
27    /// let builder = BlockContentEncoderMap::builder().set_core_data_encoder(None);
28    /// ```
29    pub fn set_core_data_encoder(mut self, encoder: Option<Encoder>) -> Self {
30        self.core_data_encoder = encoder;
31        self
32    }
33
34    /// Sets a data series encoder.
35    ///
36    /// # Examples
37    ///
38    /// ```
39    /// use noodles_cram::container::{
40    ///     compression_header::data_series_encodings::DataSeries,
41    ///     BlockContentEncoderMap,
42    /// };
43    ///
44    /// let builder = BlockContentEncoderMap::builder()
45    ///     .set_data_series_encoder(DataSeries::BamFlags, None);
46    /// ```
47    pub fn set_data_series_encoder(
48        mut self,
49        data_series: DataSeries,
50        encoder: Option<Encoder>,
51    ) -> Self {
52        let i = (block::ContentId::from(data_series) as usize) - 1;
53        self.data_series_encoders[i] = encoder;
54        self
55    }
56
57    /// Sets a tag values encoder.
58    ///
59    /// # Examples
60    ///
61    /// ```
62    /// use noodles_cram::container::{
63    ///     compression_header::preservation_map::tag_sets::Key,
64    ///     BlockContentEncoderMap,
65    /// };
66    /// use noodles_sam::alignment::record::data::field::{Tag, Type};
67    ///
68    /// let key = Key::new(Tag::ALIGNMENT_HIT_COUNT, Type::UInt8);
69    /// let builder = BlockContentEncoderMap::builder()
70    ///     .set_tag_values_encoder(key, None);
71    /// ```
72    pub fn set_tag_values_encoder(mut self, key: tag_sets::Key, encoder: Option<Encoder>) -> Self {
73        let id = block::ContentId::from(key);
74        self.tag_values_encoders.insert(id, encoder);
75        self
76    }
77
78    /// Builds a block content-encoder map.
79    ///
80    /// # Examples
81    ///
82    /// ```
83    /// use noodles_cram::container::BlockContentEncoderMap;
84    /// let map = BlockContentEncoderMap::builder().build();
85    /// ```
86    pub fn build(self) -> BlockContentEncoderMap {
87        BlockContentEncoderMap {
88            core_data_encoder: self.core_data_encoder,
89            data_series_encoders: self.data_series_encoders,
90            tag_values_encoders: self.tag_values_encoders,
91        }
92    }
93}
94
95impl Default for Builder {
96    fn default() -> Self {
97        use flate2::Compression;
98
99        use crate::container::compression_header::data_series_encodings::data_series::STANDARD_DATA_SERIES;
100
101        let compression_level = Compression::default();
102
103        Self {
104            core_data_encoder: Some(Encoder::Gzip(compression_level)),
105            data_series_encoders: vec![
106                Some(Encoder::Gzip(compression_level));
107                STANDARD_DATA_SERIES.len()
108            ],
109            tag_values_encoders: HashMap::new(),
110        }
111    }
112}