slow5 0.12.1

Library for interacting with slow5
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

#[cfg(feature = "zstd")]
use slow5lib_sys::slow5_press_method_SLOW5_COMPRESS_ZSTD;
use slow5lib_sys::{
    slow5_press_method_SLOW5_COMPRESS_NONE, slow5_press_method_SLOW5_COMPRESS_SVB_ZD,
    slow5_press_method_SLOW5_COMPRESS_ZLIB, slow5_press_method_SLOW5_COMPRESS_EX_ZD
};

/// SLOW5 record compression
#[non_exhaustive]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
pub enum RecordCompression {
    /// No compression
    None,
    /// Compress using zlib
    Zlib,
    #[cfg(feature = "zstd")]
    /// Compress using zstd
    ZStd,

}

impl RecordCompression {
    pub(crate) fn to_slow5_rep(self) -> u32 {
        match self {
            Self::None => slow5_press_method_SLOW5_COMPRESS_NONE,
            #[cfg(feature = "zstd")]
            Self::ZStd => slow5_press_method_SLOW5_COMPRESS_ZSTD,
            Self::Zlib => slow5_press_method_SLOW5_COMPRESS_ZLIB,
        }
    }

    #[allow(non_upper_case_globals)]
    #[allow(non_snake_case)]
    pub(crate) fn from_u32(n: u32) -> Self {
        match n {
            slow5_press_method_SLOW5_COMPRESS_NONE => Self::None,
            slow5_press_method_SLOW5_COMPRESS_ZLIB => Self::Zlib,
            #[cfg(feature = "zstd")]
            slow5_press_method_SLOW5_COMPRESS_ZSTD => Self::ZStd,
            _ => unreachable!("Invalid record compression"),
        }
    }
}

/// SLOW5 signal compression
#[non_exhaustive]
#[derive(Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Clone, Copy)]
pub enum SignalCompression {
    /// No signal compression
    None,
    /// Compress using streamvbyte library
    StreamVByte,
    /// Compress using ex-zd algorithm
    ExZd
}

impl SignalCompression {
    pub(crate) fn to_slow5_rep(self) -> u32 {
        match self {
            SignalCompression::None => slow5_press_method_SLOW5_COMPRESS_NONE,
            SignalCompression::StreamVByte => slow5_press_method_SLOW5_COMPRESS_SVB_ZD,
            SignalCompression::ExZd => slow5_press_method_SLOW5_COMPRESS_EX_ZD,
        }
    }

    #[allow(non_upper_case_globals)]
    #[allow(non_snake_case)]
    pub(crate) fn from_u32(x: u32) -> Self {
        match x {
            slow5_press_method_SLOW5_COMPRESS_NONE => SignalCompression::None,
            slow5_press_method_SLOW5_COMPRESS_SVB_ZD => SignalCompression::StreamVByte,
            slow5_press_method_SLOW5_COMPRESS_EX_ZD => SignalCompression::ExZd,
            _ => unreachable!("Invalid compression"),
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_sig_comp_from_u32() {
        let method = slow5_press_method_SLOW5_COMPRESS_EX_ZD;
        assert_eq!(SignalCompression::from_u32(method), SignalCompression::ExZd);

        let method = slow5_press_method_SLOW5_COMPRESS_SVB_ZD;
        assert_eq!(SignalCompression::from_u32(method), SignalCompression::StreamVByte);
    }
}