      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

    #[cfg(has_std)]
    #[macro_export]
    /// Create an `IndexMap` from a list of key-value pairs
    ///
    /// ## Example
    ///
    /// ```
    /// use indexmap::indexmap;
    ///
    /// let map = indexmap!{
    ///     "a" => 1,
    ///     "b" => 2,
    /// };
    /// assert_eq!(map["a"], 1);
    /// assert_eq!(map["b"], 2);
    /// assert_eq!(map.get("c"), None);
    ///
    /// // "a" is the first key
    /// assert_eq!(map.keys().next(), Some(&"a"));
    /// ```
    macro_rules! indexmap {
        (@single $($x:tt)*) => (());
        (@count $($rest:expr),*) => (<[()]>::len(&[$($crate::indexmap!(@single $rest)),*]));

        ($($key:expr => $value:expr,)+) => { $crate::indexmap!($($key => $value),+) };
        ($($key:expr => $value:expr),*) => {
            {
                let _cap = $crate::indexmap!(@count $($key),*);
                let mut _map = $crate::IndexMap::with_capacity(_cap);
                $(
                    _map.insert($key, $value);
                )*
                _map
            }
        };
    }

    #[cfg(has_std)]
    #[macro_export]
    /// Create an `IndexSet` from a list of values
    ///
    /// ## Example
    ///
    /// ```
    /// use indexmap::indexset;
    ///
    /// let set = indexset!{
    ///     "a",
    ///     "b",
    /// };
    /// assert!(set.contains("a"));
    /// assert!(set.contains("b"));
    /// assert!(!set.contains("c"));
    ///
    /// // "a" is the first value
    /// assert_eq!(set.iter().next(), Some(&"a"));
    /// ```
    macro_rules! indexset {
        (@single $($x:tt)*) => (());
        (@count $($rest:expr),*) => (<[()]>::len(&[$($crate::indexset!(@single $rest)),*]));

        ($($value:expr,)+) => { $crate::indexset!($($value),+) };
        ($($value:expr),*) => {
            {
                let _cap = $crate::indexset!(@count $($value),*);
                let mut _set = $crate::IndexSet::with_capacity(_cap);
                $(
                    _set.insert($value);
                )*
                _set
            }
        };
    }

    // generate all the Iterator methods by just forwarding to the underlying
    // self.iter and mapping its element.
    macro_rules! iterator_methods {
        // $map_elt is the mapping function from the underlying iterator's element
        // same mapping function for both options and iterators
        ($map_elt:expr) => {
            fn next(&mut self) -> Option<Self::Item> {
                self.iter.next().map($map_elt)
            }

            fn size_hint(&self) -> (usize, Option<usize>) {
                self.iter.size_hint()
            }

            fn count(self) -> usize {
                self.iter.len()
            }

            fn nth(&mut self, n: usize) -> Option<Self::Item> {
                self.iter.nth(n).map($map_elt)
            }

            fn last(mut self) -> Option<Self::Item> {
                self.next_back()
            }

            fn collect<C>(self) -> C
            where
                C: FromIterator<Self::Item>,
            {
                // NB: forwarding this directly to standard iterators will
                // allow it to leverage unstable traits like `TrustedLen`.
                self.iter.map($map_elt).collect()
            }
        };
    }

    macro_rules! double_ended_iterator_methods {
        // $map_elt is the mapping function from the underlying iterator's element
        // same mapping function for both options and iterators
        ($map_elt:expr) => {
            fn next_back(&mut self) -> Option<Self::Item> {
                self.iter.next_back().map($map_elt)
            }
        };
    }