uri_template_core/
value.rs

1use alloc::borrow::Cow;
2use core::hash::Hash;
3
4mod scalar;
5mod values;
6pub use scalar::Scalar;
7pub use values::BTreeValues;
8#[cfg(feature = "std")]
9pub use values::HashValues;
10
11pub trait Values<'v, 's> {
12    fn var(&self, name: &str) -> Option<Cow<'_, Value<'v, 's>>>;
13}
14
15pub trait ToValue<'v, 's> {
16    fn to_value(&self) -> Value<'v, 's>;
17}
18impl<'v, 's: 'v, T> ToValue<'v, 's> for T
19where
20    T: Into<Value<'v, 's>> + Clone,
21{
22    #[inline]
23    fn to_value(&self) -> Value<'v, 's> {
24        self.clone().into()
25    }
26}
27
28#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
29pub enum Value<'v, 's: 'v> {
30    Scalar(Scalar<'v>),
31    List(Cow<'v, [Scalar<'s>]>),
32    /// An ordered associative array of key-value pairs
33    Keys(Cow<'v, [(Scalar<'s>, Scalar<'s>)]>),
34}
35
36impl Value<'_, '_> {
37    pub fn into_static(self) -> Value<'static, 'static> {
38        match self {
39            Self::Scalar(s) => Value::Scalar(s.into_static()),
40            Self::List(list) => Value::List(Cow::Owned(
41                list.into_owned()
42                    .into_iter()
43                    .map(|s| s.into_static())
44                    .collect(),
45            )),
46            Self::Keys(items) => Value::Keys(Cow::Owned(
47                items
48                    .into_owned()
49                    .into_iter()
50                    .map(|(k, v)| (k.into_static(), v.into_static()))
51                    .collect(),
52            )),
53        }
54    }
55
56    pub(crate) fn should_expand(&self) -> bool {
57        match self {
58            Self::Scalar(_) => true,
59            Self::List(s) => !s.is_empty(),
60            Self::Keys(items) => !items.is_empty(),
61        }
62    }
63}
64
65#[cfg(feature = "serde")]
66pub use serde_impl::deserialize_owned_value;
67
68#[cfg(feature = "serde")]
69mod serde_impl {
70    use alloc::borrow::Cow;
71    use core::marker::PhantomData;
72
73    use super::{Scalar, Value};
74    use serde::{Deserialize, de::Visitor};
75
76    pub fn deserialize_owned_value<'de, D>(
77        deserializer: D,
78    ) -> Result<Value<'static, 'static>, D::Error>
79    where
80        D: serde::Deserializer<'de>,
81    {
82        deserializer
83            .deserialize_any(ValueVisitor(PhantomData))
84            .map(move |v| v.into_static())
85    }
86
87    pub struct ScalarValueVisitor<'a>(PhantomData<&'a ()>);
88    impl<'de: 'a, 'a> Deserialize<'de> for Scalar<'a> {
89        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
90        where
91            D: serde::Deserializer<'de>,
92        {
93            deserializer.deserialize_any(ScalarValueVisitor(PhantomData))
94        }
95    }
96    impl<'de: 'a, 'a> Visitor<'de> for ScalarValueVisitor<'a> {
97        type Value = Scalar<'a>;
98
99        fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
100            formatter
101                .write_str("a string/number/boolean, list of value, or list of key-value pairs")
102        }
103
104        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
105        where
106            E: serde::de::Error,
107        {
108            Ok(Scalar(v.to_owned().into()))
109        }
110
111        fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
112        where
113            E: serde::de::Error,
114        {
115            Ok(Scalar(Cow::Borrowed(v)))
116        }
117
118        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
119        where
120            E: serde::de::Error,
121        {
122            Ok(Scalar(v.into()))
123        }
124
125        fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
126        where
127            E: serde::de::Error,
128        {
129            Ok(Scalar(Cow::Owned(v.to_string())))
130        }
131
132        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
133        where
134            E: serde::de::Error,
135        {
136            Ok(Scalar(v.to_string().into()))
137        }
138
139        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
140        where
141            E: serde::de::Error,
142        {
143            Ok(Scalar(v.to_string().into()))
144        }
145
146        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
147        where
148            E: serde::de::Error,
149        {
150            Ok(Scalar(v.to_string().into()))
151        }
152
153        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
154        where
155            E: serde::de::Error,
156        {
157            Ok(Scalar(v.to_string().into()))
158        }
159
160        fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
161        where
162            E: serde::de::Error,
163        {
164            Ok(Scalar(v.to_string().into()))
165        }
166    }
167
168    pub struct ValueVisitor<'v, 's: 'v>(PhantomData<(&'v (), &'s ())>);
169    impl<'de: 'v + 's, 'v, 's: 'v> Deserialize<'de> for Value<'v, 's> {
170        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
171        where
172            D: serde::Deserializer<'de>,
173        {
174            deserializer.deserialize_any(ValueVisitor(PhantomData))
175        }
176    }
177
178    impl<'de: 'v + 's, 'v, 's: 'v> Visitor<'de> for ValueVisitor<'v, 's> {
179        type Value = Value<'v, 'v>;
180        fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
181            formatter
182                .write_str("a string/number/boolean, list of value, or list of key-value pairs")
183        }
184
185        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
186        where
187            A: serde::de::SeqAccess<'de>,
188        {
189            let mut values = Vec::new();
190
191            while let Some(value) = seq.next_element::<Scalar<'v>>()? {
192                values.push(value);
193            }
194            Ok(Value::List(Cow::Owned(values)))
195        }
196
197        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
198        where
199            A: serde::de::MapAccess<'de>,
200        {
201            let mut items = Vec::new();
202            while let Some((key, value)) = map.next_entry::<Scalar<'v>, Scalar<'v>>()? {
203                items.push((key, value));
204            }
205            Ok(Value::Keys(Cow::Owned(items)))
206        }
207
208        // delegate to ScalarValueVisitor
209        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
210        where
211            E: serde::de::Error,
212        {
213            ScalarValueVisitor(PhantomData)
214                .visit_str(v)
215                .map(Value::Scalar)
216        }
217        fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
218        where
219            E: serde::de::Error,
220        {
221            ScalarValueVisitor(PhantomData)
222                .visit_string(v)
223                .map(Value::Scalar)
224        }
225        fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
226        where
227            E: serde::de::Error,
228        {
229            ScalarValueVisitor(PhantomData)
230                .visit_borrowed_str(v)
231                .map(Value::Scalar)
232        }
233        fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
234        where
235            E: serde::de::Error,
236        {
237            ScalarValueVisitor(PhantomData)
238                .visit_bool(v)
239                .map(Value::Scalar)
240        }
241        fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
242        where
243            E: serde::de::Error,
244        {
245            ScalarValueVisitor(PhantomData)
246                .visit_i64(v)
247                .map(Value::Scalar)
248        }
249        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
250        where
251            E: serde::de::Error,
252        {
253            ScalarValueVisitor(PhantomData)
254                .visit_i128(v)
255                .map(Value::Scalar)
256        }
257        fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
258        where
259            E: serde::de::Error,
260        {
261            ScalarValueVisitor(PhantomData)
262                .visit_u64(v)
263                .map(Value::Scalar)
264        }
265        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
266        where
267            E: serde::de::Error,
268        {
269            ScalarValueVisitor(PhantomData)
270                .visit_u128(v)
271                .map(Value::Scalar)
272        }
273        fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
274        where
275            E: serde::de::Error,
276        {
277            ScalarValueVisitor(PhantomData)
278                .visit_f64(v)
279                .map(Value::Scalar)
280        }
281    }
282}
uri_template_core/value.rs

uri_template_core/
value.rs
