feat: add display UI with splash screen, dashboard, and RSSI sparkline
Implement full SSD1306 OLED display support: - Splash screen on boot (1.5s) with project name, version, board - Dashboard showing radio state, config, counters, RSSI/SNR - RSSI history sparkline (64-sample ring buffer, 2px-wide bars) - DisplayOn/DisplayOff host commands routed via dedicated channel - Pure render functions against generic DrawTarget (no hardware coupling) - Display on/off control bypasses radio task entirely Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
17624 files changed
+4564928
-38
No files matched your search
Vendored
+980
@@ -0,0 +1,980 @@
|
||||
#![cfg(feature = "extern_crate_alloc")]
|
||||
#![allow(clippy::duplicated_attributes)]
|
||||
|
||||
//! Stuff to boost things in the `alloc` crate.
|
||||
//!
|
||||
//! * You must enable the `extern_crate_alloc` feature of `bytemuck` or you will
|
||||
//! not be able to use this module! This is generally done by adding the
|
||||
//! feature to the dependency in Cargo.toml like so:
|
||||
//!
|
||||
//! `bytemuck = { version = "VERSION_YOU_ARE_USING", features =
|
||||
//! ["extern_crate_alloc"]}`
|
||||
|
||||
use super::*;
|
||||
#[cfg(target_has_atomic = "ptr")]
|
||||
use alloc::sync::Arc;
|
||||
use alloc::{
|
||||
alloc::{alloc_zeroed, Layout},
|
||||
boxed::Box,
|
||||
rc::Rc,
|
||||
vec,
|
||||
vec::Vec,
|
||||
};
|
||||
use core::{
|
||||
mem::{size_of_val, ManuallyDrop},
|
||||
ops::{Deref, DerefMut},
|
||||
};
|
||||
|
||||
/// As [`try_cast_box`], but unwraps for you.
|
||||
#[inline]
|
||||
pub fn cast_box<A: NoUninit, B: AnyBitPattern>(input: Box<A>) -> Box<B> {
|
||||
try_cast_box(input).map_err(|(e, _v)| e).unwrap()
|
||||
}
|
||||
|
||||
/// Attempts to cast the content type of a [`Box`].
|
||||
///
|
||||
/// On failure you get back an error along with the starting `Box`.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// * The start and end content type of the `Box` must have the exact same
|
||||
/// alignment.
|
||||
/// * The start and end size of the `Box` must have the exact same size.
|
||||
#[inline]
|
||||
pub fn try_cast_box<A: NoUninit, B: AnyBitPattern>(
|
||||
input: Box<A>,
|
||||
) -> Result<Box<B>, (PodCastError, Box<A>)> {
|
||||
if align_of::<A>() != align_of::<B>() {
|
||||
Err((PodCastError::AlignmentMismatch, input))
|
||||
} else if size_of::<A>() != size_of::<B>() {
|
||||
Err((PodCastError::SizeMismatch, input))
|
||||
} else {
|
||||
// Note(Lokathor): This is much simpler than with the Vec casting!
|
||||
let ptr: *mut B = Box::into_raw(input) as *mut B;
|
||||
Ok(unsafe { Box::from_raw(ptr) })
|
||||
}
|
||||
}
|
||||
|
||||
/// Allocates a `Box<T>` with all of the contents being zeroed out.
|
||||
///
|
||||
/// This uses the global allocator to create a zeroed allocation and _then_
|
||||
/// turns it into a Box. In other words, it's 100% assured that the zeroed data
|
||||
/// won't be put temporarily on the stack. You can make a box of any size
|
||||
/// without fear of a stack overflow.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// This fails if the allocation fails.
|
||||
#[inline]
|
||||
pub fn try_zeroed_box<T: Zeroable>() -> Result<Box<T>, ()> {
|
||||
if size_of::<T>() == 0 {
|
||||
// This will not allocate but simply create an arbitrary non-null
|
||||
// aligned pointer, valid for Box for a zero-sized pointee.
|
||||
let ptr = core::ptr::NonNull::dangling().as_ptr();
|
||||
return Ok(unsafe { Box::from_raw(ptr) });
|
||||
}
|
||||
let layout = Layout::new::<T>();
|
||||
let ptr = unsafe { alloc_zeroed(layout) };
|
||||
if ptr.is_null() {
|
||||
// we don't know what the error is because `alloc_zeroed` is a dumb API
|
||||
Err(())
|
||||
} else {
|
||||
Ok(unsafe { Box::<T>::from_raw(ptr as *mut T) })
|
||||
}
|
||||
}
|
||||
|
||||
/// As [`try_zeroed_box`], but unwraps for you.
|
||||
#[inline]
|
||||
pub fn zeroed_box<T: Zeroable>() -> Box<T> {
|
||||
try_zeroed_box().unwrap()
|
||||
}
|
||||
|
||||
/// Allocates a `Vec<T>` of length and capacity exactly equal to `length` and
|
||||
/// all elements zeroed.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// This fails if the allocation fails, or if a layout cannot be calculated for
|
||||
/// the allocation.
|
||||
pub fn try_zeroed_vec<T: Zeroable>(length: usize) -> Result<Vec<T>, ()> {
|
||||
if length == 0 {
|
||||
Ok(Vec::new())
|
||||
} else {
|
||||
let boxed_slice = try_zeroed_slice_box(length)?;
|
||||
Ok(boxed_slice.into_vec())
|
||||
}
|
||||
}
|
||||
|
||||
/// As [`try_zeroed_vec`] but unwraps for you
|
||||
pub fn zeroed_vec<T: Zeroable>(length: usize) -> Vec<T> {
|
||||
try_zeroed_vec(length).unwrap()
|
||||
}
|
||||
|
||||
/// Allocates a `Box<[T]>` with all contents being zeroed out.
|
||||
///
|
||||
/// This uses the global allocator to create a zeroed allocation and _then_
|
||||
/// turns it into a Box. In other words, it's 100% assured that the zeroed data
|
||||
/// won't be put temporarily on the stack. You can make a box of any size
|
||||
/// without fear of a stack overflow.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// This fails if the allocation fails, or if a layout cannot be calculated for
|
||||
/// the allocation.
|
||||
#[inline]
|
||||
pub fn try_zeroed_slice_box<T: Zeroable>(
|
||||
length: usize,
|
||||
) -> Result<Box<[T]>, ()> {
|
||||
if size_of::<T>() == 0 || length == 0 {
|
||||
// This will not allocate but simply create an arbitrary non-null aligned
|
||||
// slice pointer, valid for Box for a zero-sized pointee.
|
||||
let ptr = core::ptr::NonNull::dangling().as_ptr();
|
||||
let slice_ptr = core::ptr::slice_from_raw_parts_mut(ptr, length);
|
||||
return Ok(unsafe { Box::from_raw(slice_ptr) });
|
||||
}
|
||||
let layout = core::alloc::Layout::array::<T>(length).map_err(|_| ())?;
|
||||
let ptr = unsafe { alloc_zeroed(layout) };
|
||||
if ptr.is_null() {
|
||||
// we don't know what the error is because `alloc_zeroed` is a dumb API
|
||||
Err(())
|
||||
} else {
|
||||
let slice =
|
||||
unsafe { core::slice::from_raw_parts_mut(ptr as *mut T, length) };
|
||||
Ok(unsafe { Box::<[T]>::from_raw(slice) })
|
||||
}
|
||||
}
|
||||
|
||||
/// As [`try_zeroed_slice_box`], but unwraps for you.
|
||||
pub fn zeroed_slice_box<T: Zeroable>(length: usize) -> Box<[T]> {
|
||||
try_zeroed_slice_box(length).unwrap()
|
||||
}
|
||||
|
||||
/// Allocates a `Arc<T>` with all contents being zeroed out.
|
||||
#[cfg(all(feature = "alloc_uninit", target_has_atomic = "ptr"))]
|
||||
pub fn zeroed_arc<T: Zeroable>() -> Arc<T> {
|
||||
let mut arc = Arc::new_uninit();
|
||||
crate::write_zeroes(Arc::get_mut(&mut arc).unwrap()); // unwrap never fails for a newly allocated Arc
|
||||
unsafe { arc.assume_init() }
|
||||
}
|
||||
|
||||
/// Allocates a `Arc<[T]>` with all contents being zeroed out.
|
||||
#[cfg(all(feature = "alloc_uninit", target_has_atomic = "ptr"))]
|
||||
pub fn zeroed_arc_slice<T: Zeroable>(length: usize) -> Arc<[T]> {
|
||||
let mut arc = Arc::new_uninit_slice(length);
|
||||
crate::fill_zeroes(Arc::get_mut(&mut arc).unwrap()); // unwrap never fails for a newly allocated Arc
|
||||
unsafe { arc.assume_init() }
|
||||
}
|
||||
|
||||
/// Allocates a `Rc<T>` with all contents being zeroed out.
|
||||
#[cfg(feature = "alloc_uninit")]
|
||||
pub fn zeroed_rc<T: Zeroable>() -> Rc<T> {
|
||||
let mut rc = Rc::new_uninit();
|
||||
crate::write_zeroes(Rc::get_mut(&mut rc).unwrap()); // unwrap never fails for a newly allocated Rc
|
||||
unsafe { rc.assume_init() }
|
||||
}
|
||||
|
||||
/// Allocates a `Rc<[T]>` with all contents being zeroed out.
|
||||
#[cfg(feature = "alloc_uninit")]
|
||||
pub fn zeroed_rc_slice<T: Zeroable>(length: usize) -> Rc<[T]> {
|
||||
let mut rc = Rc::new_uninit_slice(length);
|
||||
crate::fill_zeroes(Rc::get_mut(&mut rc).unwrap()); // unwrap never fails for a newly allocated Rc
|
||||
unsafe { rc.assume_init() }
|
||||
}
|
||||
|
||||
/// As [`try_cast_slice_box`], but unwraps for you.
|
||||
#[inline]
|
||||
pub fn cast_slice_box<A: NoUninit, B: AnyBitPattern>(
|
||||
input: Box<[A]>,
|
||||
) -> Box<[B]> {
|
||||
try_cast_slice_box(input).map_err(|(e, _v)| e).unwrap()
|
||||
}
|
||||
|
||||
/// Attempts to cast the content type of a `Box<[T]>`.
|
||||
///
|
||||
/// On failure you get back an error along with the starting `Box<[T]>`.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// * The start and end content type of the `Box<[T]>` must have the exact same
|
||||
/// alignment.
|
||||
/// * The start and end content size in bytes of the `Box<[T]>` must be the
|
||||
/// exact same.
|
||||
#[inline]
|
||||
pub fn try_cast_slice_box<A: NoUninit, B: AnyBitPattern>(
|
||||
input: Box<[A]>,
|
||||
) -> Result<Box<[B]>, (PodCastError, Box<[A]>)> {
|
||||
if align_of::<A>() != align_of::<B>() {
|
||||
Err((PodCastError::AlignmentMismatch, input))
|
||||
} else if size_of::<A>() != size_of::<B>() {
|
||||
let input_bytes = size_of_val::<[A]>(&*input);
|
||||
if (size_of::<B>() == 0 && input_bytes != 0)
|
||||
|| (size_of::<B>() != 0 && input_bytes % size_of::<B>() != 0)
|
||||
{
|
||||
// If the size in bytes of the underlying buffer does not match an exact
|
||||
// multiple of the size of B, we cannot cast between them.
|
||||
Err((PodCastError::OutputSliceWouldHaveSlop, input))
|
||||
} else {
|
||||
// Because the size is an exact multiple, we can now change the length
|
||||
// of the slice and recreate the Box
|
||||
// NOTE: This is a valid operation because according to the docs of
|
||||
// std::alloc::GlobalAlloc::dealloc(), the Layout that was used to alloc
|
||||
// the block must be the same Layout that is used to dealloc the block.
|
||||
// Luckily, Layout only stores two things, the alignment, and the size in
|
||||
// bytes. So as long as both of those stay the same, the Layout will
|
||||
// remain a valid input to dealloc.
|
||||
let length =
|
||||
if size_of::<B>() != 0 { input_bytes / size_of::<B>() } else { 0 };
|
||||
let box_ptr: *mut A = Box::into_raw(input) as *mut A;
|
||||
let ptr: *mut [B] =
|
||||
unsafe { core::slice::from_raw_parts_mut(box_ptr as *mut B, length) };
|
||||
Ok(unsafe { Box::<[B]>::from_raw(ptr) })
|
||||
}
|
||||
} else {
|
||||
let box_ptr: *mut [A] = Box::into_raw(input);
|
||||
let ptr: *mut [B] = box_ptr as *mut [B];
|
||||
Ok(unsafe { Box::<[B]>::from_raw(ptr) })
|
||||
}
|
||||
}
|
||||
|
||||
/// As [`try_cast_vec`], but unwraps for you.
|
||||
#[inline]
|
||||
pub fn cast_vec<A: NoUninit, B: AnyBitPattern>(input: Vec<A>) -> Vec<B> {
|
||||
try_cast_vec(input).map_err(|(e, _v)| e).unwrap()
|
||||
}
|
||||
|
||||
/// Attempts to cast the content type of a [`Vec`].
|
||||
///
|
||||
/// On failure you get back an error along with the starting `Vec`.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// * The start and end content type of the `Vec` must have the exact same
|
||||
/// alignment.
|
||||
/// * The start and end content size in bytes of the `Vec` must be the exact
|
||||
/// same.
|
||||
/// * The start and end capacity in bytes of the `Vec` must be the exact same.
|
||||
#[inline]
|
||||
pub fn try_cast_vec<A: NoUninit, B: AnyBitPattern>(
|
||||
input: Vec<A>,
|
||||
) -> Result<Vec<B>, (PodCastError, Vec<A>)> {
|
||||
if align_of::<A>() != align_of::<B>() {
|
||||
Err((PodCastError::AlignmentMismatch, input))
|
||||
} else if size_of::<A>() != size_of::<B>() {
|
||||
let input_size = size_of_val::<[A]>(&*input);
|
||||
let input_capacity = input.capacity() * size_of::<A>();
|
||||
if (size_of::<B>() == 0 && input_capacity != 0)
|
||||
|| (size_of::<B>() != 0
|
||||
&& (input_size % size_of::<B>() != 0
|
||||
|| input_capacity % size_of::<B>() != 0))
|
||||
{
|
||||
// If the size in bytes of the underlying buffer does not match an exact
|
||||
// multiple of the size of B, we cannot cast between them.
|
||||
// Note that we have to pay special attention to make sure that both
|
||||
// length and capacity are valid under B, as we do not want to
|
||||
// change which bytes are considered part of the initialized slice
|
||||
// of the Vec
|
||||
Err((PodCastError::OutputSliceWouldHaveSlop, input))
|
||||
} else {
|
||||
// Because the size is an exact multiple, we can now change the length and
|
||||
// capacity and recreate the Vec
|
||||
// NOTE: This is a valid operation because according to the docs of
|
||||
// std::alloc::GlobalAlloc::dealloc(), the Layout that was used to alloc
|
||||
// the block must be the same Layout that is used to dealloc the block.
|
||||
// Luckily, Layout only stores two things, the alignment, and the size in
|
||||
// bytes. So as long as both of those stay the same, the Layout will
|
||||
// remain a valid input to dealloc.
|
||||
|
||||
// Note(Lokathor): First we record the length and capacity, which don't
|
||||
// have any secret provenance metadata.
|
||||
let length: usize =
|
||||
if size_of::<B>() != 0 { input_size / size_of::<B>() } else { 0 };
|
||||
let capacity: usize =
|
||||
if size_of::<B>() != 0 { input_capacity / size_of::<B>() } else { 0 };
|
||||
// Note(Lokathor): Next we "pre-forget" the old Vec by wrapping with
|
||||
// ManuallyDrop, because if we used `core::mem::forget` after taking the
|
||||
// pointer then that would invalidate our pointer. In nightly there's a
|
||||
// "into raw parts" method, which we can switch this too eventually.
|
||||
let mut manual_drop_vec = ManuallyDrop::new(input);
|
||||
let vec_ptr: *mut A = manual_drop_vec.as_mut_ptr();
|
||||
let ptr: *mut B = vec_ptr as *mut B;
|
||||
Ok(unsafe { Vec::from_raw_parts(ptr, length, capacity) })
|
||||
}
|
||||
} else {
|
||||
// Note(Lokathor): First we record the length and capacity, which don't have
|
||||
// any secret provenance metadata.
|
||||
let length: usize = input.len();
|
||||
let capacity: usize = input.capacity();
|
||||
// Note(Lokathor): Next we "pre-forget" the old Vec by wrapping with
|
||||
// ManuallyDrop, because if we used `core::mem::forget` after taking the
|
||||
// pointer then that would invalidate our pointer. In nightly there's a
|
||||
// "into raw parts" method, which we can switch this too eventually.
|
||||
let mut manual_drop_vec = ManuallyDrop::new(input);
|
||||
let vec_ptr: *mut A = manual_drop_vec.as_mut_ptr();
|
||||
let ptr: *mut B = vec_ptr as *mut B;
|
||||
Ok(unsafe { Vec::from_raw_parts(ptr, length, capacity) })
|
||||
}
|
||||
}
|
||||
|
||||
/// This "collects" a slice of pod data into a vec of a different pod type.
|
||||
///
|
||||
/// Unlike with [`cast_slice`] and [`cast_slice_mut`], this will always work.
|
||||
///
|
||||
/// The output vec will be of a minimal size/capacity to hold the slice given.
|
||||
///
|
||||
/// ```rust
|
||||
/// # use bytemuck::*;
|
||||
/// let halfwords: [u16; 4] = [5, 6, 7, 8];
|
||||
/// let vec_of_words: Vec<u32> = pod_collect_to_vec(&halfwords);
|
||||
/// if cfg!(target_endian = "little") {
|
||||
/// assert_eq!(&vec_of_words[..], &[0x0006_0005, 0x0008_0007][..])
|
||||
/// } else {
|
||||
/// assert_eq!(&vec_of_words[..], &[0x0005_0006, 0x0007_0008][..])
|
||||
/// }
|
||||
/// ```
|
||||
pub fn pod_collect_to_vec<A: NoUninit, B: NoUninit + AnyBitPattern>(
|
||||
src: &[A],
|
||||
) -> Vec<B> {
|
||||
let src_size = core::mem::size_of_val(src);
|
||||
// Note(Lokathor): dst_count is rounded up so that the dest will always be at
|
||||
// least as many bytes as the src.
|
||||
let dst_count = src_size / size_of::<B>()
|
||||
+ if src_size % size_of::<B>() != 0 { 1 } else { 0 };
|
||||
let mut dst = vec![B::zeroed(); dst_count];
|
||||
|
||||
let src_bytes: &[u8] = cast_slice(src);
|
||||
let dst_bytes: &mut [u8] = cast_slice_mut(&mut dst[..]);
|
||||
dst_bytes[..src_size].copy_from_slice(src_bytes);
|
||||
dst
|
||||
}
|
||||
|
||||
/// As [`try_cast_rc`], but unwraps for you.
|
||||
#[inline]
|
||||
pub fn cast_rc<A: NoUninit + AnyBitPattern, B: NoUninit + AnyBitPattern>(
|
||||
input: Rc<A>,
|
||||
) -> Rc<B> {
|
||||
try_cast_rc(input).map_err(|(e, _v)| e).unwrap()
|
||||
}
|
||||
|
||||
/// Attempts to cast the content type of a [`Rc`].
|
||||
///
|
||||
/// On failure you get back an error along with the starting `Rc`.
|
||||
///
|
||||
/// The bounds on this function are the same as [`cast_mut`], because a user
|
||||
/// could call `Rc::get_unchecked_mut` on the output, which could be observable
|
||||
/// in the input.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// * The start and end content type of the `Rc` must have the exact same
|
||||
/// alignment.
|
||||
/// * The start and end size of the `Rc` must have the exact same size.
|
||||
#[inline]
|
||||
pub fn try_cast_rc<A: NoUninit + AnyBitPattern, B: NoUninit + AnyBitPattern>(
|
||||
input: Rc<A>,
|
||||
) -> Result<Rc<B>, (PodCastError, Rc<A>)> {
|
||||
if align_of::<A>() != align_of::<B>() {
|
||||
Err((PodCastError::AlignmentMismatch, input))
|
||||
} else if size_of::<A>() != size_of::<B>() {
|
||||
Err((PodCastError::SizeMismatch, input))
|
||||
} else {
|
||||
// Safety: Rc::from_raw requires size and alignment match, which is met.
|
||||
let ptr: *const B = Rc::into_raw(input) as *const B;
|
||||
Ok(unsafe { Rc::from_raw(ptr) })
|
||||
}
|
||||
}
|
||||
|
||||
/// As [`try_cast_arc`], but unwraps for you.
|
||||
#[inline]
|
||||
#[cfg(target_has_atomic = "ptr")]
|
||||
pub fn cast_arc<A: NoUninit + AnyBitPattern, B: NoUninit + AnyBitPattern>(
|
||||
input: Arc<A>,
|
||||
) -> Arc<B> {
|
||||
try_cast_arc(input).map_err(|(e, _v)| e).unwrap()
|
||||
}
|
||||
|
||||
/// Attempts to cast the content type of a [`Arc`].
|
||||
///
|
||||
/// On failure you get back an error along with the starting `Arc`.
|
||||
///
|
||||
/// The bounds on this function are the same as [`cast_mut`], because a user
|
||||
/// could call `Rc::get_unchecked_mut` on the output, which could be observable
|
||||
/// in the input.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// * The start and end content type of the `Arc` must have the exact same
|
||||
/// alignment.
|
||||
/// * The start and end size of the `Arc` must have the exact same size.
|
||||
#[inline]
|
||||
#[cfg(target_has_atomic = "ptr")]
|
||||
pub fn try_cast_arc<
|
||||
A: NoUninit + AnyBitPattern,
|
||||
B: NoUninit + AnyBitPattern,
|
||||
>(
|
||||
input: Arc<A>,
|
||||
) -> Result<Arc<B>, (PodCastError, Arc<A>)> {
|
||||
if align_of::<A>() != align_of::<B>() {
|
||||
Err((PodCastError::AlignmentMismatch, input))
|
||||
} else if size_of::<A>() != size_of::<B>() {
|
||||
Err((PodCastError::SizeMismatch, input))
|
||||
} else {
|
||||
// Safety: Arc::from_raw requires size and alignment match, which is met.
|
||||
let ptr: *const B = Arc::into_raw(input) as *const B;
|
||||
Ok(unsafe { Arc::from_raw(ptr) })
|
||||
}
|
||||
}
|
||||
|
||||
/// As [`try_cast_slice_rc`], but unwraps for you.
|
||||
#[inline]
|
||||
pub fn cast_slice_rc<
|
||||
A: NoUninit + AnyBitPattern,
|
||||
B: NoUninit + AnyBitPattern,
|
||||
>(
|
||||
input: Rc<[A]>,
|
||||
) -> Rc<[B]> {
|
||||
try_cast_slice_rc(input).map_err(|(e, _v)| e).unwrap()
|
||||
}
|
||||
|
||||
/// Attempts to cast the content type of a `Rc<[T]>`.
|
||||
///
|
||||
/// On failure you get back an error along with the starting `Rc<[T]>`.
|
||||
///
|
||||
/// The bounds on this function are the same as [`cast_mut`], because a user
|
||||
/// could call `Rc::get_unchecked_mut` on the output, which could be observable
|
||||
/// in the input.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// * The start and end content type of the `Rc<[T]>` must have the exact same
|
||||
/// alignment.
|
||||
/// * The start and end content size in bytes of the `Rc<[T]>` must be the exact
|
||||
/// same.
|
||||
#[inline]
|
||||
pub fn try_cast_slice_rc<
|
||||
A: NoUninit + AnyBitPattern,
|
||||
B: NoUninit + AnyBitPattern,
|
||||
>(
|
||||
input: Rc<[A]>,
|
||||
) -> Result<Rc<[B]>, (PodCastError, Rc<[A]>)> {
|
||||
if align_of::<A>() != align_of::<B>() {
|
||||
Err((PodCastError::AlignmentMismatch, input))
|
||||
} else if size_of::<A>() != size_of::<B>() {
|
||||
let input_bytes = size_of_val::<[A]>(&*input);
|
||||
if (size_of::<B>() == 0 && input_bytes != 0)
|
||||
|| (size_of::<B>() != 0 && input_bytes % size_of::<B>() != 0)
|
||||
{
|
||||
// If the size in bytes of the underlying buffer does not match an exact
|
||||
// multiple of the size of B, we cannot cast between them.
|
||||
Err((PodCastError::OutputSliceWouldHaveSlop, input))
|
||||
} else {
|
||||
// Because the size is an exact multiple, we can now change the length
|
||||
// of the slice and recreate the Rc
|
||||
// NOTE: This is a valid operation because according to the docs of
|
||||
// std::rc::Rc::from_raw(), the type U that was in the original Rc<U>
|
||||
// acquired from Rc::into_raw() must have the same size alignment and
|
||||
// size of the type T in the new Rc<T>. So as long as both the size
|
||||
// and alignment stay the same, the Rc will remain a valid Rc.
|
||||
let length =
|
||||
if size_of::<B>() != 0 { input_bytes / size_of::<B>() } else { 0 };
|
||||
let rc_ptr: *const A = Rc::into_raw(input) as *const A;
|
||||
// Must use ptr::slice_from_raw_parts, because we cannot make an
|
||||
// intermediate const reference, because it has mutable provenance,
|
||||
// nor an intermediate mutable reference, because it could be aliased.
|
||||
let ptr = core::ptr::slice_from_raw_parts(rc_ptr as *const B, length);
|
||||
Ok(unsafe { Rc::<[B]>::from_raw(ptr) })
|
||||
}
|
||||
} else {
|
||||
let rc_ptr: *const [A] = Rc::into_raw(input);
|
||||
let ptr: *const [B] = rc_ptr as *const [B];
|
||||
Ok(unsafe { Rc::<[B]>::from_raw(ptr) })
|
||||
}
|
||||
}
|
||||
|
||||
/// As [`try_cast_slice_arc`], but unwraps for you.
|
||||
#[inline]
|
||||
#[cfg(target_has_atomic = "ptr")]
|
||||
pub fn cast_slice_arc<
|
||||
A: NoUninit + AnyBitPattern,
|
||||
B: NoUninit + AnyBitPattern,
|
||||
>(
|
||||
input: Arc<[A]>,
|
||||
) -> Arc<[B]> {
|
||||
try_cast_slice_arc(input).map_err(|(e, _v)| e).unwrap()
|
||||
}
|
||||
|
||||
/// Attempts to cast the content type of a `Arc<[T]>`.
|
||||
///
|
||||
/// On failure you get back an error along with the starting `Arc<[T]>`.
|
||||
///
|
||||
/// The bounds on this function are the same as [`cast_mut`], because a user
|
||||
/// could call `Rc::get_unchecked_mut` on the output, which could be observable
|
||||
/// in the input.
|
||||
///
|
||||
/// ## Failure
|
||||
///
|
||||
/// * The start and end content type of the `Arc<[T]>` must have the exact same
|
||||
/// alignment.
|
||||
/// * The start and end content size in bytes of the `Arc<[T]>` must be the
|
||||
/// exact same.
|
||||
#[inline]
|
||||
#[cfg(target_has_atomic = "ptr")]
|
||||
pub fn try_cast_slice_arc<
|
||||
A: NoUninit + AnyBitPattern,
|
||||
B: NoUninit + AnyBitPattern,
|
||||
>(
|
||||
input: Arc<[A]>,
|
||||
) -> Result<Arc<[B]>, (PodCastError, Arc<[A]>)> {
|
||||
if align_of::<A>() != align_of::<B>() {
|
||||
Err((PodCastError::AlignmentMismatch, input))
|
||||
} else if size_of::<A>() != size_of::<B>() {
|
||||
let input_bytes = size_of_val::<[A]>(&*input);
|
||||
if (size_of::<B>() == 0 && input_bytes != 0)
|
||||
|| (size_of::<B>() != 0 && input_bytes % size_of::<B>() != 0)
|
||||
{
|
||||
// If the size in bytes of the underlying buffer does not match an exact
|
||||
// multiple of the size of B, we cannot cast between them.
|
||||
Err((PodCastError::OutputSliceWouldHaveSlop, input))
|
||||
} else {
|
||||
// Because the size is an exact multiple, we can now change the length
|
||||
// of the slice and recreate the Arc
|
||||
// NOTE: This is a valid operation because according to the docs of
|
||||
// std::sync::Arc::from_raw(), the type U that was in the original Arc<U>
|
||||
// acquired from Arc::into_raw() must have the same size alignment and
|
||||
// size of the type T in the new Arc<T>. So as long as both the size
|
||||
// and alignment stay the same, the Arc will remain a valid Arc.
|
||||
let length =
|
||||
if size_of::<B>() != 0 { input_bytes / size_of::<B>() } else { 0 };
|
||||
let arc_ptr: *const A = Arc::into_raw(input) as *const A;
|
||||
// Must use ptr::slice_from_raw_parts, because we cannot make an
|
||||
// intermediate const reference, because it has mutable provenance,
|
||||
// nor an intermediate mutable reference, because it could be aliased.
|
||||
let ptr = core::ptr::slice_from_raw_parts(arc_ptr as *const B, length);
|
||||
Ok(unsafe { Arc::<[B]>::from_raw(ptr) })
|
||||
}
|
||||
} else {
|
||||
let arc_ptr: *const [A] = Arc::into_raw(input);
|
||||
let ptr: *const [B] = arc_ptr as *const [B];
|
||||
Ok(unsafe { Arc::<[B]>::from_raw(ptr) })
|
||||
}
|
||||
}
|
||||
|
||||
/// An extension trait for `TransparentWrapper` and alloc types.
|
||||
pub trait TransparentWrapperAlloc<Inner: ?Sized>:
|
||||
TransparentWrapper<Inner>
|
||||
{
|
||||
/// Convert a vec of the inner type into a vec of the wrapper type.
|
||||
fn wrap_vec(s: Vec<Inner>) -> Vec<Self>
|
||||
where
|
||||
Self: Sized,
|
||||
Inner: Sized,
|
||||
{
|
||||
let mut s = ManuallyDrop::new(s);
|
||||
|
||||
let length = s.len();
|
||||
let capacity = s.capacity();
|
||||
let ptr = s.as_mut_ptr();
|
||||
|
||||
unsafe {
|
||||
// SAFETY:
|
||||
// * ptr comes from Vec (and will not be double-dropped)
|
||||
// * the two types have the identical representation
|
||||
// * the len and capacity fields are valid
|
||||
Vec::from_raw_parts(ptr as *mut Self, length, capacity)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert a box to the inner type into a box to the wrapper
|
||||
/// type.
|
||||
#[inline]
|
||||
fn wrap_box(s: Box<Inner>) -> Box<Self> {
|
||||
// The unsafe contract requires that these two have
|
||||
// identical representations, and thus identical pointer metadata.
|
||||
// Assert that Self and Inner have the same pointer size,
|
||||
// which is the best we can do to assert their metadata is the same type
|
||||
// on stable.
|
||||
assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
|
||||
|
||||
unsafe {
|
||||
// A pointer cast doesn't work here because rustc can't tell that
|
||||
// the vtables match (because of the `?Sized` restriction relaxation).
|
||||
// A `transmute` doesn't work because the sizes are unspecified.
|
||||
//
|
||||
// SAFETY:
|
||||
// * The unsafe contract requires that pointers to Inner and Self have
|
||||
// identical representations
|
||||
// * Box is guaranteed to have representation identical to a (non-null)
|
||||
// pointer
|
||||
// * The pointer comes from a box (and thus satisfies all safety
|
||||
// requirements of Box)
|
||||
let inner_ptr: *mut Inner = Box::into_raw(s);
|
||||
let wrapper_ptr: *mut Self = transmute!(inner_ptr);
|
||||
Box::from_raw(wrapper_ptr)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert an [`Rc`] to the inner type into an `Rc` to the wrapper type.
|
||||
#[inline]
|
||||
fn wrap_rc(s: Rc<Inner>) -> Rc<Self> {
|
||||
// The unsafe contract requires that these two have
|
||||
// identical representations, and thus identical pointer metadata.
|
||||
// Assert that Self and Inner have the same pointer size,
|
||||
// which is the best we can do to assert their metadata is the same type
|
||||
// on stable.
|
||||
assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
|
||||
|
||||
unsafe {
|
||||
// A pointer cast doesn't work here because rustc can't tell that
|
||||
// the vtables match (because of the `?Sized` restriction relaxation).
|
||||
// A `transmute` doesn't work because the layout of Rc is unspecified.
|
||||
//
|
||||
// SAFETY:
|
||||
// * The unsafe contract requires that pointers to Inner and Self have
|
||||
// identical representations, and that the size and alignment of Inner
|
||||
// and Self are the same, which meets the safety requirements of
|
||||
// Rc::from_raw
|
||||
let inner_ptr: *const Inner = Rc::into_raw(s);
|
||||
let wrapper_ptr: *const Self = transmute!(inner_ptr);
|
||||
Rc::from_raw(wrapper_ptr)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert an [`Arc`] to the inner type into an `Arc` to the wrapper type.
|
||||
#[inline]
|
||||
#[cfg(target_has_atomic = "ptr")]
|
||||
fn wrap_arc(s: Arc<Inner>) -> Arc<Self> {
|
||||
// The unsafe contract requires that these two have
|
||||
// identical representations, and thus identical pointer metadata.
|
||||
// Assert that Self and Inner have the same pointer size,
|
||||
// which is the best we can do to assert their metadata is the same type
|
||||
// on stable.
|
||||
assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
|
||||
|
||||
unsafe {
|
||||
// A pointer cast doesn't work here because rustc can't tell that
|
||||
// the vtables match (because of the `?Sized` restriction relaxation).
|
||||
// A `transmute` doesn't work because the layout of Arc is unspecified.
|
||||
//
|
||||
// SAFETY:
|
||||
// * The unsafe contract requires that pointers to Inner and Self have
|
||||
// identical representations, and that the size and alignment of Inner
|
||||
// and Self are the same, which meets the safety requirements of
|
||||
// Arc::from_raw
|
||||
let inner_ptr: *const Inner = Arc::into_raw(s);
|
||||
let wrapper_ptr: *const Self = transmute!(inner_ptr);
|
||||
Arc::from_raw(wrapper_ptr)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert a vec of the wrapper type into a vec of the inner type.
|
||||
fn peel_vec(s: Vec<Self>) -> Vec<Inner>
|
||||
where
|
||||
Self: Sized,
|
||||
Inner: Sized,
|
||||
{
|
||||
let mut s = ManuallyDrop::new(s);
|
||||
|
||||
let length = s.len();
|
||||
let capacity = s.capacity();
|
||||
let ptr = s.as_mut_ptr();
|
||||
|
||||
unsafe {
|
||||
// SAFETY:
|
||||
// * ptr comes from Vec (and will not be double-dropped)
|
||||
// * the two types have the identical representation
|
||||
// * the len and capacity fields are valid
|
||||
Vec::from_raw_parts(ptr as *mut Inner, length, capacity)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert a box to the wrapper type into a box to the inner
|
||||
/// type.
|
||||
#[inline]
|
||||
fn peel_box(s: Box<Self>) -> Box<Inner> {
|
||||
// The unsafe contract requires that these two have
|
||||
// identical representations, and thus identical pointer metadata.
|
||||
// Assert that Self and Inner have the same pointer size,
|
||||
// which is the best we can do to assert their metadata is the same type
|
||||
// on stable.
|
||||
assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
|
||||
|
||||
unsafe {
|
||||
// A pointer cast doesn't work here because rustc can't tell that
|
||||
// the vtables match (because of the `?Sized` restriction relaxation).
|
||||
// A `transmute` doesn't work because the sizes are unspecified.
|
||||
//
|
||||
// SAFETY:
|
||||
// * The unsafe contract requires that pointers to Inner and Self have
|
||||
// identical representations
|
||||
// * Box is guaranteed to have representation identical to a (non-null)
|
||||
// pointer
|
||||
// * The pointer comes from a box (and thus satisfies all safety
|
||||
// requirements of Box)
|
||||
let wrapper_ptr: *mut Self = Box::into_raw(s);
|
||||
let inner_ptr: *mut Inner = transmute!(wrapper_ptr);
|
||||
Box::from_raw(inner_ptr)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert an [`Rc`] to the wrapper type into an `Rc` to the inner type.
|
||||
#[inline]
|
||||
fn peel_rc(s: Rc<Self>) -> Rc<Inner> {
|
||||
// The unsafe contract requires that these two have
|
||||
// identical representations, and thus identical pointer metadata.
|
||||
// Assert that Self and Inner have the same pointer size,
|
||||
// which is the best we can do to assert their metadata is the same type
|
||||
// on stable.
|
||||
assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
|
||||
|
||||
unsafe {
|
||||
// A pointer cast doesn't work here because rustc can't tell that
|
||||
// the vtables match (because of the `?Sized` restriction relaxation).
|
||||
// A `transmute` doesn't work because the layout of Rc is unspecified.
|
||||
//
|
||||
// SAFETY:
|
||||
// * The unsafe contract requires that pointers to Inner and Self have
|
||||
// identical representations, and that the size and alignment of Inner
|
||||
// and Self are the same, which meets the safety requirements of
|
||||
// Rc::from_raw
|
||||
let wrapper_ptr: *const Self = Rc::into_raw(s);
|
||||
let inner_ptr: *const Inner = transmute!(wrapper_ptr);
|
||||
Rc::from_raw(inner_ptr)
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert an [`Arc`] to the wrapper type into an `Arc` to the inner type.
|
||||
#[inline]
|
||||
#[cfg(target_has_atomic = "ptr")]
|
||||
fn peel_arc(s: Arc<Self>) -> Arc<Inner> {
|
||||
// The unsafe contract requires that these two have
|
||||
// identical representations, and thus identical pointer metadata.
|
||||
// Assert that Self and Inner have the same pointer size,
|
||||
// which is the best we can do to assert their metadata is the same type
|
||||
// on stable.
|
||||
assert!(size_of::<*mut Inner>() == size_of::<*mut Self>());
|
||||
|
||||
unsafe {
|
||||
// A pointer cast doesn't work here because rustc can't tell that
|
||||
// the vtables match (because of the `?Sized` restriction relaxation).
|
||||
// A `transmute` doesn't work because the layout of Arc is unspecified.
|
||||
//
|
||||
// SAFETY:
|
||||
// * The unsafe contract requires that pointers to Inner and Self have
|
||||
// identical representations, and that the size and alignment of Inner
|
||||
// and Self are the same, which meets the safety requirements of
|
||||
// Arc::from_raw
|
||||
let wrapper_ptr: *const Self = Arc::into_raw(s);
|
||||
let inner_ptr: *const Inner = transmute!(wrapper_ptr);
|
||||
Arc::from_raw(inner_ptr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: ?Sized, T: ?Sized + TransparentWrapper<I>> TransparentWrapperAlloc<I>
|
||||
for T
|
||||
{
|
||||
}
|
||||
|
||||
/// As `Box<[u8]>`, but remembers the original alignment.
|
||||
pub struct BoxBytes {
|
||||
// SAFETY: `ptr` is aligned to `layout.align()`, points to
|
||||
// `layout.size()` initialized bytes, and, if `layout.size() > 0`,
|
||||
// is owned and was allocated with the global allocator with `layout`.
|
||||
ptr: NonNull<u8>,
|
||||
layout: Layout,
|
||||
}
|
||||
|
||||
// SAFETY: `BoxBytes` is semantically a `Box<[u8], Global>` with a different allocation alignment,
|
||||
// `Box<[u8], Global>` is `Send + Sync`, and changing the allocation alignment has no thread-safety implications.
|
||||
unsafe impl Send for BoxBytes {}
|
||||
// SAFETY: See `Send` impl
|
||||
unsafe impl Sync for BoxBytes {}
|
||||
|
||||
impl Deref for BoxBytes {
|
||||
type Target = [u8];
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
// SAFETY: See type invariant.
|
||||
unsafe {
|
||||
core::slice::from_raw_parts(self.ptr.as_ptr(), self.layout.size())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl DerefMut for BoxBytes {
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
// SAFETY: See type invariant.
|
||||
unsafe {
|
||||
core::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.layout.size())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for BoxBytes {
|
||||
fn drop(&mut self) {
|
||||
if self.layout.size() != 0 {
|
||||
// SAFETY: See type invariant: if `self.layout.size() != 0`, then
|
||||
// `self.ptr` is owned and was allocated with `self.layout`.
|
||||
unsafe { alloc::alloc::dealloc(self.ptr.as_ptr(), self.layout) };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: ?Sized + sealed::BoxBytesOf> From<Box<T>> for BoxBytes {
|
||||
fn from(value: Box<T>) -> Self {
|
||||
value.box_bytes_of()
|
||||
}
|
||||
}
|
||||
|
||||
mod sealed {
|
||||
use crate::{BoxBytes, PodCastError};
|
||||
use alloc::boxed::Box;
|
||||
|
||||
pub trait BoxBytesOf {
|
||||
fn box_bytes_of(self: Box<Self>) -> BoxBytes;
|
||||
}
|
||||
|
||||
pub trait FromBoxBytes {
|
||||
fn try_from_box_bytes(
|
||||
bytes: BoxBytes,
|
||||
) -> Result<Box<Self>, (PodCastError, BoxBytes)>;
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NoUninit> sealed::BoxBytesOf for T {
|
||||
fn box_bytes_of(self: Box<Self>) -> BoxBytes {
|
||||
let layout = Layout::new::<T>();
|
||||
let ptr = Box::into_raw(self) as *mut u8;
|
||||
// SAFETY: Box::into_raw() returns a non-null pointer.
|
||||
let ptr = unsafe { NonNull::new_unchecked(ptr) };
|
||||
BoxBytes { ptr, layout }
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: NoUninit> sealed::BoxBytesOf for [T] {
|
||||
fn box_bytes_of(self: Box<Self>) -> BoxBytes {
|
||||
let layout = Layout::for_value::<[T]>(&self);
|
||||
let ptr = Box::into_raw(self) as *mut u8;
|
||||
// SAFETY: Box::into_raw() returns a non-null pointer.
|
||||
let ptr = unsafe { NonNull::new_unchecked(ptr) };
|
||||
BoxBytes { ptr, layout }
|
||||
}
|
||||
}
|
||||
|
||||
impl sealed::BoxBytesOf for str {
|
||||
fn box_bytes_of(self: Box<Self>) -> BoxBytes {
|
||||
self.into_boxed_bytes().box_bytes_of()
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: AnyBitPattern> sealed::FromBoxBytes for T {
|
||||
fn try_from_box_bytes(
|
||||
bytes: BoxBytes,
|
||||
) -> Result<Box<Self>, (PodCastError, BoxBytes)> {
|
||||
let layout = Layout::new::<T>();
|
||||
if bytes.layout.align() != layout.align() {
|
||||
Err((PodCastError::AlignmentMismatch, bytes))
|
||||
} else if bytes.layout.size() != layout.size() {
|
||||
Err((PodCastError::SizeMismatch, bytes))
|
||||
} else {
|
||||
let (ptr, _) = bytes.into_raw_parts();
|
||||
// SAFETY: See BoxBytes type invariant.
|
||||
Ok(unsafe { Box::from_raw(ptr.as_ptr() as *mut T) })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: AnyBitPattern> sealed::FromBoxBytes for [T] {
|
||||
fn try_from_box_bytes(
|
||||
bytes: BoxBytes,
|
||||
) -> Result<Box<Self>, (PodCastError, BoxBytes)> {
|
||||
let single_layout = Layout::new::<T>();
|
||||
if bytes.layout.align() != single_layout.align() {
|
||||
Err((PodCastError::AlignmentMismatch, bytes))
|
||||
} else if (single_layout.size() == 0 && bytes.layout.size() != 0)
|
||||
|| (single_layout.size() != 0
|
||||
&& bytes.layout.size() % single_layout.size() != 0)
|
||||
{
|
||||
Err((PodCastError::OutputSliceWouldHaveSlop, bytes))
|
||||
} else {
|
||||
let (ptr, layout) = bytes.into_raw_parts();
|
||||
let length = if single_layout.size() != 0 {
|
||||
layout.size() / single_layout.size()
|
||||
} else {
|
||||
0
|
||||
};
|
||||
let ptr =
|
||||
core::ptr::slice_from_raw_parts_mut(ptr.as_ptr() as *mut T, length);
|
||||
// SAFETY: See BoxBytes type invariant.
|
||||
Ok(unsafe { Box::from_raw(ptr) })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Re-interprets `Box<T>` as `BoxBytes`.
|
||||
///
|
||||
/// `T` must be either [`Sized`] and [`NoUninit`],
|
||||
/// [`[U]`](slice) where `U: NoUninit`, or [`str`].
|
||||
#[inline]
|
||||
pub fn box_bytes_of<T: sealed::BoxBytesOf + ?Sized>(input: Box<T>) -> BoxBytes {
|
||||
input.box_bytes_of()
|
||||
}
|
||||
|
||||
/// Re-interprets `BoxBytes` as `Box<T>`.
|
||||
///
|
||||
/// `T` must be either [`Sized`] + [`AnyBitPattern`], or
|
||||
/// [`[U]`](slice) where `U: AnyBitPattern`.
|
||||
///
|
||||
/// ## Panics
|
||||
///
|
||||
/// This is [`try_from_box_bytes`] but will panic on error and the input will be
|
||||
/// dropped.
|
||||
#[inline]
|
||||
#[cfg_attr(feature = "track_caller", track_caller)]
|
||||
pub fn from_box_bytes<T: sealed::FromBoxBytes + ?Sized>(
|
||||
input: BoxBytes,
|
||||
) -> Box<T> {
|
||||
try_from_box_bytes(input).map_err(|(error, _)| error).unwrap()
|
||||
}
|
||||
|
||||
/// Re-interprets `BoxBytes` as `Box<T>`.
|
||||
///
|
||||
/// `T` must be either [`Sized`] + [`AnyBitPattern`], or
|
||||
/// [`[U]`](slice) where `U: AnyBitPattern`.
|
||||
///
|
||||
/// Returns `Err`:
|
||||
/// * If the input isn't aligned for `T`.
|
||||
/// * If `T: Sized` and the input's length isn't exactly the size of `T`.
|
||||
/// * If `T = [U]` and the input's length isn't exactly a multiple of the size
|
||||
/// of `U`.
|
||||
#[inline]
|
||||
pub fn try_from_box_bytes<T: sealed::FromBoxBytes + ?Sized>(
|
||||
input: BoxBytes,
|
||||
) -> Result<Box<T>, (PodCastError, BoxBytes)> {
|
||||
T::try_from_box_bytes(input)
|
||||
}
|
||||
|
||||
impl BoxBytes {
|
||||
/// Constructs a `BoxBytes` from its raw parts.
|
||||
///
|
||||
/// # Safety
|
||||
///
|
||||
/// The pointer is owned, has been allocated with the provided layout, and
|
||||
/// points to `layout.size()` initialized bytes.
|
||||
pub unsafe fn from_raw_parts(ptr: NonNull<u8>, layout: Layout) -> Self {
|
||||
BoxBytes { ptr, layout }
|
||||
}
|
||||
|
||||
/// Deconstructs a `BoxBytes` into its raw parts.
|
||||
///
|
||||
/// The pointer is owned, has been allocated with the provided layout, and
|
||||
/// points to `layout.size()` initialized bytes.
|
||||
pub fn into_raw_parts(self) -> (NonNull<u8>, Layout) {
|
||||
let me = ManuallyDrop::new(self);
|
||||
(me.ptr, me.layout)
|
||||
}
|
||||
|
||||
/// Returns the original layout.
|
||||
pub fn layout(&self) -> Layout {
|
||||
self.layout
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user