d4 0.3.9

The D4 file format implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::io::{Read, Result};

pub use crate::chrom::Chrom;
use crate::dict::Dictionary;
use serde_derive::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Clone, Copy)]
pub enum Denominator {
    One,
    Value(f64),
}

impl Default for Denominator {
    fn default() -> Self {
        Self::One
    }
}

/// The D4 file header struct, this is store in the ".metadata" stream in a D4 file in JSON format
#[derive(Serialize, Deserialize)]
pub struct Header {
    pub(crate) chrom_list: Vec<Chrom>,
    pub(crate) dictionary: Dictionary,
    #[serde(default)]
    pub(crate) denominator: Denominator,
}

impl Default for Header {
    fn default() -> Self {
        Self::new()
    }
}

impl Header {
    pub const HEADER_STREAM_NAME: &'static str = ".metadata";
    /// Build a new header
    pub fn new() -> Self {
        Header {
            chrom_list: vec![],
            dictionary: Dictionary::SimpleRange { low: 0, high: 64 },
            denominator: Denominator::One,
        }
    }

    pub fn read<R: Read>(mut input: R) -> Result<Self> {
        let header_data = {
            let mut ret = vec![];
            loop {
                let mut buf = [0u8; 4096];
                let sz = input.read(&mut buf)?;
                let mut actual_size = sz;
                while actual_size > 0 && buf[actual_size - 1] == 0 {
                    actual_size -= 1;
                }
                ret.extend_from_slice(&buf[..actual_size]);
                if actual_size != sz {
                    break ret;
                }
            }
        };
        let header = serde_json::from_str(String::from_utf8_lossy(&header_data).as_ref())
            .map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, "Invalid Metadata"))?;
        Ok(header)
    }

    /// Assign dictionary to the header
    pub fn dictionary(&self) -> &Dictionary {
        &self.dictionary
    }

    /// Get a reference to current chromosome list
    pub fn chrom_list(&self) -> &[Chrom] {
        self.chrom_list.as_ref()
    }

    /// Set new chromosome list
    pub fn set_chrom_list(&mut self, new_value: Vec<Chrom>) {
        self.chrom_list = new_value
    }

    pub fn set_denominator(&mut self, value: f64) {
        self.denominator = Denominator::Value(value);
    }

    pub fn is_integral(&self) -> bool {
        matches!(self.denominator, Denominator::One)
    }

    pub fn get_denominator(&self) -> f64 {
        match self.denominator {
            Denominator::One => 1.0,
            Denominator::Value(v) => v,
        }
    }

    pub(crate) fn primary_table_offset_of_chrom(&self, chrom: &str) -> usize {
        let bw = self.dictionary.bit_width();
        self.chrom_list
            .iter()
            .take_while(|chr| chr.name != chrom)
            .map(|chr| (chr.size as usize * bw + 7) / 8)
            .sum()
    }

    pub fn get_chrom_id(&self, chrom: &str) -> Option<usize> {
        self.chrom_list
            .iter()
            .enumerate()
            .find(|(_, chr)| chr.name == chrom)
            .map(|(id, _)| id)
    }

    pub(crate) fn primary_table_size_of_chrom(&self, chrom: &str) -> usize {
        let bw = self.dictionary.bit_width();
        self.chrom_list
            .iter()
            .find(|chr| chr.name == chrom)
            .map(|chr| (chr.size as usize * bw + 7) / 8)
            .unwrap_or(0)
    }

    pub(crate) fn primary_table_size(&self) -> usize {
        let bit_width = self.dictionary.bit_width();
        self.chrom_list
            .iter()
            .map(|chr| (chr.size as usize * bit_width + 7) / 8)
            .sum()
    }
}