Struct pwasm_std::Box

#[lang = "owned_box"]
pub struct Box<T>(_)
 where
    T: ?Sized;

A pointer type for heap allocation.

See the module-level documentation for more.

Methods

impl<T> Box<T>

fn new(x: T) -> Box<T>

Allocates memory on the heap and then places x into it.

This doesn't actually allocate if T is zero-sized.

Examples

let five = Box::new(5);

impl<T> Box<T> where
    T: ?Sized, 

unsafe fn from_raw(raw: *mut T) -> Box<T>

Constructs a box from a raw pointer.

After calling this function, the raw pointer is owned by the resulting Box. Specifically, the Box destructor will call the destructor of T and free the allocated memory. Since the way Box allocates and releases memory is unspecified, the only valid pointer to pass to this function is the one taken from another Box via the Box::into_raw function.

This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.

Examples

let x = Box::new(5);
let ptr = Box::into_raw(x);
let x = unsafe { Box::from_raw(ptr) };

fn into_raw(b: Box<T>) -> *mut T

Consumes the Box, returning the wrapped raw pointer.

After calling this function, the caller is responsible for the memory previously managed by the Box. In particular, the caller should properly destroy T and release the memory. The proper way to do so is to convert the raw pointer back into a Box with the Box::from_raw function.

Note: this is an associated function, which means that you have to call it as Box::into_raw(b) instead of b.into_raw(). This is so that there is no conflict with a method on the inner type.

Examples

let x = Box::new(5);
let ptr = Box::into_raw(x);

fn into_unique(b: Box<T>) -> Unique<T>

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

needs an RFC to flesh out design

Consumes the Box, returning the wrapped pointer as Unique<T>.

After calling this function, the caller is responsible for the memory previously managed by the Box. In particular, the caller should properly destroy T and release the memory. The proper way to do so is to convert the raw pointer back into a Box with the Box::from_raw function.

Note: this is an associated function, which means that you have to call it as Box::into_unique(b) instead of b.into_unique(). This is so that there is no conflict with a method on the inner type.

Examples

#![feature(unique)]

fn main() {
    let x = Box::new(5);
    let ptr = Box::into_unique(x);
}

impl Box<Any + 'static>

fn downcast<T>(self) -> Result<Box<T>, Box<Any + 'static>> where
    T: Any, 

Attempt to downcast the box to a concrete type.

Examples

use std::any::Any;

fn print_if_string(value: Box<Any>) {
    if let Ok(string) = value.downcast::<String>() {
        println!("String ({}): {}", string.len(), string);
    }
}

fn main() {
    let my_string = "Hello World".to_string();
    print_if_string(Box::new(my_string));
    print_if_string(Box::new(0i8));
}

impl Box<Any + 'static + Send>

fn downcast<T>(self) -> Result<Box<T>, Box<Any + 'static + Send>> where
    T: Any, 

Attempt to downcast the box to a concrete type.

Examples

use std::any::Any;

fn print_if_string(value: Box<Any + Send>) {
    if let Ok(string) = value.downcast::<String>() {
        println!("String ({}): {}", string.len(), string);
    }
}

fn main() {
    let my_string = "Hello World".to_string();
    print_if_string(Box::new(my_string));
    print_if_string(Box::new(0i8));
}

Trait Implementations

impl<T> Pointer for Box<T> where
    T: ?Sized, 

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

impl<T> Borrow<T> for Box<T> where
    T: ?Sized, 

fn borrow(&self) -> &T

impl<I> DoubleEndedIterator for Box<I> where
    I: DoubleEndedIterator + ?Sized, 

fn next_back(&mut self) -> Option<<I as Iterator>::Item>

impl<T> Debug for Box<T> where
    T: Debug + ?Sized, 

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

Formats the value using the given formatter.

impl<T> PartialEq<Box<T>> for Box<T> where
    T: PartialEq<T> + ?Sized, 

fn eq(&self, other: &Box<T>) -> bool

fn ne(&self, other: &Box<T>) -> bool

impl<T> AsMut<T> for Box<T> where
    T: ?Sized, 

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

impl<T> Hash for Box<T> where
    T: Hash + ?Sized, 

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

impl<T> AsRef<T> for Box<T> where
    T: ?Sized, 

fn as_ref(&self) -> &T

Performs the conversion.

impl<T> Eq for Box<T> where
    T: Eq + ?Sized, 

impl<T> Drop for Box<T> where
    T: ?Sized, 

fn drop(&mut self)

impl<T> Generator for Box<T> where
    T: Generator + ?Sized, 

type Yield = <T as Generator>::Yield

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

type Return = <T as Generator>::Return

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

fn resume(
    &mut self
) -> GeneratorState<<Box<T> as Generator>::Yield, <Box<T> as Generator>::Return>

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

impl<T> From<Vec<T>> for Box<[T]>

fn from(v: Vec<T>) -> Box<[T]>

impl From<String> for Box<str>

fn from(s: String) -> Box<str>

impl<'a, T> From<&'a [T]> for Box<[T]> where
    T: Copy, 

fn from(slice: &'a [T]) -> Box<[T]>

impl From<Box<str>> for Box<[u8]>

fn from(s: Box<str>) -> Box<[u8]>

impl<T> From<T> for Box<T>

fn from(t: T) -> Box<T>

impl<'a> From<&'a str> for Box<str>

fn from(s: &'a str) -> Box<str>

impl<T> DerefMut for Box<T> where
    T: ?Sized, 

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

impl<T> Boxed for Box<T>

type Data = T

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

type Place = IntermediateBox<T>

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

unsafe fn finalize(b: IntermediateBox<T>) -> Box<T>

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

impl<T> PartialOrd<Box<T>> for Box<T> where
    T: PartialOrd<T> + ?Sized, 

fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering>

fn lt(&self, other: &Box<T>) -> bool

fn le(&self, other: &Box<T>) -> bool

fn ge(&self, other: &Box<T>) -> bool

fn gt(&self, other: &Box<T>) -> bool

impl<I> ExactSizeIterator for Box<I> where
    I: ExactSizeIterator + ?Sized, 

fn len(&self) -> usize

fn is_empty(&self) -> bool

impl<T> Clone for Box<[T]> where
    T: Clone, 

fn clone(&self) -> Box<[T]>

impl Clone for Box<str>

fn clone(&self) -> Box<str>

impl<T> Clone for Box<T> where
    T: Clone, 

fn clone(&self) -> Box<T>

Returns a new box with a clone() of this box's contents.

Examples

let x = Box::new(5);
let y = x.clone();

fn clone_from(&mut self, source: &Box<T>)

Copies source's contents into self without creating a new allocation.

Examples

let x = Box::new(5);
let mut y = Box::new(10);

y.clone_from(&x);

assert_eq!(*y, 5);

impl<T> Ord for Box<T> where
    T: Ord + ?Sized, 

fn cmp(&self, other: &Box<T>) -> Ordering

impl<T> BorrowMut<T> for Box<T> where
    T: ?Sized, 

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

impl<T> Display for Box<T> where
    T: Display + ?Sized, 

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

impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized, 

type Item = <I as Iterator>::Item

fn next(&mut self) -> Option<<I as Iterator>::Item>

fn size_hint(&self) -> (usize, Option<usize>)

fn nth(&mut self, n: usize) -> Option<<I as Iterator>::Item>

impl<T, U> CoerceUnsized<Box<U>> for Box<T> where
    T: Unsize<U> + ?Sized,
    U: ?Sized, 

impl<'a, A, R> FnOnce<A> for Box<FnBox<A, Output = R> + 'a>

type Output = R

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

will be deprecated if and when Box<FnOnce> becomes usable

extern "rust-call" fn call_once(self, args: A) -> R

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

will be deprecated if and when Box<FnOnce> becomes usable

impl<'a, A, R> FnOnce<A> for Box<FnBox<A, Output = R> + 'a + Send>

type Output = R

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

will be deprecated if and when Box<FnOnce> becomes usable

extern "rust-call" fn call_once(self, args: A) -> R

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

will be deprecated if and when Box<FnOnce> becomes usable

impl<T> Deref for Box<T> where
    T: ?Sized, 

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> Hasher for Box<T> where
    T: Hasher + ?Sized, 

fn finish(&self) -> u64

fn write(&mut self, bytes: &[u8])

fn write_u8(&mut self, i: u8)

fn write_u16(&mut self, i: u16)

fn write_u32(&mut self, i: u32)

fn write_u64(&mut self, i: u64)

fn write_u128(&mut self, i: u128)

fn write_usize(&mut self, i: usize)

fn write_i8(&mut self, i: i8)

fn write_i16(&mut self, i: i16)

fn write_i32(&mut self, i: i32)

fn write_i64(&mut self, i: i64)

fn write_i128(&mut self, i: i128)

fn write_isize(&mut self, i: isize)

impl<I> FusedIterator for Box<I> where
    I: FusedIterator + ?Sized, 

impl Default for Box<str>

fn default() -> Box<str>

impl<T> Default for Box<T> where
    T: Default, 

fn default() -> Box<T>

Creates a Box<T>, with the Default value for T.

impl<T> Default for Box<[T]>

fn default() -> Box<[T]>