servicepoint2 0.4.3

A rust library for the CCCB Service Point Display.
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

#[allow(unused)]
use std::io::{Read, Write};

#[cfg(feature = "compression_bzip2")]
use bzip2::read::{BzDecoder, BzEncoder};
#[cfg(feature = "compression_zlib")]
use flate2::{FlushCompress, FlushDecompress, Status};
#[cfg(feature = "compression_zstd")]
use zstd::{Decoder as ZstdDecoder, Encoder as ZstdEncoder};

use crate::{CompressionCode, Payload};

pub(crate) fn into_decompressed(
    kind: CompressionCode,
    payload: Payload,
) -> Option<Payload> {
    match kind {
        CompressionCode::Uncompressed => Some(payload),
        #[cfg(feature = "compression_zlib")]
        CompressionCode::Zlib => {
            let mut decompress = flate2::Decompress::new(true);
            let mut buffer = [0u8; 10000];

            let status = match decompress.decompress(
                &payload,
                &mut buffer,
                FlushDecompress::Finish,
            ) {
                Err(_) => return None,
                Ok(status) => status,
            };

            match status {
                Status::Ok => None,
                Status::BufError => None,
                Status::StreamEnd => Some(
                    buffer[0..(decompress.total_out() as usize)].to_owned(),
                ),
            }
        }
        #[cfg(feature = "compression_bzip2")]
        CompressionCode::Bzip2 => {
            let mut decoder = BzDecoder::new(&*payload);
            let mut decompressed = vec![];
            match decoder.read_to_end(&mut decompressed) {
                Err(_) => None,
                Ok(_) => Some(decompressed),
            }
        }
        #[cfg(feature = "compression_lzma")]
        CompressionCode::Lzma => match lzma::decompress(&payload) {
            Err(_) => None,
            Ok(decompressed) => Some(decompressed),
        },
        #[cfg(feature = "compression_zstd")]
        CompressionCode::Zstd => {
            let mut decoder = match ZstdDecoder::new(&*payload) {
                Err(_) => return None,
                Ok(value) => value,
            };
            let mut decompressed = vec![];
            match decoder.read_to_end(&mut decompressed) {
                Err(_) => None,
                Ok(_) => Some(decompressed),
            }
        }
    }
}

pub(crate) fn into_compressed(
    kind: CompressionCode,
    payload: Payload,
) -> Payload {
    match kind {
        CompressionCode::Uncompressed => payload,
        #[cfg(feature = "compression_zlib")]
        CompressionCode::Zlib => {
            let mut compress =
                flate2::Compress::new(flate2::Compression::fast(), true);
            let mut buffer = [0u8; 10000];

            match compress
                .compress(&payload, &mut buffer, FlushCompress::Finish)
                .expect("compress failed")
            {
                Status::Ok => panic!("buffer should be big enough"),
                Status::BufError => panic!("BufError"),
                Status::StreamEnd => {}
            };
            buffer[..compress.total_out() as usize].to_owned()
        }
        #[cfg(feature = "compression_bzip2")]
        CompressionCode::Bzip2 => {
            let mut encoder =
                BzEncoder::new(&*payload, bzip2::Compression::fast());
            let mut compressed = vec![];
            match encoder.read_to_end(&mut compressed) {
                Err(err) => panic!("could not compress payload: {}", err),
                Ok(_) => compressed,
            }
        }
        #[cfg(feature = "compression_lzma")]
        CompressionCode::Lzma => lzma::compress(&payload, 6).unwrap(),
        #[cfg(feature = "compression_zstd")]
        CompressionCode::Zstd => {
            let mut encoder =
                ZstdEncoder::new(vec![], zstd::DEFAULT_COMPRESSION_LEVEL)
                    .expect("could not create encoder");
            encoder
                .write_all(&payload)
                .expect("could not compress payload");
            encoder.finish().expect("could not finish encoding")
        }
    }
}