Struct SliceWithHeader

#[repr(C)]
pub struct SliceWithHeader<Header, Item> {
    pub header: Header,
    pub slice: [Item],
    /* private fields */
}

A custom slice-based DST.

The length is stored as a usize at offset 0. This must be the length of the trailing slice of the DST.

Fields

header: Header

The included header. Does not dictate the slice length.

slice: [Item]

The included slice.

Implementations

impl<Header, Item> SliceWithHeader<Header, Item>

pub fn new<A, I>(header: Header, items: I) -> A

where A: AllocSliceDst<Self>, I: IntoIterator<Item = Item>, I::IntoIter: ExactSizeIterator,

Create a new slice/header DST in a AllocSliceDst container.

Panics

Panics if the items iterator incorrectly reports its length.

pub fn from_slice<A>(header: Header, s: &[Item]) -> A

where A: AllocSliceDst<Self>, Item: Copy,

Create a new slice/header DST from a slice, in a AllocSliceDst container.

Trait Implementations

impl<Header, Item> Clone for Box<SliceWithHeader<Header, Item>>

where Header: Clone, Item: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Header: Debug, Item: Debug> Debug for SliceWithHeader<Header, Item>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Header, Item> Erasable for SliceWithHeader<Header, Item>

const ACK_1_1_0: bool = true

Whether this implementor has acknowledged the 1.1.0 update to unerase’s documented implementation requirements.

unsafe fn unerase(this: ErasedPtr) -> NonNull<Self>

Unerase this erased pointer.

fn erase(this: NonNull<Self>) -> NonNull<Erased>

Turn this erasable pointer into an erased pointer.

impl<Header: Hash, Item: Hash> Hash for SliceWithHeader<Header, Item>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

impl<Header: PartialEq, Item: PartialEq> PartialEq for SliceWithHeader<Header, Item>

fn eq(&self, other: &SliceWithHeader<Header, Item>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Header, Item> SliceDst for SliceWithHeader<Header, Item>

fn layout_for(len: usize) -> Layout

Get the layout of the slice-containing type with the given slice length.

fn retype(ptr: NonNull<[()]>) -> NonNull<Self>

Add the type onto an untyped pointer.

impl<Header: Eq, Item: Eq> Eq for SliceWithHeader<Header, Item>

impl<Header, Item> StructuralPartialEq for SliceWithHeader<Header, Item>