compris 0.0.11

Composite Primitive Schema (CPS) for Rust
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

use super::variant::*;

use std::{mem::*, slice, vec};

//
// VariantIterator
//

/// If the variant is a [List](super::list::List), iterates its items. Otherwise just iterates
/// itself once.
pub enum VariantIterator<'own, AnnotatedT> {
    /// Iterator.
    Iterator(slice::Iter<'own, Variant<AnnotatedT>>),

    /// Variant.
    Variant(Option<&'own Variant<AnnotatedT>>),
}

impl<'own, AnnotatedT> VariantIterator<'own, AnnotatedT> {
    /// Constructor.
    pub fn new(variant: &'own Variant<AnnotatedT>) -> Self {
        match variant {
            Variant::List(list) => Self::Iterator(list.inner.iter()),
            _ => Self::Variant(Some(variant)),
        }
    }
}

impl<'own, AnnotatedT> Iterator for VariantIterator<'own, AnnotatedT> {
    type Item = &'own Variant<AnnotatedT>;

    fn next(&mut self) -> Option<Self::Item> {
        match self {
            Self::Iterator(iter) => iter.next(),
            Self::Variant(variant) => take(variant),
        }
    }
}

//
// IntoVariantIterator
//

/// If the variant is a [List](super::list::List), iterates its items. Otherwise just iterates
/// itself once.
pub enum IntoVariantIterator<AnnotatedT> {
    /// Iterator.
    Iterator(vec::IntoIter<Variant<AnnotatedT>>),

    /// Variant.
    Variant(Option<Variant<AnnotatedT>>),
}

impl<AnnotatedT> IntoVariantIterator<AnnotatedT> {
    /// Constructor.
    pub fn new(variant: Variant<AnnotatedT>) -> Self {
        match variant {
            Variant::List(list) => Self::Iterator(list.inner.into_iter()),
            _ => Self::Variant(Some(variant)),
        }
    }
}

impl<AnnotatedT> Iterator for IntoVariantIterator<AnnotatedT> {
    type Item = Variant<AnnotatedT>;

    fn next(&mut self) -> Option<Self::Item> {
        match self {
            Self::Iterator(iter) => iter.next(),
            Self::Variant(variant) => take(variant),
        }
    }
}