aliasable/
vec.rs

Help
1//! Aliasable `Vec`.
2
3use core::ops::{Deref, DerefMut};
4use core::pin::Pin;
5use core::ptr::NonNull;
6use core::{fmt, mem, slice};
7
8pub use alloc::vec::Vec as UniqueVec;
9
10/// Basic aliasable (non `core::ptr::Unique`) alternative to
11/// [`alloc::vec::Vec`].
12pub struct AliasableVec<T> {
13    ptr: NonNull<T>,
14    len: usize,
15    cap: usize,
16}
17
18impl<T> AliasableVec<T> {
19    /// Construct an `AliasableVec` from a [`UniqueVec`].
20    pub fn from_unique(mut vec: UniqueVec<T>) -> Self {
21        let ptr = vec.as_mut_ptr();
22        let len = vec.len();
23        let cap = vec.capacity();
24
25        mem::forget(vec);
26
27        let ptr = unsafe { NonNull::new_unchecked(ptr) };
28
29        Self { ptr, len, cap }
30    }
31
32    /// Consumes the [`AliasableVec`] and converts it back into a
33    /// non-aliasable [`UniqueVec`].
34    #[inline]
35    pub fn into_unique(mut vec: AliasableVec<T>) -> UniqueVec<T> {
36        // SAFETY: As we are consuming the `Vec` structure we can safely assume
37        // any aliasing has ended and convert the aliasable `Vec` back to into
38        // an unaliasable `UniqueVec`.
39        let unique = unsafe { vec.reclaim_as_unique_vec() };
40        // Forget the aliasable `Vec` so the allocation behind the `UniqueVec`
41        // is not deallocated.
42        mem::forget(vec);
43        // Return the `UniqueVec`.
44        unique
45    }
46
47    /// Convert a pinned [`AliasableVec`] to a `core::ptr::Unique` backed pinned
48    /// [`UniqueVec`].
49    pub fn into_unique_pin(pin: Pin<AliasableVec<T>>) -> Pin<UniqueVec<T>> {
50        // SAFETY: The pointer is not changed, just the container.
51        unsafe {
52            let aliasable = Pin::into_inner_unchecked(pin);
53            Pin::new_unchecked(AliasableVec::into_unique(aliasable))
54        }
55    }
56
57    /// Convert a pinned `core::ptr::Unique` backed [`UniqueVec`] to a
58    /// pinned [`AliasableVec`].
59    pub fn from_unique_pin(pin: Pin<UniqueVec<T>>) -> Pin<AliasableVec<T>> {
60        unsafe {
61            let unique = Pin::into_inner_unchecked(pin);
62            Pin::new_unchecked(AliasableVec::from(unique))
63        }
64    }
65
66    #[inline]
67    unsafe fn reclaim_as_unique_vec(&mut self) -> UniqueVec<T> {
68        UniqueVec::from_raw_parts(self.ptr.as_mut(), self.len, self.cap)
69    }
70}
71
72impl<T> From<UniqueVec<T>> for AliasableVec<T> {
73    #[inline]
74    fn from(vec: UniqueVec<T>) -> Self {
75        Self::from_unique(vec)
76    }
77}
78
79impl<T> From<AliasableVec<T>> for UniqueVec<T> {
80    #[inline]
81    fn from(vec: AliasableVec<T>) -> Self {
82        AliasableVec::into_unique(vec)
83    }
84}
85
86impl<T> Drop for AliasableVec<T> {
87    fn drop(&mut self) {
88        // As the `Vec` structure is being dropped we can safely assume any
89        // aliasing has ended and convert the aliasable `Vec` back to into an
90        // unaliasable `UniqueVec` to handle the deallocation.
91        let _ = unsafe { self.reclaim_as_unique_vec() };
92    }
93}
94
95impl<T> Deref for AliasableVec<T> {
96    type Target = [T];
97
98    #[inline]
99    fn deref(&self) -> &[T] {
100        // SAFETY: We own the data, so we can return a reference to it.
101        unsafe { slice::from_raw_parts(self.ptr.as_ptr(), self.len) }
102    }
103}
104
105impl<T> DerefMut for AliasableVec<T> {
106    #[inline]
107    fn deref_mut(&mut self) -> &mut [T] {
108        // SAFETY: We own the data, so we can return a reference to it.
109        unsafe { slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len) }
110    }
111}
112
113impl<T> AsRef<[T]> for AliasableVec<T> {
114    fn as_ref(&self) -> &[T] {
115        &*self
116    }
117}
118
119impl<T> AsMut<[T]> for AliasableVec<T> {
120    fn as_mut(&mut self) -> &mut [T] {
121        &mut *self
122    }
123}
124
125impl<T> fmt::Debug for AliasableVec<T>
126where
127    T: fmt::Debug,
128{
129    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
130        fmt::Debug::fmt(self.as_ref(), f)
131    }
132}
133
134unsafe impl<T> Send for AliasableVec<T> where T: Send {}
135unsafe impl<T> Sync for AliasableVec<T> where T: Sync {}
136
137#[cfg(feature = "traits")]
138unsafe impl<T> crate::StableDeref for AliasableVec<T> {}
139
140#[cfg(feature = "traits")]
141unsafe impl<T> crate::AliasableDeref for AliasableVec<T> {}
142
143#[cfg(test)]
144mod tests {
145    use super::AliasableVec;
146    use alloc::{format, vec};
147    use core::pin::Pin;
148
149    #[test]
150    fn test_new() {
151        let aliasable = AliasableVec::from_unique(vec![10]);
152        assert_eq!(&*aliasable, &[10]);
153        let unique = AliasableVec::into_unique(aliasable);
154        assert_eq!(&*unique, &[10]);
155    }
156
157    #[test]
158    fn test_new_pin() {
159        let aliasable = AliasableVec::from_unique_pin(Pin::new(vec![10]));
160        assert_eq!(&*aliasable, &[10]);
161        let unique = AliasableVec::into_unique_pin(aliasable);
162        assert_eq!(&*unique, &[10]);
163    }
164
165    #[test]
166    fn test_refs() {
167        let mut aliasable = AliasableVec::from_unique(vec![10]);
168        let ptr: *const [u8] = &*aliasable;
169        let as_mut_ptr: *const [u8] = aliasable.as_mut();
170        let as_ref_ptr: *const [u8] = aliasable.as_ref();
171        assert_eq!(ptr, as_mut_ptr);
172        assert_eq!(ptr, as_ref_ptr);
173    }
174
175    #[test]
176    fn test_debug() {
177        let aliasable = AliasableVec::from_unique(vec![10]);
178        assert_eq!(format!("{:?}", aliasable), "[10]");
179    }
180}
aliasable/vec.rs

aliasable/
vec.rs
