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

use super::{super::normal::*, iterator::*};

use std::collections::*;

//
// KeyValuePairIteratorForHashMap
//

/// A [KeyValuePairIterator] for [HashMap].
///
/// It's just a simple wrapper.
pub struct KeyValuePairIteratorForHashMap<'own, AnnotatedT> {
    /// Inner iterator.
    pub inner: hash_map::Iter<'own, Variant<AnnotatedT>, Variant<AnnotatedT>>,
}

impl<'own, AnnotatedT> KeyValuePairIteratorForHashMap<'own, AnnotatedT> {
    /// Constructor.
    pub fn new(inner: hash_map::Iter<'own, Variant<AnnotatedT>, Variant<AnnotatedT>>) -> Self {
        Self { inner }
    }

    /// Constructor.
    pub fn new_for(map: &'own HashMap<Variant<AnnotatedT>, Variant<AnnotatedT>>) -> Self {
        Self::new(map.into_iter())
    }
}

impl<'own, AnnotatedT> KeyValuePairIterator<AnnotatedT> for KeyValuePairIteratorForHashMap<'own, AnnotatedT> {
    fn next(
        &mut self,
    ) -> Result<
        Option<(&'own Variant<AnnotatedT>, &'own Variant<AnnotatedT>)>,
        (MalformedError<AnnotatedT>, &Variant<AnnotatedT>),
    > {
        Ok(self.inner.next())
    }
}

//
// IntoKeyValuePairIteratorForHashMap
//

/// An [IntoKeyValuePairIterator] for [HashMap].
///
/// It's just a simple wrapper.
pub struct IntoKeyValuePairIteratorForHashMap<AnnotatedT> {
    /// Inner iterator.
    pub inner: hash_map::IntoIter<Variant<AnnotatedT>, Variant<AnnotatedT>>,
}

impl<AnnotatedT> IntoKeyValuePairIteratorForHashMap<AnnotatedT> {
    /// Constructor.
    pub fn new(inner: hash_map::IntoIter<Variant<AnnotatedT>, Variant<AnnotatedT>>) -> Self {
        Self { inner }
    }

    /// Constructor.
    pub fn new_for(map: HashMap<Variant<AnnotatedT>, Variant<AnnotatedT>>) -> Self {
        Self::new(map.into_iter())
    }
}

impl<AnnotatedT> IntoKeyValuePairIterator<AnnotatedT> for IntoKeyValuePairIteratorForHashMap<AnnotatedT> {
    fn next(
        &mut self,
    ) -> Result<Option<(Variant<AnnotatedT>, Variant<AnnotatedT>)>, (MalformedError<AnnotatedT>, Variant<AnnotatedT>)>
    {
        Ok(self.inner.next())
    }
}