kvs 0.0.6

Embedded Key-Value Store
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

use crate::adapters::*;
use core::ops::{Deref, DerefMut};

pub struct PagedAdapter<A, const PAGE_SIZE: usize>
where
    A: StoreAdapter,
{
    inner: A,
}

impl<A, const PAGE_SIZE: usize> PagedAdapter<A, PAGE_SIZE>
where
    A: StoreAdapter,
{
    pub fn new(inner: A) -> Self {
        Self { inner }
    }
}

impl<A, const PAGE_SIZE: usize> Deref for PagedAdapter<A, PAGE_SIZE>
where
    A: StoreAdapter,
{
    type Target = A;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl<A, const PAGE_SIZE: usize> DerefMut for PagedAdapter<A, PAGE_SIZE>
where
    A: StoreAdapter,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

impl<A, const PAGE_SIZE: usize> StoreAdapter for PagedAdapter<A, PAGE_SIZE>
where
    A: StoreAdapter,
{
    type Error = A::Error;

    fn max_address(&self) -> Address {
        self.inner.max_address()
    }

    fn read(&mut self, addr: Address, buf: &mut [u8]) -> Result<(), Self::Error> {
        self.inner.read(addr, buf)
    }

    fn write(&mut self, addr: Address, data: &[u8]) -> Result<(), Self::Error> {
        let page_offset = addr % PAGE_SIZE;
        if page_offset + data.len() <= PAGE_SIZE {
            return self.inner.write(addr, data);
        }

        let mut offset = 0;
        let mut chunk = PAGE_SIZE - page_offset;
        while chunk > 0 {
            self.inner
                .write(addr + offset, &data[offset..(offset + chunk)])?;
            offset += chunk;
            chunk = usize::min(PAGE_SIZE, data.len() - offset);
        }

        Ok(())
    }
}