g-string 0.1.1

Stack-allocated string type with generic configurations.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use serde::{
    Deserialize, Deserializer, Serialize, Serializer,
    de::{self, Visitor},
};

use crate::{GString, GStringError, Validator};
use core::{fmt, marker::PhantomData};

#[cfg(feature = "alloc")]
extern crate alloc;

#[cfg(feature = "alloc")]
use alloc::string::String;

impl<V: Validator, const MIN: usize, const MAX: usize, const ASCII_ONLY: bool> Serialize
    for GString<V, MIN, MAX, ASCII_ONLY>
{
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(self.as_str())
    }
}

struct GStringVisitor<V: Validator, const MIN: usize, const MAX: usize, const ASCII_ONLY: bool>(
    PhantomData<V>,
);

impl<'de, V, const MIN: usize, const MAX: usize, const ASCII_ONLY: bool> Visitor<'de>
    for GStringVisitor<V, MIN, MAX, ASCII_ONLY>
where
    V: Validator,
    GStringError<V::Err>: fmt::Display,
{
    type Value = GString<V, MIN, MAX, ASCII_ONLY>;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(
            formatter,
            "a string with length between {} and {}{}",
            MIN,
            MAX,
            if ASCII_ONLY { " (ASCII only)" } else { "" }
        )
    }

    fn visit_str<E: de::Error>(self, v: &str) -> Result<Self::Value, E> {
        GString::try_new(v).map_err(de::Error::custom)
    }

    #[cfg(feature = "alloc")]
    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        GString::try_from(v).map_err(de::Error::custom)
    }
}

impl<'de, V, const MIN: usize, const MAX: usize, const ASCII_ONLY: bool> Deserialize<'de>
    for GString<V, MIN, MAX, ASCII_ONLY>
where
    V: Validator,
    GStringError<V::Err>: fmt::Display,
{
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        deserializer.deserialize_str(GStringVisitor(PhantomData))
    }
}

// GSecret serde
#[cfg(feature = "secret")]
mod secret_serde {
    use crate::{GSecret, GStringError, Validator};
    use core::{fmt, marker::PhantomData};
    use serde::{
        Deserialize, Deserializer,
        de::{self, Visitor},
    };

    #[cfg(feature = "alloc")]
    extern crate alloc;

    #[cfg(feature = "alloc")]
    use alloc::string::String;

    struct GSecretVisitor<V: Validator, const MIN: usize, const MAX: usize, const ASCII_ONLY: bool>(
        PhantomData<V>,
    );

    impl<'de, V, const MIN: usize, const MAX: usize, const ASCII_ONLY: bool> Visitor<'de>
        for GSecretVisitor<V, MIN, MAX, ASCII_ONLY>
    where
        V: Validator,
        GStringError<V::Err>: fmt::Display,
    {
        type Value = GSecret<V, MIN, MAX, ASCII_ONLY>;

        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            write!(
                formatter,
                "a secret string between {} and {}{}",
                MIN,
                MAX,
                if ASCII_ONLY { " (ASCII only)" } else { "" }
            )
        }

        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            GSecret::try_new(v).map_err(de::Error::custom)
        }

        #[cfg(feature = "alloc")]
        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
        where
            E: de::Error,
        {
            GSecret::try_from(v).map_err(de::Error::custom)
        }
    }

    impl<'de, V, const MIN: usize, const MAX: usize, const ASCII_ONLY: bool> Deserialize<'de>
        for GSecret<V, MIN, MAX, ASCII_ONLY>
    where
        V: Validator,
        GStringError<V::Err>: fmt::Display,
    {
        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
        where
            D: Deserializer<'de>,
        {
            deserializer.deserialize_str(GSecretVisitor(PhantomData))
        }
    }
}