stackstring 0.4.4

A fixed-size string
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

use super::{Error, String};

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

impl<const L: usize> Archive for String<L> {
    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, const L: usize> Serialize<S> for String<L>
where
    S::Error: Source,
    str: SerializeUnsized<S>,
{
    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
        ArchivedString::serialize_from_str(self.as_str(), serializer)
    }
}

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

impl<D: Fallible<Error = Error> + ?Sized, const L: usize> Deserialize<String<L>, D>
    for ArchivedString
where
    str: DeserializeUnsized<str, D>,
{
    fn deserialize(&self, _: &mut D) -> Result<String<L>, D::Error> {
        String::try_from(self.as_str())
    }
}