reusable-memory 0.2.1

Reusable memory that can be mutably borrowed as another type.
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

use std::{
	fmt,
	ops::{Bound, Range, RangeBounds}
};

use super::ReusableMemoryBorrow;

// Most of this code is copied from std Vec

pub struct BorrowDrainIter<'bor, 'mem, T: 'mem> {
	borrow: &'bor mut ReusableMemoryBorrow<'mem, T>,
	drain_range: Range<usize>,

	/// Start of the tail after the drained items
	tail_start: usize,
	/// Length of tail after the drained items
	tail_len: usize
}
impl<'bor, 'mem: 'bor, T: 'mem> BorrowDrainIter<'bor, 'mem, T> {
	pub(super) fn new(
		borrow: &'bor mut ReusableMemoryBorrow<'mem, T>, range: impl RangeBounds<usize>
	) -> Self {
		let len = borrow.len();
		let start = match range.start_bound() {
			Bound::Included(&n) => n,
			Bound::Excluded(&n) => n + 1,
			Bound::Unbounded => 0
		};
		let end = match range.end_bound() {
			Bound::Included(&n) => n + 1,
			Bound::Excluded(&n) => n,
			Bound::Unbounded => len
		};
		assert!(start <= end);
		assert!(end <= len);

		unsafe {
			// Safety in case Drain is leaked
			borrow.set_len(start);

			Self { borrow, drain_range: start .. end, tail_start: end, tail_len: len - end }
		}
	}
}
impl<T: fmt::Debug> fmt::Debug for BorrowDrainIter<'_, '_, T> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		f.debug_tuple("BorrowDrainIter")
			.field(unsafe {
				&std::slice::from_raw_parts(
					self.borrow.as_ptr().add(self.drain_range.start),
					self.drain_range.end - self.drain_range.start
				)
			})
			.finish()
	}
}
impl<T> Iterator for BorrowDrainIter<'_, '_, T> {
	type Item = T;

	fn next(&mut self) -> Option<T> {
		self.drain_range
			.next()
			.map(|offset| unsafe { std::ptr::read(self.borrow.as_ptr().add(offset)) })
	}

	fn size_hint(&self) -> (usize, Option<usize>) { self.drain_range.size_hint() }
}
impl<T> DoubleEndedIterator for BorrowDrainIter<'_, '_, T> {
	fn next_back(&mut self) -> Option<T> {
		self.drain_range
			.next_back()
			.map(|offset| unsafe { std::ptr::read(self.borrow.as_ptr().add(offset)) })
	}
}
impl<T> ExactSizeIterator for BorrowDrainIter<'_, '_, T> {}
impl<T> Drop for BorrowDrainIter<'_, '_, T> {
	fn drop(&mut self) {
		// exhaust self first
		self.for_each(drop);

		if self.tail_len > 0 {
			unsafe {
				let start = self.borrow.len();
				let tail = self.tail_start;
				// There is some tail left and we need to memmove it
				if start != tail {
					let src = self.borrow.as_ptr().add(tail);
					let dst = self.borrow.as_mut_ptr().add(start);
					std::ptr::copy(src, dst, self.tail_len);
				}

				self.borrow.set_len(start + self.tail_len);
			}
		}
	}
}