bivec 0.1.0

A Rust implementation of Bivec, two vecs in one, with the same length.
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

use std::ptr;

use super::*; 

impl <F, S> BiVec<F, S> {
    /// Removes the element at the given index, and returns it. 
    /// 
    /// The removed element is replaced by the last element of the vector. 
    pub fn swap_remove(&mut self, first_index: usize, second_index: usize) -> (F, S) {
        #[cold]
        #[inline(never)]
        fn assert_failed(index: usize, len: usize) -> ! {
            panic!("swap_remove index (is {index}) should be < len (is {len})");
        }
        let len = self.len();
        if first_index >= len {
            assert_failed(first_index, len);
        }
        if second_index >= len {
            assert_failed(second_index, len); 
        }
        self.len -= 1; 
        let (first, second); 
        unsafe {
            let value_ptr = self.first.as_ptr().add(first_index); 
            let end_ptr = self.first.as_ptr().add(len); 
            first = ptr::read(value_ptr); 
            value_ptr.write(end_ptr.read());
            let value_ptr = self.second.as_ptr().add(second_index); 
            let end_ptr = self.second.as_ptr().add(len); 
            second = ptr::read(value_ptr); 
            value_ptr.write(end_ptr.read()); 
        }
        (first, second)
    }
    pub fn swap_remove_same(&mut self, index: usize) -> (F, S) {
        self.swap_remove(index, index)
    } 
    pub fn remove(&mut self, index: usize) -> (F, S) {
        let len = self.len; 
        assert!(index < len, "remove index (is {}) should be < len (is {})", index, len); 
        let (f, s); 
        unsafe {
            let value_ptr = self.first.as_ptr().add(index); 
            let to_copy = self.first.as_ptr().add(index + 1); 
            f = ptr::read(value_ptr); 
            value_ptr.copy_from(to_copy, len - index - 1);
            let value_ptr = self.second.as_ptr().add(index); 
            let to_copy = self.second.as_ptr().add(index + 1); 
            s = ptr::read(value_ptr); 
            value_ptr.copy_from(to_copy, len - index - 1); 
        }
        (f, s)
    }
    pub fn retain_mut(&mut self, mut f: impl FnMut(&mut F, &mut S) -> bool) {
        let len = self.len; 
        let mut retains = Vec::with_capacity(len);
        let (slice1, slice2) = self.as_slice_mut(); 
        for i in 0..len {
            if f(&mut slice1[i], &mut slice2[i]) {
                retains.push(i); 
            }
        } 
        self.retain_in(retains); 
    }
    pub fn retain(&mut self, mut f: impl FnMut(&F, &S) -> bool) {
        let len = self.len; 
        let mut retains = Vec::with_capacity(len);
        let (slice1, slice2) = self.as_slice_mut(); 
        for i in 0..len {
            if f(&slice1[i], &slice2[i]) {
                retains.push(i); 
            }
        } 
        self.retain_in(retains); 
    }
    fn retain_in(&mut self, retains: Vec<usize>) {
        let len = self.len; 
        let mut reit = retains.iter(); 
        let mut current = reit.next(); 
        for i in 0..len {
            match current {
                Some(&current_val) => {
                    if i == current_val {
                        current = reit.next(); 
                        continue; 
                    } 
                }
                None => (), 
            }
            unsafe { self.first.as_ptr().add(i).drop_in_place(); } 
        }
        let mut reit = retains.iter(); 
        let mut current = reit.next(); 
        for i in 0..len {
            match current {
                Some(&current_val) => {
                    if i == current_val {
                        current = reit.next(); 
                        continue; 
                    } 
                }
                None => (), 
            }
            unsafe { self.second.as_ptr().add(i).drop_in_place(); } 
        }
        self.len = retains.len(); 
        for (i, &v) in retains.iter().enumerate() {
            unsafe {
                let first_ptr = self.first.as_ptr().add(i); 
                let first_to_copy = self.first.as_ptr().add(v); 
                first_ptr.write(first_to_copy.read()); 
            } 
        }
        for (i, &v) in retains.iter().enumerate() {
            unsafe {
                let second_ptr = self.second.as_ptr().add(i); 
                let second_to_copy = self.second.as_ptr().add(v); 
                second_ptr.write(second_to_copy.read()); 
            } 
        } 
    }
    pub fn truncate(&mut self, new_len: usize) {
        if self.len <= new_len {
            return 
        }
        let len = self.len; 
        for i in new_len..len {
            unsafe { self.first.as_ptr().add(i).drop_in_place(); } 
        } 
        for i in new_len..len {
            unsafe { self.second.as_ptr().add(i).drop_in_place(); } 
        } 
        self.len = new_len; 
    } 
}