/// 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
}
/// 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