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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

use crate::{
    address::{primitive::UniqueRootAddress, *},
    location::Location,
};

// pub mod list;
// pub mod tree;

/// Main store driver
///
/// This and the related traits are what you need to implement
/// if you want to add a store.
pub trait Store: Clone {
    type Error: std::fmt::Debug + std::fmt::Display + Send + Sync + 'static;
    type RootAddress: Address + From<UniqueRootAddress> = UniqueRootAddress;
}

pub trait StoreEx<Root: Address + From<UniqueRootAddress>>: Store {
    fn sub<Addr: Address>(&self, addr: Addr) -> Location<Addr, Self>
    where
        Self: Addressable<Addr>,
    {
        Location::new(addr, self.clone())
    }

    fn root(&self) -> Location<Root, Self>
    where
        Self: Addressable<Root>,
    {
        Location::new(UniqueRootAddress.into(), self.clone())
    }

    fn path<Addr: Address>(&self, p: &str) -> StoreResult<Location<Addr, Self>, Self>
    where
        Self: Addressable<Root> + Addressable<Addr>,
        Root: PathAddress<Output = Addr>,
        <Self as Store>::Error: From<<Root as PathAddress>::Error>, // Root::Error: From<Self::Error> + Into<Self::Error>,
    {
        self.root().path(p)
    }
}

impl<S: Store> StoreEx<S::RootAddress> for S {}

pub type StoreResult<V, S> = Result<V, <S as Store>::Error>;

// pub struct SharedStore<S: Store> {
//     store: Arc<Mutex<S>>,
// }

// impl<S: Store> S {}
// impl<S: Store> SharedStore<S> {
//     pub fn new(store: S) -> Self {
//         SharedStore {
//             store: Arc::new(Mutex::new(store)),
//         }
//     }

//     pub fn root(&self) -> Location<OpaqueValue, UniqueRootAddress, S> {
//         Location::new(UniqueRootAddress, self.store.clone())
//     }
//     pub fn sub<A: AddressFor<V, S>, V>(&self, addr: A) -> Location<V, A, S> {
//         self.root().sub(addr)
//     }
// }

// pub trait ReadStore<A: AddressFor<V, Self>, V>: Store {
//     async fn _read(&self, addr: A) -> StoreResult<Option<V>, Self>;
// }
// pub trait WriteStore<A: AddressFor<V, Self>, V>: Store {
//     async fn _write(&self, value: Option<V>, addr: A) -> StoreResult<(), Self>;
// }