Struct drone_core::prelude::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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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

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

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

fn drop(&mut self)

Executes the destructor for this type.

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)

The type of value this generator yields.

type Return = <T as Generator>::Return

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

The type of value this generator returns.

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

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

Resumes the execution of this generator.

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

Mutably dereferences the value.

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>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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]>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Clone for Box<str>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

The returned type after the call operator is used.

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

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

Performs the call operation.

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

type Output = R

The returned type after the call operator is used.

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

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

Performs the call operation.

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>

Returns the "default value" for a type.

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]>

Returns the "default value" for a type.