ps-hkey 0.1.0-34

This crate defines the hashkey format and provides methods for resolving them
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

use std::{
    collections::HashMap,
    sync::{Arc, Mutex, PoisonError},
};

use ps_datachunk::{DataChunk, DataChunkError, OwnedDataChunk};
use ps_hash::{Hash, HashError};

use crate::HkeyError;

use super::Store;

#[derive(Clone, Debug, Default)]
pub struct InMemoryStore {
    hashmap: Arc<Mutex<HashMap<Hash, OwnedDataChunk>>>,
}

#[derive(thiserror::Error, Debug)]
pub enum InMemoryStoreError {
    #[error(transparent)]
    DataChunk(#[from] DataChunkError),
    #[error(transparent)]
    Hash(#[from] HashError),
    #[error(transparent)]
    Hkey(#[from] HkeyError),
    #[error("The internal mutex was poisoned.")]
    MutexPoison,
    #[error("The data with this hash was not found.")]
    NotFound,
}

impl<T> From<PoisonError<T>> for InMemoryStoreError {
    fn from(_: PoisonError<T>) -> Self {
        Self::MutexPoison
    }
}

impl Store for InMemoryStore {
    type Chunk<'c> = OwnedDataChunk;
    type Error = InMemoryStoreError;

    fn get<'a>(&'a self, hash: &Hash) -> Result<Self::Chunk<'a>, Self::Error> {
        self.hashmap
            .lock()?
            .get(hash)
            .cloned()
            .ok_or(InMemoryStoreError::NotFound)
    }

    fn put_encrypted<C: DataChunk>(&self, chunk: C) -> Result<(), Self::Error> {
        let chunk = chunk.into_owned();
        let hash = *chunk.hash_ref();

        self.hashmap.lock()?.insert(hash, chunk);

        Ok(())
    }
}