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
use std::ptr;
macro_rules! idx_check (
($slice:expr, $idx:expr) => {
assert!($idx < $slice.len(),
concat!("`", stringify!($idx), "` ({}) out of bounds. Length: {}"),
$idx, $slice.len());
}
);
macro_rules! len_check (
($slice:expr, $start:ident, $len:ident) => {
assert!(
$start.checked_add($len)
.expect(concat!("Overflow evaluating ", stringify!($start + $len)))
<= $slice.len(),
"Length {} starting at {} is out of bounds (slice len {}).", $len, $start, $slice.len()
)
}
);
pub fn copy_over<T: Copy>(slice: &mut [T], src_idx: usize, dest_idx: usize, len: usize) {
if slice.len() == 0 { return; }
idx_check!(slice, src_idx);
idx_check!(slice, dest_idx);
len_check!(slice, src_idx, len);
len_check!(slice, dest_idx, len);
let src_ptr: *const T = &slice[src_idx];
let dest_ptr: *mut T = &mut slice[dest_idx];
unsafe {
ptr::copy(src_ptr, dest_ptr, len);
}
}
pub fn write_bytes(slice: &mut [u8], byte: u8) {
unsafe {
ptr::write_bytes(slice.as_mut_ptr(), byte, slice.len());
}
}
pub fn prepend<T: Copy>(elems: &[T], vec: &mut Vec<T>) {
vec.reserve(elems.len());
let old_len = vec.len();
let new_len = old_len + elems.len();
unsafe {
vec.set_len(new_len);
}
if old_len > 0 {
copy_over(vec, 0, elems.len(), old_len);
}
vec[..elems.len()].copy_from_slice(elems);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[should_panic]
fn bounds_check() {
let mut arr = [0i32, 1, 2, 3, 4, 5];
copy_over(&mut arr, 2, 1, 7);
}
#[test]
fn copy_empty() {
let mut arr: [i32; 0] = [];
copy_over(&mut arr, 0, 0, 0);
}
#[test]
fn prepend_empty() {
let mut vec: Vec<i32> = vec![];
prepend(&[1, 2, 3], &mut vec);
}
#[test]
fn prepend_i32() {
let mut vec = vec![3, 4, 5];
prepend(&[1, 2], &mut vec);
assert_eq!(vec, &[1, 2, 3, 4, 5]);
}
}