anystore 0.2.1

Polymorphic, type-safe, composable async API for arbitrary stores
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

use std::sync::Arc;

use thiserror::Error;
use tokio::sync::RwLock;

use crate::{
    address::{
        primitive::UniqueRootAddress,
        traits::{AddressableGet, AddressableSet},
        Addressable,
    },
    store::Store,
};

#[derive(Debug, Error, Eq, PartialEq)]
pub enum MemoryCellStoreError {}

#[derive(Debug, Clone)]
pub struct MemoryCellStore<V: Clone> {
    value: Arc<RwLock<Option<V>>>,
}

impl<V: Clone> MemoryCellStore<V> {
    pub fn new(value: Option<V>) -> Self {
        MemoryCellStore {
            value: Arc::new(RwLock::new(value)),
        }
    }
}

impl<V: Clone> Store for MemoryCellStore<V> {
    type Error = MemoryCellStoreError;
}

impl<V: Clone> Addressable<UniqueRootAddress> for MemoryCellStore<V> {
    type DefaultValue = V;
}

impl<V: Clone> AddressableGet<V, UniqueRootAddress> for MemoryCellStore<V> {
    async fn addr_get(&self, _address: &UniqueRootAddress) -> Result<Option<V>, Self::Error> {
        let value = self.value.read().await.clone();
        Ok(value)
    }
}

impl<V: Clone> AddressableSet<V, UniqueRootAddress> for MemoryCellStore<V> {
    async fn set_addr(
        &self,
        _address: &UniqueRootAddress,
        value: &Option<V>,
    ) -> Result<(), Self::Error> {
        *self.value.write().await = value.clone();
        Ok(())
    }
}