Struct no_alloc::BoxS

pub struct BoxS<T, M> where
    T: ?Sized,
    M: Memory,  { /* fields omitted */ }

A box that exists entirely on the stack.

Implementations

impl<T, M> BoxS<T, M> where
    M: Memory, 

pub fn new(x: T) -> Self

Acquires memory on the stack and places x into it.

The acquired memory is backed by M. If the size or alignment of T is greater than that of M the box cannot be constructed. This will reuslt in a compile fail.

If T is zero-sized then no memory is required; M may also be zero sized in this case.

Examples

Creating a boxed value:

use no_alloc::BoxS;

let boxed: BoxS<isize, [usize; 1]> = BoxS::new(0);

Creating a boxed ZST (zero-sized type):

use no_alloc::BoxS;

let boxed: BoxS<(), [usize; 0]> = BoxS::new(());

Failing to create a boxed value due to size error (this results in a compile error):

use no_alloc::BoxS;

let _impossible = BoxS::<isize, [u8; 0]>::new(0);

Failing to create a boxed value due to alignment error (this results in a compile error):

use core::mem::size_of;
use no_alloc::BoxS;

let _impossible = BoxS::<isize, [u8; size_of::<isize>()]>::new(0);

Coercing to a boxed DST (dynamically-sized type) (requires the coerce_unsized feature):

use core::any::Any;
use no_alloc::BoxS;

let boxed: BoxS<dyn Any, [usize; 1]> = BoxS::new(0_isize);

impl<M> BoxS<dyn Any + 'static, M> where
    M: Memory, 

pub fn downcast<T>(self) -> Result<BoxS<T, M>, Self> where
    T: Any, 

Attempts to downcast the box to a concrete type.

Examples

use core::any::Any;
use core::fmt;

use no_alloc::{BoxS, Memory};

fn write_if_str<W: fmt::Write, M: Memory>(
    mut wtr: W,
    boxed: BoxS<dyn Any + 'static, M>
) -> fmt::Result {
    if let Ok(s) = boxed.downcast::<&str>() {
        wtr.write_str(&s)?;
    }
    Ok(())
}

impl<M> BoxS<dyn Any + Send + 'static, M> where
    M: Memory, 

pub fn downcast<T>(self) -> Result<BoxS<T, M>, Self> where
    T: Any, 

Attempts to downcast the box to a concrete type.

Examples

use core::any::Any;
use core::fmt;

use no_alloc::{BoxS, Memory};

fn write_if_str<W: fmt::Write, M: Memory>(
    mut wtr: W,
    boxed: BoxS<dyn Any + Send + 'static, M>
) -> fmt::Result {
    if let Ok(s) = boxed.downcast::<&str>() {
        wtr.write_str(&s)?;
    }
    Ok(())
}

Trait Implementations

impl<T: ?Sized, M> Debug for BoxS<T, M> where
    T: Debug,
    M: Memory, 

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

Formats the value using the given formatter.

impl<T, M> Deref for BoxS<T, M> where
    T: ?Sized,
    M: Memory, 

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, M> DerefMut for BoxS<T, M> where
    T: ?Sized,
    M: Memory, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: ?Sized, M> Display for BoxS<T, M> where
    T: Display,
    M: Memory, 

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

Formats the value using the given formatter.

impl<T, M> Drop for BoxS<T, M> where
    T: ?Sized,
    M: Memory, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, M> Pointer for BoxS<T, M> where
    T: ?Sized,
    M: Memory, 

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

Formats the value using the given formatter.

impl<T: ?Sized, M> Send for BoxS<T, M> where
    T: Send,
    M: Memory, 

impl<T: ?Sized, M> Sync for BoxS<T, M> where
    T: Sync,
    M: Memory,