Struct ExternalSlice 

#[repr(C)]
pub struct ExternalSlice<T: 'static> {
    ptr: NonNull<T>,
    len: usize,
    capacity: usize,
}

A slice stored as a standalone struct, suitable for wrapping in ExternalPtr.

This is analogous to the data inside a Box<[T]>, but stores capacity for proper deallocation when created from a Vec.

Usage

To use with ExternalPtr, implement TypedExternal for your specific ExternalSlice<YourType>:

impl_typed_external!(ExternalSlice<MyElement>);
let ptr = ExternalPtr::new(ExternalSlice::new(vec![1, 2, 3]));

Fields

ptr: NonNull<T>

len: usize

capacity: usize

Implementations

impl<T: 'static> ExternalSlice<T>

pub fn new(slice: Vec<T>) -> Self

Create an external slice from a Vec, preserving its allocation.

pub fn from_boxed(boxed: Box<[T]>) -> Self

Create from a boxed slice (capacity == len).

pub fn as_slice(&self) -> &[T]

Borrow the contents as a shared slice.

pub fn as_mut_slice(&mut self) -> &mut [T]

Borrow the contents as a mutable slice.

pub fn len(&self) -> usize

Number of elements in the slice.

pub fn is_empty(&self) -> bool

Returns true if the slice is empty.

pub fn capacity(&self) -> usize

Capacity of the underlying allocation.

Trait Implementations

impl<T: 'static> Drop for ExternalSlice<T>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes