hexga_encoding 0.0.11-beta.53

Encoding and I/O abstraction for loading, saving, and converting data with custom extensions and media types, with optional Serde integration.
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

use super::*;

pub trait UrlDeserializer<'de>: Deserializer<'de>
{
    fn deserialize_with_encoding<T>(self) -> Result<T, Self::Error>
    where
        T: FromUrl,
    {
        if self.is_human_readable()
        {
            let url = self.deserialize_string(StringVisitor)?;
            return T::from_url(&url).map_err(serde::de::Error::custom);
        }
        let url = self.deserialize_byte_buf(BytesVisitor)?;
        return T::from_bin_url_or_bytes(&url, "").map_err(serde::de::Error::custom);
    }
}
impl<'de, F> UrlDeserializer<'de> for F where F: Deserializer<'de> + ?Sized {}

pub trait UrlSerializer: Serializer
{
    fn serialize_with_encoding<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ToUrl,
    {
        self.serialize_with_encoding_and_extension(
            value,
            T::save_prefered_extension().unwrap_or_default(),
        )
    }

    fn serialize_with_encoding_and_extension<T>(
        self,
        value: &T,
        extension: &extension,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: ToUrl,
    {
        use serde::ser::Error;

        if self.is_human_readable()
        {
            let url = value.to_url(extension).map_err(Self::Error::custom)?;
            self.serialize_str(&url)
        }
        else
        {
            let url = value.to_url_bin(extension).map_err(Self::Error::custom)?;
            self.serialize_bytes(&url)
        }
    }
}

impl<F> UrlSerializer for F where F: Serializer + ?Sized {}

pub(crate) struct BytesVisitor;

impl<'de> Visitor<'de> for BytesVisitor
{
    type Value = Vec<u8>;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result
    {
        formatter.write_str("a byte buffer")
    }

    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        Ok(v.to_vec())
    }

    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        Ok(v)
    }
}

pub(crate) struct StringVisitor;

impl<'de> Visitor<'de> for StringVisitor
{
    type Value = String;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result
    {
        formatter.write_str("a UTF-8 string")
    }

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        Ok(v.to_string())
    }

    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        Ok(v)
    }
}