Skip to content

Commit 4f348df

Browse files
tbu-tbu-
committed
Minimize diff between src/arrayvec{,_copy}.rs 
1 parent 2b807d3 commit 4f348df

File tree

3 files changed

+36
-137
lines changed

3 files changed

+36
-137
lines changed

‎src/arrayvec.rs‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -499,7 +499,7 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
499499
let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len };
500500

501501
#[inline(always)]
502-
fn process_one<F: FnMut(&mut T) -> bool, T, const CAP: usize, const DELETED: bool>(
502+
fn process_one<T, F: FnMut(&mut T) -> bool, const CAP: usize, const DELETED: bool>(
503503
f: &mut F,
504504
g: &mut BackshiftOnDrop<'_, T, CAP>
505505
) -> bool {
@@ -522,14 +522,14 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
522522

523523
// Stage 1: Nothing was deleted.
524524
while g.processed_len != original_len {
525-
if !process_one::<F, T, CAP, false>(&mut f, &mut g) {
525+
if !process_one::<T, F, CAP, false>(&mut f, &mut g) {
526526
break;
527527
}
528528
}
529529

530530
// Stage 2: Some elements were deleted.
531531
while g.processed_len != original_len {
532-
process_one::<F, T, CAP, true>(&mut f, &mut g);
532+
process_one::<T, F, CAP, true>(&mut f, &mut g);
533533
}
534534

535535
drop(g);
@@ -899,7 +899,7 @@ impl<T, const CAP: usize> IntoIterator for ArrayVec<T, CAP> {
899899
/// let data = unsafe { core::slice::from_raw_parts(array.as_ptr(), array.capacity()) };
900900
/// assert_eq!(data, [0, 0, 0]);
901901
/// ```
902-
impl<Z: zeroize::Zeroize, const CAP: usize> zeroize::Zeroize for ArrayVec<Z, CAP> {
902+
impl<T: zeroize::Zeroize, const CAP: usize> zeroize::Zeroize for ArrayVec<T, CAP> {
903903
fn zeroize(&mut self) {
904904
// Zeroize all the contained elements.
905905
self.iter_mut().zeroize();
@@ -1064,16 +1064,16 @@ impl<'a, T: 'a, const CAP: usize> Drop for Drain<'a, T, CAP> {
10641064
}
10651065
}
10661066

1067-
struct ScopeExitGuard<T, Data, F>
1068-
where F: FnMut(&Data, &mut T)
1067+
struct ScopeExitGuard<V, Data, F>
1068+
where F: FnMut(&Data, &mut V)
10691069
{
1070-
value: T,
1070+
value: V,
10711071
data: Data,
10721072
f: F,
10731073
}
10741074

1075-
impl<T, Data, F> Drop for ScopeExitGuard<T, Data, F>
1076-
where F: FnMut(&Data, &mut T)
1075+
impl<V, Data, F> Drop for ScopeExitGuard<V, Data, F>
1076+
where F: FnMut(&Data, &mut V)
10771077
{
10781078
fn drop(&mut self) {
10791079
(self.f)(&self.data, &mut self.value)

‎src/arrayvec_copy.patch‎

Lines changed: 9 additions & 118 deletions
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,18 @@
11
diff --git a/src/arrayvec_copy_generated.rs b/src/arrayvec_copy.rs
2-
index 6719868..d36e5fb 100644
2+
index b12aa9e..5597af9 100644
33
--- a/src/arrayvec_copy_generated.rs
44
+++ b/src/arrayvec_copy.rs
5-
@@ -14,7 +14,6 @@ use std::fmt;
6-
#[cfg(feature="std")]
7-
use std::io;
5+
@@ -27,6 +27,9 @@ use crate::utils::MakeMaybeUninit;
86

9-
-use std::mem::ManuallyDrop;
10-
use std::mem::MaybeUninit;
11-
12-
#[cfg(feature="serde")]
13-
@@ -25,7 +24,7 @@ use crate::errors::CapacityError;
14-
use crate::arrayvec_impl::ArrayVecImpl;
15-
use crate::utils::MakeMaybeUninit;
16-
17-
-/// A vector with a fixed capacity.
18-
+/// A vector with a fixed capacity which implements `Copy` and its elemenents are constrained to also be `Copy`.
7+
/// A vector with a fixed capacity.
198
///
9+
+/// **Its only difference to [`ArrayVec`](crate::ArrayVec) is that its elements
10+
+/// are constrained to be `Copy` which allows it to be `Copy` itself.**
11+
+///
2012
/// The `ArrayVecCopy` is a vector backed by a fixed size array. It keeps track of
2113
/// the number of initialized elements. The `ArrayVecCopy<T, CAP>` is parameterized
22-
@@ -46,14 +45,6 @@ pub struct ArrayVecCopy<T: Copy, const CAP: usize> {
14+
/// by `T` for the element type and `CAP` for the maximum capacity.
15+
@@ -46,14 +49,6 @@ pub struct ArrayVecCopy<T: Copy, const CAP: usize> {
2316
xs: [MaybeUninit<T>; CAP],
2417
}
2518

@@ -34,91 +27,7 @@ index 6719868..d36e5fb 100644
3427
macro_rules! panic_oob {
3528
($method_name:expr, $index:expr, $len:expr) => {
3629
panic!(concat!("ArrayVecCopy::", $method_name, ": index {} is out of bounds in vector of length {}"),
37-
@@ -231,8 +222,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
38-
ArrayVecImpl::push_unchecked(self, element)
39-
}
40-
41-
- /// Shortens the vector, keeping the first `len` elements and dropping
42-
- /// the rest.
43-
+ /// Shortens the vector, keeping the first `len` elements.
44-
///
45-
/// If `len` is greater than the vector’s current length this has no
46-
/// effect.
47-
@@ -499,7 +489,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
48-
let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len };
49-
50-
#[inline(always)]
51-
- fn process_one<F: FnMut(&mut T) -> bool, T, const CAP: usize, const DELETED: bool>(
52-
+ fn process_one<T: Copy, F: FnMut(&mut T) -> bool, const CAP: usize, const DELETED: bool>(
53-
f: &mut F,
54-
g: &mut BackshiftOnDrop<'_, T, CAP>
55-
) -> bool {
56-
@@ -507,7 +497,6 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
57-
if !f(unsafe { &mut *cur }) {
58-
g.processed_len += 1;
59-
g.deleted_cnt += 1;
60-
- unsafe { ptr::drop_in_place(cur) };
61-
return false;
62-
}
63-
if DELETED {
64-
@@ -522,14 +511,14 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
65-
66-
// Stage 1: Nothing was deleted.
67-
while g.processed_len != original_len {
68-
- if !process_one::<F, T, CAP, false>(&mut f, &mut g) {
69-
+ if !process_one::<T, F, CAP, false>(&mut f, &mut g) {
70-
break;
71-
}
72-
}
73-
74-
// Stage 2: Some elements were deleted.
75-
while g.processed_len != original_len {
76-
- process_one::<F, T, CAP, true>(&mut f, &mut g);
77-
+ process_one::<T, F, CAP, true>(&mut f, &mut g);
78-
}
79-
80-
drop(g);
81-
@@ -570,7 +559,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
82-
&mut self.xs[len..]
83-
}
84-
85-
- /// Set the vector’s length without dropping or moving out elements
86-
+ /// Set the vector’s length without moving out elements
87-
///
88-
/// This method is `unsafe` because it changes the notion of the
89-
/// number of “valid” elements in the vector. Use with care.
90-
@@ -703,8 +692,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
91-
/// This operation is safe if and only if length equals capacity.
92-
pub unsafe fn into_inner_unchecked(self) -> [T; CAP] {
93-
debug_assert_eq!(self.len(), self.capacity());
94-
- let self_ = ManuallyDrop::new(self);
95-
- let array = ptr::read(self_.as_ptr() as *const [T; CAP]);
96-
+ let array = ptr::read(self.as_ptr() as *const [T; CAP]);
97-
array
98-
}
99-
100-
@@ -790,10 +778,9 @@ impl<T: Copy, const CAP: usize> DerefMut for ArrayVecCopy<T, CAP> {
101-
impl<T: Copy, const CAP: usize> From<[T; CAP]> for ArrayVecCopy<T, CAP> {
102-
#[track_caller]
103-
fn from(array: [T; CAP]) -> Self {
104-
- let array = ManuallyDrop::new(array);
105-
let mut vec = <ArrayVecCopy<T, CAP>>::new();
106-
unsafe {
107-
- (&*array as *const [T; CAP] as *const [MaybeUninit<T>; CAP])
108-
+ (&array as *const [T; CAP] as *const [MaybeUninit<T>; CAP])
109-
.copy_to_nonoverlapping(&mut vec.xs as *mut [MaybeUninit<T>; CAP], 1);
110-
vec.set_len(CAP);
111-
}
112-
@@ -899,7 +886,7 @@ impl<T: Copy, const CAP: usize> IntoIterator for ArrayVecCopy<T, CAP> {
113-
/// let data = unsafe { core::slice::from_raw_parts(array.as_ptr(), array.capacity()) };
114-
/// assert_eq!(data, [0, 0, 0]);
115-
/// ```
116-
-impl<Z: zeroize::Zeroize, const CAP: usize> zeroize::Zeroize for ArrayVecCopy<Z, CAP> {
117-
+impl<T: Copy + zeroize::Zeroize, const CAP: usize> zeroize::Zeroize for ArrayVecCopy<T, CAP> {
118-
fn zeroize(&mut self) {
119-
// Zeroize all the contained elements.
120-
self.iter_mut().zeroize();
121-
@@ -964,21 +951,6 @@ impl<T: Copy, const CAP: usize> DoubleEndedIterator for IntoIter<T, CAP> {
30+
@@ -964,21 +959,6 @@ impl<T: Copy, const CAP: usize> DoubleEndedIterator for IntoIter<T, CAP> {
12231

12332
impl<T: Copy, const CAP: usize> ExactSizeIterator for IntoIter<T, CAP> { }
12433

@@ -140,21 +49,3 @@ index 6719868..d36e5fb 100644
14049
impl<T: Copy, const CAP: usize> Clone for IntoIter<T, CAP>
14150
where T: Clone,
14251
{
143-
@@ -1064,7 +1036,7 @@ impl<'a, T: Copy + 'a, const CAP: usize> Drop for Drain<'a, T, CAP> {
144-
}
145-
}
146-
147-
-struct ScopeExitGuard<T: Copy, Data, F>
148-
+struct ScopeExitGuard<T, Data, F>
149-
where F: FnMut(&Data, &mut T)
150-
{
151-
value: T,
152-
@@ -1072,7 +1044,7 @@ struct ScopeExitGuard<T: Copy, Data, F>
153-
f: F,
154-
}
155-
156-
-impl<T: Copy, Data, F> Drop for ScopeExitGuard<T, Data, F>
157-
+impl<T, Data, F> Drop for ScopeExitGuard<T, Data, F>
158-
where F: FnMut(&Data, &mut T)
159-
{
160-
fn drop(&mut self) {

‎src/arrayvec_copy.rs‎

Lines changed: 18 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@ use std::fmt;
1414
#[cfg(feature="std")]
1515
use std::io;
1616

17+
use std::mem::ManuallyDrop;
1718
use std::mem::MaybeUninit;
1819

1920
#[cfg(feature="serde")]
@@ -24,7 +25,10 @@ use crate::errors::CapacityError;
2425
use crate::arrayvec_impl::ArrayVecImpl;
2526
use crate::utils::MakeMaybeUninit;
2627

27-
/// A vector with a fixed capacity which implements `Copy` and its elemenents are constrained to also be `Copy`.
28+
/// A vector with a fixed capacity.
29+
///
30+
/// **Its only difference to [`ArrayVec`](crate::ArrayVec) is that its elements
31+
/// are constrained to be `Copy` which allows it to be `Copy` itself.**
2832
///
2933
/// The `ArrayVecCopy` is a vector backed by a fixed size array. It keeps track of
3034
/// the number of initialized elements. The `ArrayVecCopy<T, CAP>` is parameterized
@@ -222,7 +226,8 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
222226
ArrayVecImpl::push_unchecked(self, element)
223227
}
224228

225-
/// Shortens the vector, keeping the first `len` elements.
229+
/// Shortens the vector, keeping the first `len` elements and dropping
230+
/// the rest.
226231
///
227232
/// If `len` is greater than the vector’s current length this has no
228233
/// effect.
@@ -497,6 +502,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
497502
if !f(unsafe { &mut *cur }) {
498503
g.processed_len += 1;
499504
g.deleted_cnt += 1;
505+
unsafe { ptr::drop_in_place(cur) };
500506
return false;
501507
}
502508
if DELETED {
@@ -559,7 +565,7 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
559565
&mut self.xs[len..]
560566
}
561567

562-
/// Set the vector’s length without moving out elements
568+
/// Set the vector’s length without dropping or moving out elements
563569
///
564570
/// This method is `unsafe` because it changes the notion of the
565571
/// number of “valid” elements in the vector. Use with care.
@@ -692,7 +698,8 @@ impl<T: Copy, const CAP: usize> ArrayVecCopy<T, CAP> {
692698
/// This operation is safe if and only if length equals capacity.
693699
pub unsafe fn into_inner_unchecked(self) -> [T; CAP] {
694700
debug_assert_eq!(self.len(), self.capacity());
695-
let array = ptr::read(self.as_ptr() as *const [T; CAP]);
701+
let self_ = ManuallyDrop::new(self);
702+
let array = ptr::read(self_.as_ptr() as *const [T; CAP]);
696703
array
697704
}
698705

@@ -778,9 +785,10 @@ impl<T: Copy, const CAP: usize> DerefMut for ArrayVecCopy<T, CAP> {
778785
impl<T: Copy, const CAP: usize> From<[T; CAP]> for ArrayVecCopy<T, CAP> {
779786
#[track_caller]
780787
fn from(array: [T; CAP]) -> Self {
788+
let array = ManuallyDrop::new(array);
781789
let mut vec = <ArrayVecCopy<T, CAP>>::new();
782790
unsafe {
783-
(&array as *const [T; CAP] as *const [MaybeUninit<T>; CAP])
791+
(&*array as *const [T; CAP] as *const [MaybeUninit<T>; CAP])
784792
.copy_to_nonoverlapping(&mut vec.xs as *mut [MaybeUninit<T>; CAP], 1);
785793
vec.set_len(CAP);
786794
}
@@ -1036,16 +1044,16 @@ impl<'a, T: Copy + 'a, const CAP: usize> Drop for Drain<'a, T, CAP> {
10361044
}
10371045
}
10381046

1039-
struct ScopeExitGuard<T, Data, F>
1040-
where F: FnMut(&Data, &mut T)
1047+
struct ScopeExitGuard<V, Data, F>
1048+
where F: FnMut(&Data, &mut V)
10411049
{
1042-
value: T,
1050+
value: V,
10431051
data: Data,
10441052
f: F,
10451053
}
10461054

1047-
impl<T, Data, F> Drop for ScopeExitGuard<T, Data, F>
1048-
where F: FnMut(&Data, &mut T)
1055+
impl<V, Data, F> Drop for ScopeExitGuard<V, Data, F>
1056+
where F: FnMut(&Data, &mut V)
10491057
{
10501058
fn drop(&mut self) {
10511059
(self.f)(&self.data, &mut self.value)

0 commit comments

Comments
 (0)