use core::marker::PhantomData;
use core::ptr::NonNull;
#[repr(C, packed(4))]
pub struct PackedSlice<'a, T> {
ptr: NonNull<T>,
len: u32,
_marker: PhantomData<&'a [T]>,
}
impl<T> Clone for PackedSlice<'_, T> {
#[inline]
fn clone(&self) -> Self {
*self
}
}
impl<T> Copy for PackedSlice<'_, T> {}
unsafe impl<T: Sync> Send for PackedSlice<'_, T> {}
unsafe impl<T: Sync> Sync for PackedSlice<'_, T> {}
impl<'a, T> PackedSlice<'a, T> {
#[inline]
pub fn new(slice: &'a [T]) -> Self {
debug_assert!(u32::try_from(slice.len()).is_ok());
Self {
ptr: NonNull::from(slice).cast(),
len: slice.len() as u32,
_marker: PhantomData,
}
}
#[inline]
pub fn as_slice(self) -> &'a [T] {
let (ptr, len) = (self.ptr, self.len);
unsafe { core::slice::from_raw_parts(ptr.as_ptr(), len as usize) }
}
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(target_pointer_width = "64")]
const _: () = {
use core::mem::{align_of, size_of};
use crate::{MapView, ProtoBytes, ProtoStr};
assert!(
size_of::<PackedSlice<'_, u64>>() == 12
&& align_of::<PackedSlice<'_, u64>>() == 4
&& size_of::<Option<PackedSlice<'_, u8>>>() == 12
&& size_of::<ProtoStr<'_>>() == 12
&& size_of::<Option<ProtoStr<'_>>>() == 12
&& size_of::<ProtoBytes<'_>>() == 12
&& size_of::<Option<ProtoBytes<'_>>>() == 12
&& size_of::<MapView<'_, u8, u8>>() == 12
)
};
fn _covariant<'a: 'b, 'b>(s: PackedSlice<'a, &'a u8>) -> PackedSlice<'b, &'b u8> {
s
}
#[test]
fn round_trips_the_slice() {
let data = [1u64, 2, 3];
let s = PackedSlice::new(&data[1..]);
assert_eq!(s.as_slice(), &[2, 3]);
assert_eq!(s.as_slice().as_ptr(), data[1..].as_ptr());
assert!(PackedSlice::new(&data[..0]).as_slice().is_empty());
}
#[test]
fn under_aligned_cells_keep_an_aligned_pointer() {
#[repr(align(16))]
#[derive(Debug, PartialEq)]
struct Wide(u8);
let data = [Wide(1), Wide(2)];
let cells = [PackedSlice::new(&data[..1]), PackedSlice::new(&data[1..])];
for (cell, want) in cells.iter().zip([1u8, 2]) {
let s: &[Wide] = cell.as_slice();
assert_eq!(s.as_ptr().addr() % 16, 0);
assert_eq!(s, &[Wide(want)]);
}
}
}