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

use crate::ImpVec;
use orx_pinned_vec::PinnedVec;

impl<T, P1, P2> PartialEq<ImpVec<T, P2>> for ImpVec<T, P1>
where
    P1: PinnedVec<T>,
    P2: PinnedVec<T>,
    T: PartialEq,
{
    fn eq(&self, other: &ImpVec<T, P2>) -> bool {
        if self.len() == other.len() {
            self.iter().zip(other.iter()).all(|(x, y)| x == y)
        } else {
            false
        }
    }
}
impl<T, P> Eq for ImpVec<T, P>
where
    P: PinnedVec<T>,
    T: PartialEq,
{
}

impl<T, P, S> PartialEq<S> for ImpVec<T, P>
where
    P: PinnedVec<T>,
    S: AsRef<[T]>,
    T: PartialEq,
{
    fn eq(&self, other: &S) -> bool {
        self.cell.borrow().partial_eq(other.as_ref())
    }
}

impl<T, P> PartialEq<ImpVec<T, P>> for Vec<T>
where
    P: PinnedVec<T>,
    T: PartialEq,
{
    fn eq(&self, other: &ImpVec<T, P>) -> bool {
        other.cell.borrow().partial_eq(self)
    }
}
impl<T, P, const N: usize> PartialEq<ImpVec<T, P>> for [T; N]
where
    P: PinnedVec<T>,
    T: PartialEq,
{
    fn eq(&self, other: &ImpVec<T, P>) -> bool {
        other.cell.borrow().partial_eq(self)
    }
}

#[cfg(test)]
mod tests {
    use crate::prelude::*;
    use crate::test_all_pinned_types;

    #[test]
    fn eq_with_imp() {
        fn test<P: PinnedVec<usize>>(pinned_vec: P) {
            let imp1: ImpVec<_, _> = pinned_vec.into();
            let imp2: ImpVec<_, _> = FixedVec::new(3344).into();

            for i in 0..1000 {
                imp1.push(i);
                imp2.push(i);
            }
            assert_eq!(imp1, imp2);
            assert_eq!(imp2, imp1);

            imp2.push(1000);
            assert_ne!(imp1, imp2);
            assert_ne!(imp2, imp1);
        }

        test_all_pinned_types!(test);
    }

    #[test]
    fn eq_with_asref() {
        fn test<P: PinnedVec<usize>>(pinned_vec: P) {
            let imp: ImpVec<_, _> = pinned_vec.into();
            let mut vec = vec![];

            for i in 0..1000 {
                imp.push(i);
                vec.push(i);
            }
            assert_eq!(vec, imp);
            assert_eq!(imp, vec);
            assert_eq!(imp, vec.as_slice());
            assert_eq!(imp, &vec);
        }

        test_all_pinned_types!(test);
    }

    #[test]
    fn eq_with_slice() {
        fn test<P: PinnedVec<usize>>(pinned_vec: P) {
            let imp: ImpVec<_, _> = pinned_vec.into();
            for i in 0..4 {
                imp.push(i);
            }
            assert_eq!(vec![0, 1, 2, 3], imp);
            assert_eq!(imp, &[0, 1, 2, 3]);
        }

        test_all_pinned_types!(test);
    }

    #[test]
    fn eq_with_array() {
        fn test<P: PinnedVec<usize>>(pinned_vec: P) {
            let imp: ImpVec<_, _> = pinned_vec.into();
            for i in 0..4 {
                imp.push(i);
            }
            assert_eq!([0, 1, 2, 3], imp);
            assert_eq!(imp, [0, 1, 2, 3]);
        }

        test_all_pinned_types!(test);
    }
}