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

use crate::DataChunk;
use crate::DataChunkTrait;
use ps_hash::Hash;
use std::sync::Arc;

pub struct SharedDataChunk {
    data: Arc<[u8]>,
    hash: Arc<Hash>,
}

impl SharedDataChunk {
    pub fn data(&self) -> Arc<[u8]> {
        self.data.clone()
    }

    pub fn hash(&self) -> Arc<Hash> {
        self.hash.clone()
    }
}

impl DataChunkTrait for SharedDataChunk {
    fn data_ref(&self) -> &[u8] {
        &self.data
    }

    fn hash_ref(&self) -> &[u8] {
        self.hash.as_bytes()
    }

    fn hash(&self) -> crate::HashCow {
        crate::HashCow::from_arc(self.hash.clone())
    }

    fn to_owned(&self) -> crate::OwnedDataChunk {
        crate::OwnedDataChunk::from_data_ref_and_hash(self.data_ref(), self.hash())
    }
}

impl SharedDataChunk {
    pub fn from_data_and_hash(data: Arc<[u8]>, hash: Arc<Hash>) -> Self {
        Self { data, hash }
    }

    pub fn from_data(data: Arc<[u8]>) -> Self {
        let hash = Arc::from(ps_hash::hash(&data));

        Self::from_data_and_hash(data, hash)
    }
}

impl From<Arc<[u8]>> for SharedDataChunk {
    fn from(data: Arc<[u8]>) -> Self {
        Self::from_data(data)
    }
}

impl From<&Arc<[u8]>> for SharedDataChunk {
    fn from(data: &Arc<[u8]>) -> Self {
        Self::from_data(data.clone())
    }
}

impl<'lt> From<Arc<[u8]>> for DataChunk<'lt> {
    fn from(data: Arc<[u8]>) -> Self {
        DataChunk::Shared(data.into())
    }
}

impl<'lt> From<&Arc<[u8]>> for DataChunk<'lt> {
    fn from(data: &Arc<[u8]>) -> Self {
        DataChunk::Shared(data.into())
    }
}