compact_str 0.9.0

A memory efficient string type that transparently stores strings on the stack, when possible
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

#![cfg_attr(docsrs, doc(cfg(feature = "rkyv")))]

use rkyv::rancor::{Fallible, Source};
use rkyv::string::{ArchivedString, StringResolver};
use rkyv::{Archive, Deserialize, DeserializeUnsized, Place, Serialize, SerializeUnsized};

use crate::CompactString;

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

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

impl<S: Fallible + ?Sized> Serialize<S> for CompactString
where
    str: SerializeUnsized<S>,
    S::Error: Source,
{
    #[inline]
    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
        ArchivedString::serialize_from_str(self.as_str(), serializer)
    }
}

impl<D: Fallible + ?Sized> Deserialize<CompactString, D> for ArchivedString
where
    str: DeserializeUnsized<str, D>,
{
    #[inline]
    fn deserialize(&self, _: &mut D) -> Result<CompactString, D::Error> {
        Ok(self.as_str().into())
    }
}

impl PartialEq<CompactString> for ArchivedString {
    #[inline]
    fn eq(&self, other: &CompactString) -> bool {
        PartialEq::eq(self.as_str(), other.as_str())
    }
}

impl PartialOrd<CompactString> for ArchivedString {
    #[inline]
    fn partial_cmp(&self, other: &CompactString) -> Option<core::cmp::Ordering> {
        PartialOrd::partial_cmp(self.as_str(), other.as_str())
    }
}

#[cfg(test)]
mod tests {
    use alloc::string::String;

    use rkyv::string::ArchivedString;
    use rkyv::{rancor, Archive};
    use test_strategy::proptest;

    use crate::CompactString;

    #[cfg_attr(miri, ignore)] // https://github.com/rust-lang/unsafe-code-guidelines/issues/134
    #[test]
    fn test_roundtrip() {
        const VALUE: &str = "Hello, 🌍!";

        let bytes_compact = rkyv::to_bytes::<rancor::Error>(&CompactString::from(VALUE)).unwrap();
        let bytes_control = rkyv::to_bytes::<rancor::Error>(&String::from(VALUE)).unwrap();
        assert_eq!(&*bytes_compact, &*bytes_control);

        let archived = rkyv::access::<ArchivedString, rancor::Error>(&bytes_compact).unwrap();
        let compact = rkyv::deserialize::<CompactString, rancor::Error>(archived).unwrap();
        let control = rkyv::deserialize::<String, rancor::Error>(archived).unwrap();
        assert_eq!(archived, VALUE);
        assert_eq!(compact, VALUE);
        assert_eq!(control, VALUE);

        let archived = rkyv::access::<ArchivedString, rancor::Error>(&bytes_compact).unwrap();
        let compact = rkyv::deserialize::<CompactString, rancor::Error>(archived).unwrap();
        let control = rkyv::deserialize::<String, rancor::Error>(archived).unwrap();
        assert_eq!(archived, VALUE);
        assert_eq!(compact, VALUE);
        assert_eq!(control, VALUE);
    }

    #[cfg_attr(miri, ignore)]
    #[proptest]
    fn proptest_roundtrip(s: String) {
        let bytes_compact = rkyv::to_bytes::<rancor::Error>(&CompactString::from(&s)).unwrap();
        let bytes_control = rkyv::to_bytes::<rancor::Error>(&s).unwrap();
        assert_eq!(&*bytes_compact, &*bytes_control);

        let archived =
            rkyv::access::<<CompactString as Archive>::Archived, rancor::Error>(&bytes_compact)
                .unwrap();
        let compact = rkyv::deserialize::<CompactString, rancor::Error>(archived).unwrap();
        let control = rkyv::deserialize::<String, rancor::Error>(archived).unwrap();
        assert_eq!(archived, &s);
        assert_eq!(compact, s);
        assert_eq!(control, s);

        let archived =
            rkyv::access::<<String as Archive>::Archived, rancor::Error>(&bytes_compact).unwrap();
        let compact = rkyv::deserialize::<CompactString, rancor::Error>(archived).unwrap();
        let control = rkyv::deserialize::<String, rancor::Error>(archived).unwrap();
        assert_eq!(archived, &s);
        assert_eq!(compact, s);
        assert_eq!(control, s);
    }
}