eight 1.0.0-alpha.2

Modular asynchronous embedded key-value 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

//! Official filesystem based storage implementation for eight.

use crate::{
    embedded::{self, filesystem},
    err,
};
use async_trait::async_trait;
use std::path::PathBuf;

/// Filesystem based storage. Preferred when you need to keep key-values on disk.
#[derive(Debug, Default)]
pub struct Storage {
    path: PathBuf,
}

impl Storage {
    /// Create new file-storage.
    ///
    /// This function is same with [`Default::default`].
    pub fn new() -> Self {
        Default::default()
    }

    /// Create new file-storage from path.
    ///
    /// ```no_run
    /// use eight::embedded::storage::filesystem;
    ///
    /// filesystem::Storage::from_path("/tmp/test");
    /// ```
    pub fn from_path<T>(path: T) -> Self
    where
        T: Into<PathBuf>,
    {
        Self { path: path.into() }
    }
}

#[async_trait]
impl super::Storage for Storage {
    async fn set(&self, key: String, value: String) -> embedded::Result<()> {
        let mut path = filesystem::create_path(&self.path, &key)?;
        filesystem::write(&mut path, value).await
    }

    async fn get(&self, key: String) -> embedded::Result<String> {
        let path = filesystem::create_path(&self.path, &key)?;
        filesystem::read(&path).await
    }

    async fn delete(&self, key: String) -> embedded::Result<()> {
        let path = filesystem::create_path(&self.path, &key)?;
        filesystem::delete(&path).await
    }

    async fn exists(&self, key: String) -> embedded::Result<bool> {
        let path = filesystem::create_path(&self.path, &key)?;
        filesystem::exists(&path).await
    }

    async fn increment(&self, key: String, num: usize) -> embedded::Result<usize> {
        let mut path = filesystem::create_path(&self.path, &key)?;

        let raw = filesystem::read(&path).await?;
        let new = raw
            .parse::<usize>()
            .map_err(|_| err!(embedded, UIntParseFail))?
            + num;

        filesystem::write(&mut path, new.to_string()).await?;
        Ok(new)
    }

    async fn decrement(&self, key: String, num: usize) -> embedded::Result<usize> {
        let mut path = filesystem::create_path(&self.path, &key)?;

        let raw = filesystem::read(&path).await?;
        let new = raw
            .parse::<usize>()
            .map_err(|_| err!(embedded, UIntParseFail))?
            - num;

        filesystem::write(&mut path, new.to_string()).await?;
        Ok(new)
    }

    async fn search(&self, key: String) -> embedded::Result<Vec<String>> {
        filesystem::search(&self.path, &key).await
    }

    async fn flush(&self) -> embedded::Result<()> {
        filesystem::flush(&self.path).await
    }
}