turbocow 0.3.0-beta.2

Compact, clone-on-write vectors, strings, maps and sets with inline + referenced storage — a superset of ecow.
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

use rkyv::rancor::{Fallible, Source};
use rkyv::ser::{Allocator, Writer};
use rkyv::string::{ArchivedString, StringResolver};
use rkyv::vec::{ArchivedVec, VecResolver};
use rkyv::{Archive, Deserialize, Place, Serialize, SerializeUnsized};

use super::{EcoByteString, EcoString};

// ═══════════════════════════════════════════════════════════════════════════
// EcoString — archived as an ArchivedString (same as String)
// ═══════════════════════════════════════════════════════════════════════════

impl Archive for EcoString {
    type Archived = ArchivedString;
    type Resolver = StringResolver;

    fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>) {
        ArchivedString::resolve_from_str(self.as_str(), resolver, out);
    }
}

impl<Ser> Serialize<Ser> for EcoString
where
    Ser: Fallible + ?Sized,
    Ser::Error: Source,
    str: SerializeUnsized<Ser>,
{
    fn serialize(&self, serializer: &mut Ser) -> Result<StringResolver, Ser::Error> {
        ArchivedString::serialize_from_str(self.as_str(), serializer)
    }
}

impl<D> Deserialize<EcoString, D> for ArchivedString
where
    D: Fallible + ?Sized,
{
    fn deserialize(&self, _: &mut D) -> Result<EcoString, D::Error> {
        Ok(EcoString::from(self.as_str()))
    }
}

// ═══════════════════════════════════════════════════════════════════════════
// EcoByteString — archived as an ArchivedVec<u8> (same as Vec<u8>)
// ═══════════════════════════════════════════════════════════════════════════

impl Archive for EcoByteString {
    type Archived = ArchivedVec<u8>;
    type Resolver = VecResolver;

    fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>) {
        ArchivedVec::resolve_from_slice(self.as_bytes(), resolver, out);
    }
}

impl<Ser> Serialize<Ser> for EcoByteString
where
    Ser: Fallible + Allocator + Writer + ?Sized,
{
    fn serialize(&self, serializer: &mut Ser) -> Result<VecResolver, Ser::Error> {
        ArchivedVec::<u8>::serialize_from_slice(self.as_bytes(), serializer)
    }
}

impl<D> Deserialize<EcoByteString, D> for ArchivedVec<u8>
where
    D: Fallible + ?Sized,
{
    fn deserialize(&self, _: &mut D) -> Result<EcoByteString, D::Error> {
        Ok(EcoByteString::from_bytes(self.as_slice()))
    }
}