Struct StackBox 

pub struct StackBox<T, Ctnr>
where
    T: ?Sized,
{ /* private fields */ }

Implementations

impl<T, Ctnr> StackBox<T, Ctnr>

where Ctnr: StackBoxContainer,

pub fn new(value: T) -> Self

Statically check if value could be put into this box. If checking is failed then trigger error at compile time.

Examples found in repository

examples/cells.rs (line 8)

fn main() {
    let cb = CellBox::new(RefCell::new(10u32)); // internal mutability
    let r1 = cb.borrow();
    let r2 = cb.borrow();
    drop((r1, r2));
    *cb.borrow_mut() = 99;
}

examples/basic.rs (line 8)

fn main() {
    let u16_box = U32Box::new(16u16); // ok
    let u32_box = U32Box::new([32u32; 3]); // ok

    // U32Box::new(0u64); // panic at compile time
    // U32Box::new([0u32; 4]); // panic at compile time

    assert!(U32Box::new_dynamic(0u64).is_err()); // align too large
    assert!(U32Box::new_dynamic([0u32; 4]).is_err()); // size too large

    let arr: [U32Box<dyn Debug>; 2] = [coerce!(u16_box), coerce!(u32_box)];

    for x in arr {
        dbg!(&*x);
    }
}

pub fn new_dynamic(value: T) -> Result<Self, (T, Error)>

Same to Self::new but does check at runtime and returns a Result

Examples found in repository

examples/basic.rs (line 14)

fn main() {
    let u16_box = U32Box::new(16u16); // ok
    let u32_box = U32Box::new([32u32; 3]); // ok

    // U32Box::new(0u64); // panic at compile time
    // U32Box::new([0u32; 4]); // panic at compile time

    assert!(U32Box::new_dynamic(0u64).is_err()); // align too large
    assert!(U32Box::new_dynamic([0u32; 4]).is_err()); // size too large

    let arr: [U32Box<dyn Debug>; 2] = [coerce!(u16_box), coerce!(u32_box)];

    for x in arr {
        dbg!(&*x);
    }
}

pub fn coerce_unsized<U, F>(this: Self, check_fn: F) -> StackBox<U, Ctnr>

where U: ?Sized, F: Fn(&mut UnsizeChecker<U, T>) -> &mut UnsizeChecker<U, U>,

impl<T, Ctnr> StackBox<T, Ctnr>

where T: ?Sized,

pub fn as_ptr(this: &Self) -> *mut T

Trait Implementations

impl<T, U, Ctnr> AsMut<U> for StackBox<T, Ctnr>

where T: AsMut<U> + ?Sized, U: ?Sized,

fn as_mut(&mut self) -> &mut U

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, U, Ctnr> AsRef<U> for StackBox<T, Ctnr>

where T: AsRef<U> + ?Sized, U: ?Sized,

fn as_ref(&self) -> &U

Converts this type into a shared reference of the (usually inferred) input type.

impl<T, Ctnr> Borrow<T> for StackBox<T, Ctnr>

where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T, Ctnr> BorrowMut<T> for StackBox<T, Ctnr>

where T: ?Sized,

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

Mutably borrows from an owned value.

impl<T, Ctnr> Clone for StackBox<T, Ctnr>

where T: Clone, Ctnr: StackBoxContainer,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, Ctnr> Deref for StackBox<T, Ctnr>

where T: ?Sized,

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, Ctnr> DerefMut for StackBox<T, Ctnr>

where T: ?Sized,

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

Mutably dereferences the value.

impl<T, Ctnr> Drop for StackBox<T, Ctnr>

where T: ?Sized,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, Ctnr> Hash for StackBox<T, Ctnr>

where T: Hash + ?Sized,

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, Ctnr> Ord for StackBox<T, Ctnr>

where T: Ord + ?Sized,

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, U, Ctnr, Ctnr2> PartialEq<StackBox<U, Ctnr2>> for StackBox<T, Ctnr>

where T: PartialEq<U> + ?Sized, U: ?Sized,

fn eq(&self, other: &StackBox<U, Ctnr2>) -> 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<T, U, Ctnr, Ctnr2> PartialOrd<StackBox<U, Ctnr2>> for StackBox<T, Ctnr>

where T: PartialOrd<U> + ?Sized, U: ?Sized,

fn partial_cmp(&self, other: &StackBox<U, Ctnr2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, Ctnr> Eq for StackBox<T, Ctnr>

where T: Eq + ?Sized,

impl<T, Ctnr> Send for StackBox<T, Ctnr>

where T: Send + ?Sized,

impl<T, Ctnr> Sync for StackBox<T, Ctnr>

where T: Sync + ?Sized,