    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

    #![allow(dead_code)]

    use std::borrow::Borrow;

    /// Flat (Vec) backed set
    ///
    /// This preserves insertion order
    #[derive(Clone, Debug, PartialEq, Eq)]
    pub(crate) struct FlatSet<T> {
        inner: Vec<T>,
    }

    impl<T: PartialEq + Eq> FlatSet<T> {
        pub(crate) fn new() -> Self {
            Default::default()
        }

        pub(crate) fn insert(&mut self, value: T) -> bool {
            for existing in &self.inner {
                if *existing == value {
                    return false;
                }
            }
            self.inner.push(value);
            true
        }

        pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool
        where
            T: Borrow<Q>,
            Q: Eq,
        {
            for existing in &self.inner {
                if existing.borrow() == value {
                    return true;
                }
            }
            false
        }

        pub fn retain<F>(&mut self, f: F)
        where
            F: FnMut(&T) -> bool,
        {
            self.inner.retain(f);
        }

        pub(crate) fn is_empty(&self) -> bool {
            self.inner.is_empty()
        }

        pub(crate) fn iter(&self) -> std::slice::Iter<'_, T> {
            self.inner.iter()
        }

        pub fn sort_by_key<K, F>(&mut self, f: F)
        where
            F: FnMut(&T) -> K,
            K: Ord,
        {
            self.inner.sort_by_key(f);
        }
    }

    impl<T: PartialEq + Eq> Default for FlatSet<T> {
        fn default() -> Self {
            Self {
                inner: Default::default(),
            }
        }
    }

    impl<T: PartialEq + Eq> IntoIterator for FlatSet<T> {
        type Item = T;
        type IntoIter = std::vec::IntoIter<T>;

        fn into_iter(self) -> Self::IntoIter {
            self.inner.into_iter()
        }
    }

    impl<'s, T: PartialEq + Eq> IntoIterator for &'s FlatSet<T> {
        type Item = &'s T;
        type IntoIter = std::slice::Iter<'s, T>;

        fn into_iter(self) -> Self::IntoIter {
            self.inner.iter()
        }
    }

    impl<T: PartialEq + Eq> Extend<T> for FlatSet<T> {
        fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
            for value in iter {
                self.insert(value);
            }
        }
    }

    impl<T: PartialEq + Eq> FromIterator<T> for FlatSet<T> {
        fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
            let mut set = Self::new();
            for value in iter {
                set.insert(value);
            }
            set
        }
    }