protobuf/
singular.rs

1use std::default::Default;
2use std::fmt;
3use std::hash::Hash;
4use std::hash::Hasher;
5use std::mem;
6use std::option;
7
8#[cfg(feature = "with-serde")]
9use serde;
10
11use crate::clear::Clear;
12
13/// Like `Option<T>`, but keeps the actual element on `clear`.
14pub struct SingularField<T> {
15    value: T,
16    set: bool,
17}
18
19/// Like `Option<Box<T>>`, but keeps the actual element on `clear`.
20pub struct SingularPtrField<T> {
21    value: Option<Box<T>>,
22    set: bool,
23}
24
25impl<T> SingularField<T> {
26    /// Construct this object from given value.
27    #[inline]
28    pub fn some(value: T) -> SingularField<T> {
29        SingularField {
30            value: value,
31            set: true,
32        }
33    }
34
35    /// True iff this object contains data.
36    #[inline]
37    pub fn is_some(&self) -> bool {
38        self.set
39    }
40
41    /// True iff this object contains no data.
42    #[inline]
43    pub fn is_none(&self) -> bool {
44        !self.is_some()
45    }
46
47    /// Convert this object into `Option`.
48    #[inline]
49    pub fn into_option(self) -> Option<T> {
50        if self.set {
51            Some(self.value)
52        } else {
53            None
54        }
55    }
56
57    /// View data as `Option`.
58    #[inline]
59    pub fn as_ref<'a>(&'a self) -> Option<&'a T> {
60        if self.set {
61            Some(&self.value)
62        } else {
63            None
64        }
65    }
66
67    /// View data as mutable `Option`.
68    #[inline]
69    pub fn as_mut<'a>(&'a mut self) -> Option<&'a mut T> {
70        if self.set {
71            Some(&mut self.value)
72        } else {
73            None
74        }
75    }
76
77    /// Unwrap data as reference.
78    #[inline]
79    pub fn unwrap_ref<'a>(&'a self) -> &'a T {
80        self.as_ref().unwrap()
81    }
82
83    /// Unwrap data as mutable reference.
84    #[inline]
85    pub fn unwrap_mut_ref<'a>(&'a mut self) -> &'a mut T {
86        self.as_mut().unwrap()
87    }
88
89    /// Unwrap data, panic if not set.
90    #[inline]
91    pub fn unwrap(self) -> T {
92        if self.set {
93            self.value
94        } else {
95            panic!();
96        }
97    }
98
99    /// Unwrap data or return given default value.
100    #[inline]
101    pub fn unwrap_or(self, def: T) -> T {
102        if self.set {
103            self.value
104        } else {
105            def
106        }
107    }
108
109    /// Unwrap data or return given default value.
110    #[inline]
111    pub fn unwrap_or_else<F>(self, f: F) -> T
112    where
113        F: FnOnce() -> T,
114    {
115        if self.set {
116            self.value
117        } else {
118            f()
119        }
120    }
121
122    /// Apply a function to contained element and store result in new `SingularPtrField`.
123    #[inline]
124    pub fn map<U, F>(self, f: F) -> SingularPtrField<U>
125    where
126        F: FnOnce(T) -> U,
127    {
128        SingularPtrField::from_option(self.into_option().map(f))
129    }
130
131    /// View as iterator over references.
132    #[inline]
133    pub fn iter<'a>(&'a self) -> option::IntoIter<&'a T> {
134        self.as_ref().into_iter()
135    }
136
137    /// View as iterator over mutable references.
138    #[inline]
139    pub fn mut_iter<'a>(&'a mut self) -> option::IntoIter<&'a mut T> {
140        self.as_mut().into_iter()
141    }
142
143    /// Clear this object.
144    /// Note, contained object destructor is not called, so allocated memory could be reused.
145    #[inline]
146    pub fn clear(&mut self) {
147        self.set = false;
148    }
149}
150
151impl<T: Default> SingularField<T> {
152    /// Construct a `SingularField` with no data.
153    #[inline]
154    pub fn none() -> SingularField<T> {
155        SingularField {
156            value: Default::default(),
157            set: false,
158        }
159    }
160
161    /// Construct `SingularField` from `Option`.
162    #[inline]
163    pub fn from_option(option: Option<T>) -> SingularField<T> {
164        match option {
165            Some(x) => SingularField::some(x),
166            None => SingularField::none(),
167        }
168    }
169
170    /// Return data as option, clear this object.
171    #[inline]
172    pub fn take(&mut self) -> Option<T> {
173        if self.set {
174            self.set = false;
175            Some(mem::replace(&mut self.value, Default::default()))
176        } else {
177            None
178        }
179    }
180}
181
182impl<T> SingularPtrField<T> {
183    /// Construct `SingularPtrField` from given object.
184    #[inline]
185    pub fn some(value: T) -> SingularPtrField<T> {
186        SingularPtrField {
187            value: Some(Box::new(value)),
188            set: true,
189        }
190    }
191
192    /// Construct an empty `SingularPtrField`.
193    #[inline]
194    pub fn none() -> SingularPtrField<T> {
195        SingularPtrField {
196            value: None,
197            set: false,
198        }
199    }
200
201    /// Construct `SingularPtrField` from optional.
202    #[inline]
203    pub fn from_option(option: Option<T>) -> SingularPtrField<T> {
204        match option {
205            Some(x) => SingularPtrField::some(x),
206            None => SingularPtrField::none(),
207        }
208    }
209
210    /// True iff this object contains data.
211    #[inline]
212    pub fn is_some(&self) -> bool {
213        self.set
214    }
215
216    /// True iff this object contains no data.
217    #[inline]
218    pub fn is_none(&self) -> bool {
219        !self.is_some()
220    }
221
222    /// Convert into `Option<T>`.
223    #[inline]
224    pub fn into_option(self) -> Option<T> {
225        if self.set {
226            Some(*self.value.unwrap())
227        } else {
228            None
229        }
230    }
231
232    /// View data as reference option.
233    #[inline]
234    pub fn as_ref<'a>(&'a self) -> Option<&'a T> {
235        if self.set {
236            Some(&**self.value.as_ref().unwrap())
237        } else {
238            None
239        }
240    }
241
242    /// View data as mutable reference option.
243    #[inline]
244    pub fn as_mut<'a>(&'a mut self) -> Option<&'a mut T> {
245        if self.set {
246            Some(&mut **self.value.as_mut().unwrap())
247        } else {
248            None
249        }
250    }
251
252    /// Get data as reference.
253    /// Panics if empty.
254    #[inline]
255    pub fn get_ref<'a>(&'a self) -> &'a T {
256        self.as_ref().unwrap()
257    }
258
259    /// Get data as mutable reference.
260    /// Panics if empty.
261    #[inline]
262    pub fn get_mut_ref<'a>(&'a mut self) -> &'a mut T {
263        self.as_mut().unwrap()
264    }
265
266    /// Take the data.
267    /// Panics if empty
268    #[inline]
269    pub fn unwrap(self) -> T {
270        if self.set {
271            *self.value.unwrap()
272        } else {
273            panic!();
274        }
275    }
276
277    /// Take the data or return supplied default element if empty.
278    #[inline]
279    pub fn unwrap_or(self, def: T) -> T {
280        if self.set {
281            *self.value.unwrap()
282        } else {
283            def
284        }
285    }
286
287    /// Take the data or return supplied default element if empty.
288    #[inline]
289    pub fn unwrap_or_else<F>(self, f: F) -> T
290    where
291        F: FnOnce() -> T,
292    {
293        if self.set {
294            *self.value.unwrap()
295        } else {
296            f()
297        }
298    }
299
300    /// Apply given function to contained data to construct another `SingularPtrField`.
301    /// Returns empty `SingularPtrField` if this object is empty.
302    #[inline]
303    pub fn map<U, F>(self, f: F) -> SingularPtrField<U>
304    where
305        F: FnOnce(T) -> U,
306    {
307        SingularPtrField::from_option(self.into_option().map(f))
308    }
309
310    /// View data as iterator.
311    #[inline]
312    pub fn iter<'a>(&'a self) -> option::IntoIter<&'a T> {
313        self.as_ref().into_iter()
314    }
315
316    /// View data as mutable iterator.
317    #[inline]
318    pub fn mut_iter<'a>(&'a mut self) -> option::IntoIter<&'a mut T> {
319        self.as_mut().into_iter()
320    }
321
322    /// Take data as option, leaving this object empty.
323    #[inline]
324    pub fn take(&mut self) -> Option<T> {
325        if self.set {
326            self.set = false;
327            Some(*self.value.take().unwrap())
328        } else {
329            None
330        }
331    }
332
333    /// Clear this object, but do not call destructor of underlying data.
334    #[inline]
335    pub fn clear(&mut self) {
336        self.set = false;
337    }
338}
339
340impl<T: Default + Clear> SingularField<T> {
341    /// Get contained data, consume self. Return default value for type if this is empty.
342    #[inline]
343    pub fn unwrap_or_default(mut self) -> T {
344        if !self.set {
345            self.value.clear();
346        }
347        self.value
348    }
349
350    /// Initialize this object with default value.
351    /// This operation can be more efficient then construction of clear element,
352    /// because it may reuse previously contained object.
353    #[inline]
354    pub fn set_default<'a>(&'a mut self) -> &'a mut T {
355        self.set = true;
356        self.value.clear();
357        &mut self.value
358    }
359}
360
361impl<T: Default + Clear> SingularPtrField<T> {
362    /// Get contained data, consume self. Return default value for type if this is empty.
363    #[inline]
364    pub fn unwrap_or_default(mut self) -> T {
365        if self.set {
366            self.unwrap()
367        } else if self.value.is_some() {
368            self.value.clear();
369            *self.value.unwrap()
370        } else {
371            Default::default()
372        }
373    }
374
375    /// Initialize this object with default value.
376    /// This operation can be more efficient then construction of clear element,
377    /// because it may reuse previously contained object.
378    #[inline]
379    pub fn set_default<'a>(&'a mut self) -> &'a mut T {
380        self.set = true;
381        if self.value.is_some() {
382            self.value.as_mut().unwrap().clear();
383        } else {
384            self.value = Some(Default::default());
385        }
386        self.as_mut().unwrap()
387    }
388}
389
390impl<T: Default> Default for SingularField<T> {
391    #[inline]
392    fn default() -> SingularField<T> {
393        SingularField::none()
394    }
395}
396
397impl<T> Default for SingularPtrField<T> {
398    #[inline]
399    fn default() -> SingularPtrField<T> {
400        SingularPtrField::none()
401    }
402}
403
404impl<T: Default> From<Option<T>> for SingularField<T> {
405    fn from(o: Option<T>) -> Self {
406        SingularField::from_option(o)
407    }
408}
409
410impl<T> From<Option<T>> for SingularPtrField<T> {
411    fn from(o: Option<T>) -> Self {
412        SingularPtrField::from_option(o)
413    }
414}
415
416impl<T: Clone + Default> Clone for SingularField<T> {
417    #[inline]
418    fn clone(&self) -> SingularField<T> {
419        if self.set {
420            SingularField::some(self.value.clone())
421        } else {
422            SingularField::none()
423        }
424    }
425}
426
427impl<T: Clone> Clone for SingularPtrField<T> {
428    #[inline]
429    fn clone(&self) -> SingularPtrField<T> {
430        if self.set {
431            SingularPtrField::some(self.as_ref().unwrap().clone())
432        } else {
433            SingularPtrField::none()
434        }
435    }
436}
437
438impl<T: fmt::Debug> fmt::Debug for SingularField<T> {
439    #[inline]
440    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
441        if self.is_some() {
442            write!(f, "Some({:?})", *self.as_ref().unwrap())
443        } else {
444            write!(f, "None")
445        }
446    }
447}
448
449impl<T: fmt::Debug> fmt::Debug for SingularPtrField<T> {
450    #[inline]
451    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
452        if self.is_some() {
453            write!(f, "Some({:?})", *self.as_ref().unwrap())
454        } else {
455            write!(f, "None")
456        }
457    }
458}
459
460impl<T: PartialEq> PartialEq for SingularField<T> {
461    #[inline]
462    fn eq(&self, other: &SingularField<T>) -> bool {
463        self.as_ref() == other.as_ref()
464    }
465}
466
467impl<T: Eq> Eq for SingularField<T> {}
468
469impl<T: PartialEq> PartialEq for SingularPtrField<T> {
470    #[inline]
471    fn eq(&self, other: &SingularPtrField<T>) -> bool {
472        self.as_ref() == other.as_ref()
473    }
474}
475
476impl<T: Eq> Eq for SingularPtrField<T> {}
477
478impl<T: Hash> Hash for SingularField<T> {
479    fn hash<H: Hasher>(&self, state: &mut H) {
480        self.as_ref().hash(state);
481    }
482}
483
484impl<T: Hash> Hash for SingularPtrField<T> {
485    fn hash<H: Hasher>(&self, state: &mut H) {
486        self.as_ref().hash(state);
487    }
488}
489
490impl<'a, T> IntoIterator for &'a SingularField<T> {
491    type Item = &'a T;
492    type IntoIter = option::IntoIter<&'a T>;
493
494    fn into_iter(self) -> option::IntoIter<&'a T> {
495        self.iter()
496    }
497}
498
499impl<'a, T> IntoIterator for &'a SingularPtrField<T> {
500    type Item = &'a T;
501    type IntoIter = option::IntoIter<&'a T>;
502
503    fn into_iter(self) -> option::IntoIter<&'a T> {
504        self.iter()
505    }
506}
507
508#[cfg(feature = "with-serde")]
509impl<T: serde::Serialize> serde::Serialize for SingularPtrField<T> {
510    fn serialize<S>(
511        &self,
512        serializer: S,
513    ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
514    where
515        S: serde::Serializer,
516    {
517        self.as_ref().serialize(serializer)
518    }
519}
520
521#[cfg(feature = "with-serde")]
522impl<T: serde::Serialize> serde::Serialize for SingularField<T> {
523    fn serialize<S>(
524        &self,
525        serializer: S,
526    ) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>
527    where
528        S: serde::Serializer,
529    {
530        self.as_ref().serialize(serializer)
531    }
532}
533
534#[cfg(feature = "with-serde")]
535impl<'de, T: serde::Deserialize<'de>> serde::Deserialize<'de> for SingularPtrField<T> {
536    fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error>
537    where
538        D: serde::Deserializer<'de>,
539    {
540        Option::deserialize(deserializer).map(SingularPtrField::from_option)
541    }
542}
543
544#[cfg(feature = "with-serde")]
545impl<'de, T: serde::Deserialize<'de> + Default> serde::Deserialize<'de> for SingularField<T> {
546    fn deserialize<D>(deserializer: D) -> Result<Self, <D as serde::Deserializer<'de>>::Error>
547    where
548        D: serde::Deserializer<'de>,
549    {
550        Option::deserialize(deserializer).map(SingularField::from_option)
551    }
552}
553
554#[cfg(test)]
555mod test {
556    use super::SingularField;
557    use crate::clear::Clear;
558
559    #[test]
560    fn test_set_default_clears() {
561        #[derive(Default)]
562        struct Foo {
563            b: isize,
564        }
565
566        impl Clear for Foo {
567            fn clear(&mut self) {
568                self.b = 0;
569            }
570        }
571
572        let mut x = SingularField::some(Foo { b: 10 });
573        x.clear();
574        x.set_default();
575        assert_eq!(0, x.as_ref().unwrap().b);
576
577        x.as_mut().unwrap().b = 11;
578        // without clear
579        x.set_default();
580        assert_eq!(0, x.as_ref().unwrap().b);
581    }
582
583    #[test]
584    fn unwrap_or_default() {
585        assert_eq!(
586            "abc",
587            SingularField::some("abc".to_owned()).unwrap_or_default()
588        );
589        assert_eq!("", SingularField::<String>::none().unwrap_or_default());
590        let mut some = SingularField::some("abc".to_owned());
591        some.clear();
592        assert_eq!("", some.unwrap_or_default());
593    }
594}
protobuf/singular.rs

protobuf/
singular.rs
