/// involved. This type is excellent for building your own data structures like Vec and VecDeque.
/// In particular:
///
-/// * Produces `Unique::empty()` on zero-sized types.
-/// * Produces `Unique::empty()` on zero-length allocations.
-/// * Avoids freeing `Unique::empty()`.
+/// * Produces `Unique::dangling()` on zero-sized types.
+/// * Produces `Unique::dangling()` on zero-length allocations.
+/// * Avoids freeing `Unique::dangling()`.
/// * Catches all overflows in capacity computations (promotes them to "capacity overflow" panics).
/// * Guards against 32-bit systems allocating more than isize::MAX bytes.
/// * Guards against overflowing your length.
/// the returned `RawVec`.
pub const fn new_in(alloc: A) -> Self {
// `cap: 0` means "unallocated". zero-sized types are ignored.
- Self { ptr: Unique::empty(), cap: 0, alloc }
+ Self { ptr: Unique::dangling(), cap: 0, alloc }
}
/// Like `with_capacity`, but parameterized over the choice of
let memory = alloc.alloc(layout, init).unwrap_or_else(|_| handle_alloc_error(layout));
Self {
- ptr: memory.ptr.cast().into(),
+ ptr: unsafe { Unique::new_unchecked(memory.ptr.cast().as_ptr()) },
cap: Self::capacity_from_bytes(memory.size),
alloc,
}
}
/// Gets a raw pointer to the start of the allocation. Note that this is
- /// `Unique::empty()` if `capacity == 0` or `T` is zero-sized. In the former case, you must
+ /// `Unique::dangling()` if `capacity == 0` or `T` is zero-sized. In the former case, you must
/// be careful.
pub fn ptr(&self) -> *mut T {
self.ptr.as_ptr()
}
}
- /// Attempts to double the size of the type's backing allocation in place. This is common
- /// enough to want to do that it's easiest to just have a dedicated method. Slightly
- /// more efficient logic can be provided for this than the general case.
- ///
- /// Returns `true` if the reallocation attempt has succeeded.
- ///
- /// # Panics
- ///
- /// * Panics if `T` is zero-sized on the assumption that you managed to exhaust
- /// all `usize::MAX` slots in your imaginary buffer.
- /// * Panics on 32-bit platforms if the requested capacity exceeds
- /// `isize::MAX` bytes.
- #[inline(never)]
- #[cold]
- pub fn double_in_place(&mut self) -> bool {
- self.grow(Double, InPlace, Uninitialized).is_ok()
- }
-
/// Ensures that the buffer contains at least enough space to hold
/// `used_capacity + needed_extra_capacity` elements. If it doesn't already have
/// enough capacity, will reallocate enough space plus comfortable slack
}
fn set_memory(&mut self, memory: MemoryBlock) {
- self.ptr = memory.ptr.cast().into();
+ self.ptr = unsafe { Unique::new_unchecked(memory.ptr.cast().as_ptr()) };
self.cap = Self::capacity_from_bytes(memory.size);
}