theory 0.1.0

Documentation viewer (WIP)
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
130
131
132

//! Reader for data blocks.

use core::num::NonZeroUsize;
use std::io::{self, Read, Seek, SeekFrom};

use super::BlockType;

/// Size of the LRU cache.
const LRU_CACHE_SIZE: NonZeroUsize = match NonZeroUsize::new(16) {
    // TODO use Option::unwrap when const_option feature is stable.
    Some(n) => n,
    None => panic!(),
};

pub(crate) struct DataBlocksReader<S> {
    stream: S,

    stream_len: u64,

    cache: lru::LruCache<u64, Result<Vec<u8>, io::Error>>,
}

impl<S: Read + Seek> DataBlocksReader<S> {
    pub(crate) fn new(mut stream: S) -> io::Result<Self> {
        let stream_len = stream.seek(SeekFrom::End(0))?;
        let cache = lru::LruCache::new(LRU_CACHE_SIZE);

        Ok(DataBlocksReader {
            stream,
            stream_len,
            cache,
        })
    }

    /// Return a mutable reference to the input stream.
    pub(crate) fn input_stream(&mut self) -> &mut S {
        &mut self.stream
    }

    /// Return the known length of the stream.
    pub(crate) fn input_stream_len(&self) -> u64 {
        self.stream_len
    }

    /// Get a block from its identifier.
    ///
    /// The function is applied only if the block can be fully read, and the
    /// offset is within the block.
    pub(crate) fn with_block<F, T, O>(&mut self, block_id: u64, offset: O, f: F) -> io::Result<T>
    where
        F: FnOnce(&[u8]) -> T,
        O: TryInto<usize>,
    {
        let offset = O::try_into(offset).map_err(|_| {
            io::Error::new(
                io::ErrorKind::InvalidInput,
                "offset cannot be converted to usize",
            )
        })?;

        let stream = &mut self.stream;

        let result = self.cache.get_or_insert(block_id, || {
            stream.seek(SeekFrom::Start(block_id))?;

            // Block type.
            let mut byte_tag = [0];
            stream.read_exact(&mut byte_tag)?;

            let block_type = BlockType::try_from(byte_tag[0])
                .map_err(|_| io::Error::new(io::ErrorKind::Other, "Invalid block type"))?;

            // Block length.
            //
            // Return an error if the length is beyond the end of the input.
            let mut len = [0; 4];
            stream.read_exact(&mut len)?;
            let len = u32::from_be_bytes(len);

            if offset > len as usize {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidInput,
                    "offset is beyond end of the block",
                ));
            }

            if block_id.saturating_add(len as u64) > self.stream_len {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidData,
                    "Block beyond the end of the input",
                ));
            }

            // Block data.
            let mut data;

            match block_type {
                BlockType::Uncompressed => {
                    data = vec![0; len as usize];
                    stream.read_exact(&mut data)?;
                }

                #[cfg(feature = "deflate")]
                BlockType::Deflate => {
                    data = Vec::with_capacity(len.next_power_of_two() as usize);
                    let mut deflater = flate2::write::DeflateDecoder::new(&mut data);
                    io::copy(&mut stream.take(len as u64), &mut deflater)?;
                    deflater.finish()?;
                    data.shrink_to_fit()
                }

                #[cfg(feature = "lz4")]
                BlockType::Lz4 => {
                    data = Vec::with_capacity(len.next_power_of_two() as usize);
                    let mut decoder = lz4_flex::frame::FrameDecoder::new(stream.take(len as u64));
                    decoder.read_to_end(&mut data)?;
                    data.shrink_to_fit()
                }
            }

            Ok(data)
        });

        result
            .as_ref()
            .map(|data| f(&data[offset..]))
            .map_err(|e| match e.get_ref() {
                Some(r) => io::Error::new(e.kind(), r.to_string()),
                None => io::Error::new(e.kind(), ""),
            })
    }
}