zstd 0.1.0

Rust zstd bindings library.
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

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

use ll;

struct DecoderContext {
    c: ll::ZBUFFDecompressionContext,
}

impl DecoderContext {
    fn new() -> Self {
        DecoderContext { c: unsafe { ll::ZBUFF_createDCtx() } }
    }
}

impl Drop for DecoderContext {
    fn drop(&mut self) {
        let code = unsafe { ll::ZBUFF_freeDCtx(self.c) };
        ll::parse_code(code).unwrap();
    }
}


/// A decoder that decompress input data from another `Read`.
pub struct Decoder<R: Read> {
    // input reader (compressed data)
    reader: R,
    // input buffer
    buffer: Vec<u8>,
    // we already read everything in the buffer up to that point
    offset: usize,
    // decompression context
    context: DecoderContext,
}

impl<R: Read> Decoder<R> {
    pub fn new(reader: R) -> IoResult<Self> {

        let context = DecoderContext::new();

        try!(ll::parse_code(unsafe { ll::ZBUFF_decompressInit(context.c) }));

        let buffer_size = unsafe { ll::ZBUFF_recommendedDInSize() };

        Ok(Decoder {
            reader: reader,
            buffer: Vec::with_capacity(buffer_size),
            offset: 0,
            context: context,
        })
    }
}

impl<R: Read> Read for Decoder<R> {
    fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {

        let mut written = 0;
        while written != buf.len() {

            if self.offset == self.buffer.len() {
                // We need moar data!
                // Make a nice clean buffer
                let buffer_size = self.buffer.capacity();
                unsafe {
                    self.buffer.set_len(buffer_size);
                }

                // And FILL IT!
                self.offset = 0;
                let read = try!(self.reader.read(&mut self.buffer));
                unsafe {
                    self.buffer.set_len(read);
                }
                // If we can't read anything, no need to try and decompress it.
                // Just break the loop.
                if read == 0 {
                    break;
                }

            }

            let mut out_size = buf.len() - written;
            let mut in_size = self.buffer.len() - self.offset;

            unsafe {
                let code = ll::ZBUFF_decompressContinue(self.context.c,
                                                        buf[written..].as_mut_ptr(),
                                                        &mut out_size,
                                                        self.buffer[self.offset..].as_ptr(),
                                                        &mut in_size);
                let hint = try!(ll::parse_code(code));
            }

            written += out_size;
            self.offset += in_size;
        }
        Ok(written)
    }
}