associated_list 0.2.0

An associated list, for cases when the key implements neither Hash nor Ord.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Iterators for an [`AssocList`](crate::AssocList) where using the [`Vec`](alloc::vec::Vec)-Iterators directly was not possible.

use core::{
    marker::PhantomData,
    slice::{self, Iter},
};

use alloc::vec::{self, IntoIter};

use crate::allocator::Allocator;

/// Draining Iterator for an [`AssocList`](crate::AssocList).
/// It is created by the [`drain`](crate::AssocList::drain)-method.
#[derive(Debug)]
#[must_use]
pub struct Drain<'a, K, V, A: Allocator> {
    #[cfg(feature = "allocator_api")]
    /// The Iterator from a [`Vec`](alloc::vec::Vec) the implementation is based on.
    pub(crate) iter: vec::Drain<'a, (K, V), A>,
    #[cfg(not(feature = "allocator_api"))]
    /// The Iterator from a [`Vec`](alloc::vec::Vec) the implementation is based on.
    pub(crate) iter: vec::Drain<'a, (K, V)>,
    /// PhantomData
    pub(crate) phantom: PhantomData<A>,
}

impl<K, V, A: Allocator> Iterator for Drain<'_, K, V, A> {
    type Item = (K, V);

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next()
    }
}

// following convention for Iterator-names
#[allow(clippy::module_name_repetitions)]
/// Mutable Iterator for an [`AssocList`](crate::AssocList).
/// It is created by the [`iter_mut`](crate::AssocList::iter_mut)-method.
#[derive(Debug)]
#[must_use]
pub struct IterMut<'a, K, V>(pub(crate) slice::IterMut<'a, (K, V)>);

impl<'a, K, V> Iterator for IterMut<'a, K, V> {
    type Item = (&'a K, &'a mut V);

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(key, value)| (&*key, value))
    }
}

/// Iterator for the keys of an [`AssocList`](crate::AssocList).
/// It is created by the [`keys`](crate::AssocList::keys)-method.
#[derive(Debug)]
#[must_use]
pub struct Keys<'a, K, V>(pub(crate) Iter<'a, (K, V)>);

impl<'a, K, V> Iterator for Keys<'a, K, V> {
    type Item = &'a K;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(key, _value)| key)
    }
}

/// Consuming Iterator for the keys of an [`AssocList`](crate::AssocList).
/// It is created by the [`into_keys`](crate::AssocList::into_keys)-method.
#[derive(Debug)]
#[must_use]
pub struct IntoKeys<K, V, A: Allocator> {
    #[cfg(feature = "allocator_api")]
    /// The Iterator from a [`Vec`](alloc::vec::Vec) the implementation is based on.
    pub(crate) iter: IntoIter<(K, V), A>,
    #[cfg(not(feature = "allocator_api"))]
    /// The Iterator from a [`Vec`](alloc::vec::Vec) the implementation is based on.
    pub(crate) iter: IntoIter<(K, V)>,
    /// PhantomData
    pub(crate) phantom: PhantomData<A>,
}

impl<K, V, A: Allocator> Iterator for IntoKeys<K, V, A> {
    type Item = K;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(|(key, _value)| key)
    }
}

/// Iterator for the values of an [`AssocList`](crate::AssocList).
/// It is created by the [`values`](crate::AssocList::values)-method.
#[derive(Debug)]
#[must_use]
pub struct Values<'a, K, V>(pub(crate) Iter<'a, (K, V)>);

impl<'a, K, V> Iterator for Values<'a, K, V> {
    type Item = &'a V;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(_key, value)| value)
    }
}

/// Iterator for the mutable values of an [`AssocList`](crate::AssocList).
/// It is created by the [`values_mut`](crate::AssocList::values_mut)-method.
#[derive(Debug)]
#[must_use]
pub struct ValuesMut<'a, K, V>(pub(crate) slice::IterMut<'a, (K, V)>);

impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
    type Item = &'a mut V;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.0.next().map(|(_key, value)| value)
    }
}

/// Consuming Iterator for the values of an [`AssocList`](crate::AssocList).
/// It is created by the [`into_values`](crate::AssocList::into_values)-method.
#[derive(Debug)]
#[must_use]
pub struct IntoValues<K, V, A: Allocator> {
    #[cfg(feature = "allocator_api")]
    /// The Iterator from a [`Vec`](alloc::vec::Vec) the implementation is based on.
    pub(crate) iter: IntoIter<(K, V), A>,
    #[cfg(not(feature = "allocator_api"))]
    /// The Iterator from a [`Vec`](alloc::vec::Vec) the implementation is based on.
    pub(crate) iter: IntoIter<(K, V)>,
    /// PhantomData
    pub(crate) phantom: PhantomData<A>,
}

impl<K, V, A: Allocator> Iterator for IntoValues<K, V, A> {
    type Item = V;

    #[inline]
    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(|(_key, value)| value)
    }
}