1 #[cfg(has_std)]
2 #[macro_export]
3 /// Create an `IndexMap` from a list of key-value pairs
4 ///
5 /// ## Example
6 ///
7 /// ```
8 /// use indexmap::indexmap;
9 ///
10 /// let map = indexmap!{
11 ///     "a" => 1,
12 ///     "b" => 2,
13 /// };
14 /// assert_eq!(map["a"], 1);
15 /// assert_eq!(map["b"], 2);
16 /// assert_eq!(map.get("c"), None);
17 ///
18 /// // "a" is the first key
19 /// assert_eq!(map.keys().next(), Some(&"a"));
20 /// ```
21 macro_rules! indexmap {
22     (@single $($x:tt)*) => (());
23     (@count $($rest:expr),*) => (<[()]>::len(&[$($crate::indexmap!(@single $rest)),*]));
24 
25     ($($key:expr => $value:expr,)+) => { $crate::indexmap!($($key => $value),+) };
26     ($($key:expr => $value:expr),*) => {
27         {
28             let _cap = $crate::indexmap!(@count $($key),*);
29             let mut _map = $crate::IndexMap::with_capacity(_cap);
30             $(
31                 _map.insert($key, $value);
32             )*
33             _map
34         }
35     };
36 }
37 
38 #[cfg(has_std)]
39 #[macro_export]
40 /// Create an `IndexSet` from a list of values
41 ///
42 /// ## Example
43 ///
44 /// ```
45 /// use indexmap::indexset;
46 ///
47 /// let set = indexset!{
48 ///     "a",
49 ///     "b",
50 /// };
51 /// assert!(set.contains("a"));
52 /// assert!(set.contains("b"));
53 /// assert!(!set.contains("c"));
54 ///
55 /// // "a" is the first value
56 /// assert_eq!(set.iter().next(), Some(&"a"));
57 /// ```
58 macro_rules! indexset {
59     (@single $($x:tt)*) => (());
60     (@count $($rest:expr),*) => (<[()]>::len(&[$($crate::indexset!(@single $rest)),*]));
61 
62     ($($value:expr,)+) => { $crate::indexset!($($value),+) };
63     ($($value:expr),*) => {
64         {
65             let _cap = $crate::indexset!(@count $($value),*);
66             let mut _set = $crate::IndexSet::with_capacity(_cap);
67             $(
68                 _set.insert($value);
69             )*
70             _set
71         }
72     };
73 }
74 
75 // generate all the Iterator methods by just forwarding to the underlying
76 // self.iter and mapping its element.
77 macro_rules! iterator_methods {
78     // $map_elt is the mapping function from the underlying iterator's element
79     // same mapping function for both options and iterators
80     ($map_elt:expr) => {
81         fn next(&mut self) -> Option<Self::Item> {
82             self.iter.next().map($map_elt)
83         }
84 
85         fn size_hint(&self) -> (usize, Option<usize>) {
86             self.iter.size_hint()
87         }
88 
89         fn count(self) -> usize {
90             self.iter.len()
91         }
92 
93         fn nth(&mut self, n: usize) -> Option<Self::Item> {
94             self.iter.nth(n).map($map_elt)
95         }
96 
97         fn last(mut self) -> Option<Self::Item> {
98             self.next_back()
99         }
100 
101         fn collect<C>(self) -> C
102         where
103             C: FromIterator<Self::Item>,
104         {
105             // NB: forwarding this directly to standard iterators will
106             // allow it to leverage unstable traits like `TrustedLen`.
107             self.iter.map($map_elt).collect()
108         }
109     };
110 }
111 
112 macro_rules! double_ended_iterator_methods {
113     // $map_elt is the mapping function from the underlying iterator's element
114     // same mapping function for both options and iterators
115     ($map_elt:expr) => {
116         fn next_back(&mut self) -> Option<Self::Item> {
117             self.iter.next_back().map($map_elt)
118         }
119     };
120 }
121