Struct stack_dst::ValueA

pub struct ValueA<T: ?Sized, D: DataBuf> { /* fields omitted */ }

Stack-allocated dynamically sized type

T is the unsized type contained. D is the buffer used to hold the unsized type (both data and metadata).

Implementations

impl<T: ?Sized, D: DataBuf> ValueA<T, D>

pub fn new<U: Unsize<T>>(val: U) -> Result<ValueA<T, D>, U>

Construct a stack-based DST

Returns Ok(dst) if the allocation was successful, or Err(val) if it failed

pub fn new_stable<U, F: FnOnce(&U) -> &T>(
    val: U,
    get_ref: F
) -> Result<ValueA<T, D>, U>

Construct a stack-based DST (without needing Unsize)

Returns Ok(dst) if the allocation was successful, or Err(val) if it failed

pub fn new_or_boxed<U>(val: U) -> ValueA<T, D> where
    U: Unsize<T>,
    Box<U>: Unsize<T>, 

Construct a stack-based DST, falling back on boxing if the value doesn’t fit

use stack_dst::ValueA;
use core::fmt::Debug;
let val = [1usize, 2, 3, 4];
assert!( ValueA::<dyn Debug, [usize; 2]>::new(val).is_err() );
let v = ValueA::<dyn Debug, [usize; 2]>::new_or_boxed(val);
println!("v = {:?}", v);

pub unsafe fn new_raw(
    info: &[usize],
    data: *mut (),
    size: usize
) -> Option<ValueA<T, D>>

UNSAFE: data must point to size bytes, which shouldn’t be freed if Some is returned

Trait Implementations

impl<D: DataBuf, T: ?Sized> Debug for ValueA<T, D> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T: ?Sized, D: DataBuf> Deref for ValueA<T, D>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: ?Sized, D: DataBuf> DerefMut for ValueA<T, D>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<D: DataBuf, T: ?Sized> Display for ValueA<T, D> where
    T: Display, 

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

Formats the value using the given formatter.

impl<T: ?Sized, D: DataBuf> Drop for ValueA<T, D>

fn drop(&mut self)

Executes the destructor for this type.

impl<D: DataBuf, T: ?Sized> Future for ValueA<T, D> where
    T: Future, 

Future if the inner impls Future

type Output = T::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.