liteboxfs 0.1.0

A modern POSIX filesystem in a SQLite database
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

use std::ops::RangeBounds;

use super::types::BlockSignature;

pub trait EjectBuf {
    fn eject(self) -> Vec<u8>;
}

#[derive(Debug)]
pub struct FullSliceBuf {
    buf: Vec<u8>,
}

impl FullSliceBuf {
    pub fn new(buf: Vec<u8>) -> Self {
        FullSliceBuf { buf }
    }

    pub fn splice<R, I>(&mut self, range: R, replace_with: I)
    where
        R: RangeBounds<usize>,
        I: IntoIterator<Item = u8>,
    {
        self.buf.splice(range, replace_with);
    }
}

impl EjectBuf for FullSliceBuf {
    fn eject(mut self) -> Vec<u8> {
        self.buf.clear();
        self.buf
    }
}

impl AsRef<[u8]> for FullSliceBuf {
    fn as_ref(&self) -> &[u8] {
        self.buf.as_ref()
    }
}

impl AsMut<[u8]> for FullSliceBuf {
    fn as_mut(&mut self) -> &mut [u8] {
        self.buf.as_mut()
    }
}

#[derive(Debug)]
pub struct PartialSliceBuf {
    buf: Vec<u8>,
    first_block: Option<BlockSignature>,
    last_block: Option<BlockSignature>,
}

impl PartialSliceBuf {
    pub fn new(
        buf: Vec<u8>,
        first_block: Option<BlockSignature>,
        last_block: Option<BlockSignature>,
    ) -> Self {
        PartialSliceBuf {
            buf,
            first_block,
            last_block,
        }
    }

    pub fn first_block_signature(&self) -> Option<&BlockSignature> {
        self.first_block.as_ref()
    }

    pub fn last_block_signature(&self) -> Option<&BlockSignature> {
        self.last_block.as_ref()
    }

    /// The bytes of the first block in the slice, or `None` if the first block is a hole or the
    /// slice is empty. Hole blocks contribute no bytes to the buffer.
    pub fn first_block_data(&self) -> Option<&[u8]> {
        match &self.first_block {
            Some(BlockSignature::Data { len, .. }) => Some(
                self.buf
                    .get(0..*len)
                    .expect("Partial slice buffer unexpectedly missing the first block."),
            ),
            _ => None,
        }
    }

    /// The bytes of the last block in the slice, or `None` if the last block is a hole or the slice
    /// is empty.
    pub fn last_block_data(&self) -> Option<&[u8]> {
        let first_data_len = match &self.first_block {
            Some(BlockSignature::Data { len, .. }) => *len,
            _ => 0,
        };

        match &self.last_block {
            Some(BlockSignature::Data { len, .. }) => Some(
                self.buf
                    .get(first_data_len..(first_data_len + *len))
                    .expect("Partial slice buffer unexpectedly missing the last block."),
            ),
            _ => None,
        }
    }
}

impl EjectBuf for PartialSliceBuf {
    fn eject(mut self) -> Vec<u8> {
        self.buf.clear();
        self.buf
    }
}

pub enum SliceBuf {
    Full(FullSliceBuf),
    Partial(PartialSliceBuf),
}

impl EjectBuf for SliceBuf {
    fn eject(self) -> Vec<u8> {
        match self {
            SliceBuf::Full(b) => b.eject(),
            SliceBuf::Partial(b) => b.eject(),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SliceReadMode {
    Full,
    Partial,
}