ps-datachunk 0.1.0-35

Chunk-based data encrypter
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use std::ops::Deref;

use bytes::Bytes;
use ps_hash::hash;
use rancor::{Error, Strategy};
use rkyv::{
    api::high::HighSerializer,
    bytecheck::CheckBytes,
    ser::allocator::ArenaHandle,
    util::AlignedVec,
    validation::{archive::ArchiveValidator, shared::SharedValidator, Validator},
    Archive, Serialize,
};

use crate::{DataChunk, Hash, Result};

#[derive(Debug, Clone)]
pub struct AlignedDataChunk {
    data: AlignedVec,
    hash: Hash,
}

impl AlignedDataChunk {
    pub fn from_parts<D, H>(data: D, hash: H) -> Self
    where
        D: Into<AlignedVec>,
        H: Into<Hash>,
    {
        let data = data.into();
        let hash = hash.into();

        Self { data, hash }
    }

    pub fn from_data_vec(data: AlignedVec) -> Result<Self> {
        let hash = hash(&data)?;

        Ok(Self::from_parts(data, hash))
    }

    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.data.is_empty()
    }

    #[must_use]
    pub fn len(&self) -> usize {
        self.data.len()
    }
}

impl AsRef<[u8]> for AlignedDataChunk {
    fn as_ref(&self) -> &[u8] {
        self
    }
}

impl Deref for AlignedDataChunk {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        &self.data
    }
}

impl AlignedDataChunk {
    pub fn try_from<T>(value: &T) -> Result<Self>
    where
        for<'a> T: Archive + Serialize<HighSerializer<AlignedVec, ArenaHandle<'a>, Error>>,
    {
        let data = rkyv::to_bytes::<Error>(value)
            .map_err(|_| crate::PsDataChunkError::RkyvSerializationFailed)?;

        Self::from_data_vec(data)
    }

    pub fn try_bytes_as<T: rkyv::Archive>(data: &[u8]) -> Result<&T::Archived>
    where
        for<'a> <T as rkyv::Archive>::Archived:
            CheckBytes<Strategy<Validator<ArchiveValidator<'a>, SharedValidator>, rancor::Error>>,
    {
        rkyv::access::<T::Archived, Error>(data)
            .map_err(|_| crate::PsDataChunkError::RkyvInvalidArchive)
    }

    pub fn try_as<T: rkyv::Archive>(&self) -> Result<&T::Archived>
    where
        for<'a> <T as Archive>::Archived:
            CheckBytes<Strategy<Validator<ArchiveValidator<'a>, SharedValidator>, rancor::Error>>,
    {
        Self::try_bytes_as::<T>(self.data_ref())
    }
}

impl DataChunk for AlignedDataChunk {
    fn data_ref(&self) -> &[u8] {
        self
    }
    fn hash_ref(&self) -> &Hash {
        &self.hash
    }
    fn hash(&self) -> Hash {
        self.hash
    }

    /// Transforms this [`DataChunk`] into [`Bytes`].
    fn into_bytes(self) -> Bytes {
        Bytes::from_owner(self.data)
    }

    /// Transforms this chunk into an [`OwnedDataChunk`]
    fn into_owned(self) -> crate::OwnedDataChunk {
        let Self { data, hash } = self;

        crate::OwnedDataChunk::from_data_and_hash(data, hash)
    }
}