ssi_core/
one_or_many.rs

1use std::marker::PhantomData;
2
3use serde::{Deserialize, Serialize};
4
5/// One or many.
6///
7/// Serializes/deserializes into/from either a value, or an array of values.
8#[derive(Debug, Serialize, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9#[serde(untagged)]
10pub enum OneOrMany<T> {
11    /// A single value.
12    One(T),
13
14    /// An array of values.
15    Many(Vec<T>),
16}
17
18impl<T> Default for OneOrMany<T> {
19    fn default() -> Self {
20        Self::Many(Vec::new())
21    }
22}
23
24impl<T> OneOrMany<T> {
25    pub fn any<F>(&self, f: F) -> bool
26    where
27        F: Fn(&T) -> bool,
28    {
29        match self {
30            Self::One(value) => f(value),
31            Self::Many(values) => values.iter().any(f),
32        }
33    }
34
35    pub fn len(&self) -> usize {
36        match self {
37            Self::One(_) => 1,
38            Self::Many(values) => values.len(),
39        }
40    }
41
42    pub fn is_empty(&self) -> bool {
43        match self {
44            Self::One(_) => false,
45            Self::Many(values) => values.is_empty(),
46        }
47    }
48
49    pub fn contains(&self, x: &T) -> bool
50    where
51        T: PartialEq<T>,
52    {
53        match self {
54            Self::One(value) => x == value,
55            Self::Many(values) => values.contains(x),
56        }
57    }
58
59    pub fn as_slice(&self) -> &[T] {
60        match self {
61            Self::One(t) => std::slice::from_ref(t),
62            Self::Many(l) => l.as_slice(),
63        }
64    }
65
66    pub fn first(&self) -> Option<&T> {
67        match self {
68            Self::One(value) => Some(value),
69            Self::Many(values) => {
70                if !values.is_empty() {
71                    Some(&values[0])
72                } else {
73                    None
74                }
75            }
76        }
77    }
78
79    pub fn to_single(&self) -> Option<&T> {
80        match self {
81            Self::One(value) => Some(value),
82            Self::Many(values) => {
83                if values.len() == 1 {
84                    Some(&values[0])
85                } else {
86                    None
87                }
88            }
89        }
90    }
91
92    pub fn to_single_mut(&mut self) -> Option<&mut T> {
93        match self {
94            Self::One(value) => Some(value),
95            Self::Many(values) => {
96                if values.len() == 1 {
97                    Some(&mut values[0])
98                } else {
99                    None
100                }
101            }
102        }
103    }
104
105    pub fn into_single(self) -> Option<T> {
106        match self {
107            Self::One(value) => Some(value),
108            Self::Many(values) => {
109                let mut it = values.into_iter();
110                let value = it.next()?;
111                if it.next().is_none() {
112                    Some(value)
113                } else {
114                    None
115                }
116            }
117        }
118    }
119
120    pub fn into_vec(self) -> Vec<T> {
121        match self {
122            Self::One(t) => vec![t],
123            Self::Many(v) => v,
124        }
125    }
126}
127
128// consuming iterator
129impl<T> IntoIterator for OneOrMany<T> {
130    type Item = T;
131    type IntoIter = std::vec::IntoIter<Self::Item>;
132
133    fn into_iter(self) -> Self::IntoIter {
134        match self {
135            Self::One(value) => vec![value].into_iter(),
136            Self::Many(values) => values.into_iter(),
137        }
138    }
139}
140
141// non-consuming iterator
142impl<'a, T> IntoIterator for &'a OneOrMany<T> {
143    type Item = &'a T;
144    type IntoIter = std::vec::IntoIter<Self::Item>;
145
146    fn into_iter(self) -> Self::IntoIter {
147        match self {
148            OneOrMany::One(value) => vec![value].into_iter(),
149            OneOrMany::Many(values) => values.iter().collect::<Vec<Self::Item>>().into_iter(),
150        }
151    }
152}
153
154impl<'de, T> Deserialize<'de> for OneOrMany<T>
155where
156    T: Deserialize<'de>,
157{
158    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
159    where
160        D: serde::de::Deserializer<'de>,
161    {
162        deserializer.deserialize_any(Visitor(PhantomData))
163    }
164}
165
166struct Visitor<T>(PhantomData<T>);
167
168impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
169where
170    T: Deserialize<'de>,
171{
172    type Value = OneOrMany<T>;
173
174    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
175        write!(formatter, "one or more values")
176    }
177
178    fn visit_unit<E>(self) -> Result<Self::Value, E>
179    where
180        E: serde::de::Error,
181    {
182        T::deserialize(serde::de::value::UnitDeserializer::new()).map(OneOrMany::One)
183    }
184
185    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
186    where
187        E: serde::de::Error,
188    {
189        T::deserialize(serde::de::value::BoolDeserializer::new(v)).map(OneOrMany::One)
190    }
191
192    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
193    where
194        E: serde::de::Error,
195    {
196        T::deserialize(serde::de::value::U8Deserializer::new(v)).map(OneOrMany::One)
197    }
198
199    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
200    where
201        E: serde::de::Error,
202    {
203        T::deserialize(serde::de::value::U16Deserializer::new(v)).map(OneOrMany::One)
204    }
205
206    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
207    where
208        E: serde::de::Error,
209    {
210        T::deserialize(serde::de::value::U32Deserializer::new(v)).map(OneOrMany::One)
211    }
212
213    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
214    where
215        E: serde::de::Error,
216    {
217        T::deserialize(serde::de::value::U64Deserializer::new(v)).map(OneOrMany::One)
218    }
219
220    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
221    where
222        E: serde::de::Error,
223    {
224        T::deserialize(serde::de::value::U128Deserializer::new(v)).map(OneOrMany::One)
225    }
226
227    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
228    where
229        E: serde::de::Error,
230    {
231        T::deserialize(serde::de::value::I8Deserializer::new(v)).map(OneOrMany::One)
232    }
233
234    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
235    where
236        E: serde::de::Error,
237    {
238        T::deserialize(serde::de::value::I16Deserializer::new(v)).map(OneOrMany::One)
239    }
240
241    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
242    where
243        E: serde::de::Error,
244    {
245        T::deserialize(serde::de::value::I32Deserializer::new(v)).map(OneOrMany::One)
246    }
247
248    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
249    where
250        E: serde::de::Error,
251    {
252        T::deserialize(serde::de::value::I64Deserializer::new(v)).map(OneOrMany::One)
253    }
254
255    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
256    where
257        E: serde::de::Error,
258    {
259        T::deserialize(serde::de::value::I128Deserializer::new(v)).map(OneOrMany::One)
260    }
261
262    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
263    where
264        E: serde::de::Error,
265    {
266        T::deserialize(serde::de::value::F32Deserializer::new(v)).map(OneOrMany::One)
267    }
268
269    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
270    where
271        E: serde::de::Error,
272    {
273        T::deserialize(serde::de::value::F64Deserializer::new(v)).map(OneOrMany::One)
274    }
275
276    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
277    where
278        E: serde::de::Error,
279    {
280        T::deserialize(serde::de::value::CharDeserializer::new(v)).map(OneOrMany::One)
281    }
282
283    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
284    where
285        E: serde::de::Error,
286    {
287        T::deserialize(serde::de::value::BytesDeserializer::new(v)).map(OneOrMany::One)
288    }
289
290    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
291    where
292        E: serde::de::Error,
293    {
294        T::deserialize(serde::de::value::BorrowedBytesDeserializer::new(v)).map(OneOrMany::One)
295    }
296
297    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
298    where
299        E: serde::de::Error,
300    {
301        T::deserialize(serde::de::value::BytesDeserializer::new(&v)).map(OneOrMany::One)
302    }
303
304    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
305    where
306        E: serde::de::Error,
307    {
308        T::deserialize(serde::de::value::StrDeserializer::new(v)).map(OneOrMany::One)
309    }
310
311    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
312    where
313        E: serde::de::Error,
314    {
315        T::deserialize(serde::de::value::BorrowedStrDeserializer::new(v)).map(OneOrMany::One)
316    }
317
318    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
319    where
320        E: serde::de::Error,
321    {
322        T::deserialize(serde::de::value::StringDeserializer::new(v)).map(OneOrMany::One)
323    }
324
325    fn visit_none<E>(self) -> Result<Self::Value, E>
326    where
327        E: serde::de::Error,
328    {
329        T::deserialize(NoneDeserializer::<T, E>(PhantomData)).map(OneOrMany::One)
330    }
331
332    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
333    where
334        D: serde::de::Deserializer<'de>,
335    {
336        T::deserialize(SomeDeserializer::<T, D>(deserializer, PhantomData)).map(OneOrMany::One)
337    }
338
339    fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
340    where
341        A: serde::de::MapAccess<'de>,
342    {
343        T::deserialize(serde::de::value::MapAccessDeserializer::new(map)).map(OneOrMany::One)
344    }
345
346    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
347    where
348        A: serde::de::EnumAccess<'de>,
349    {
350        T::deserialize(serde::de::value::EnumAccessDeserializer::new(data)).map(OneOrMany::One)
351    }
352
353    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
354    where
355        D: serde::de::Deserializer<'de>,
356    {
357        T::deserialize(NewtypeStructDeserializer::<T, D>(deserializer, PhantomData))
358            .map(OneOrMany::One)
359    }
360
361    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
362    where
363        A: serde::de::SeqAccess<'de>,
364    {
365        let mut many = Vec::new();
366
367        while let Some(t) = seq.next_element::<T>()? {
368            many.push(t);
369        }
370
371        Ok(OneOrMany::Many(many))
372    }
373}
374
375struct NoneDeserializer<T, E>(PhantomData<(T, E)>);
376
377impl<'de, T, E> serde::de::Deserializer<'de> for NoneDeserializer<T, E>
378where
379    T: Deserialize<'de>,
380    E: serde::de::Error,
381{
382    type Error = E;
383
384    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
385    where
386        V: serde::de::Visitor<'de>,
387    {
388        visitor.visit_none()
389    }
390
391    serde::forward_to_deserialize_any! {
392        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
393        bytes byte_buf option unit unit_struct newtype_struct seq tuple
394        tuple_struct map struct enum identifier ignored_any
395    }
396}
397
398struct SomeDeserializer<T, D>(D, PhantomData<T>);
399
400impl<'de, T, D> serde::de::Deserializer<'de> for SomeDeserializer<T, D>
401where
402    T: Deserialize<'de>,
403    D: serde::de::Deserializer<'de>,
404{
405    type Error = D::Error;
406
407    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
408    where
409        V: serde::de::Visitor<'de>,
410    {
411        visitor.visit_some(self.0)
412    }
413
414    serde::forward_to_deserialize_any! {
415        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
416        bytes byte_buf option unit unit_struct newtype_struct seq tuple
417        tuple_struct map struct enum identifier ignored_any
418    }
419}
420
421struct NewtypeStructDeserializer<T, D>(D, PhantomData<T>);
422
423impl<'de, T, D> serde::de::Deserializer<'de> for NewtypeStructDeserializer<T, D>
424where
425    T: Deserialize<'de>,
426    D: serde::de::Deserializer<'de>,
427{
428    type Error = D::Error;
429
430    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
431    where
432        V: serde::de::Visitor<'de>,
433    {
434        visitor.visit_newtype_struct(self.0)
435    }
436
437    serde::forward_to_deserialize_any! {
438        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
439        bytes byte_buf option unit unit_struct newtype_struct seq tuple
440        tuple_struct map struct enum identifier ignored_any
441    }
442}
443
444/// One or many reference(s).
445#[derive(Debug, Serialize, Clone, PartialEq, Eq)]
446#[serde(untagged)]
447pub enum OneOrManyRef<'a, T> {
448    One(&'a T),
449    Many(&'a [T]),
450}
451
452impl<'a, T> OneOrManyRef<'a, T> {
453    pub fn from_slice(s: &'a [T]) -> Self {
454        match s {
455            [t] => Self::One(t),
456            _ => Self::Many(s),
457        }
458    }
459
460    pub fn is_empty(&self) -> bool {
461        matches!(self, Self::Many([]))
462    }
463}
ssi_core/one_or_many.rs

ssi_core/
one_or_many.rs
