Struct std::boxed::Box [] [src]

pub struct Box<T> where T: ?Sized(_);
1.0.0

A pointer type for heap allocation.

See the module-level documentation for more.

Methods

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.

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.

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

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

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.

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

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.

Examples

fn main() { let seventeen = Box::new(17); let raw = Box::into_raw(seventeen); let boxed_again = unsafe { Box::from_raw(raw) }; }
let seventeen = Box::new(17);
let raw = Box::into_raw(seventeen);
let boxed_again = unsafe { Box::from_raw(raw) };

impl<T> Box<T>

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

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

Examples

fn main() { let five = Box::new(5); }
let five = Box::new(5);

Trait Implementations

impl<T> AsMut<T> for Box<T> where T: ?Sized1.5.0

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

impl<T> AsRef<T> for Box<T> where T: ?Sized1.5.0

fn as_ref(&self) -> &T

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

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

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

fn borrow(&self) -> &T

impl<T> Clone for Box<[T]> where T: Clone1.3.0

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

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

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 + Send>

type Output = R

Unstable (fnbox #28796)

: Newly introduced

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

Unstable (fnbox #28796)

: Newly introduced

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

type Output = R

Unstable (fnbox #28796)

: Newly introduced

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

Unstable (fnbox #28796)

: Newly introduced

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

fn len(&self) -> usize

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

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

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

type Item = I::Item

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

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

fn count(self) -> usize

fn last(self) -> Option<Self::Item>

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

fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>

fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B

fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>

fn enumerate(self) -> Enumerate<Self>

fn peekable(self) -> Peekable<Self>

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool

fn skip(self, n: usize) -> Skip<Self>

fn take(self, n: usize) -> Take<Self>

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where U: IntoIterator, F: FnMut(Self::Item) -> U

fn fuse(self) -> Fuse<Self>

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()

fn by_ref(&mut self) -> &mut Self

fn collect<B>(self) -> B where B: FromIterator<Self::Item>

fn partition<B, F>(self, f: F) -> (B, B) where F: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>

fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B

fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool

fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool

fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where Self: ExactSizeIterator + DoubleEndedIterator, P: FnMut(Self::Item) -> bool

fn max(self) -> Option<Self::Item> where Self::Item: Ord

fn min(self) -> Option<Self::Item> where Self::Item: Ord

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B1.6.0

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B1.6.0

fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where Self: Iterator<Item=(A, B)>, FromA: Default + Extend<A>, FromB: Default + Extend<B>

fn cloned<'a, T>(self) -> Cloned<Self> where Self: Iterator<Item=&'a T>, T: 'a + Clone

fn cycle(self) -> Cycle<Self> where Self: Clone

fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero

fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One

fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord1.5.0

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>1.5.0

fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>1.5.0

fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>1.5.0

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

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

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

type Target = T

fn deref(&self) -> &T

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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<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 Clone for Box<str>1.3.0

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

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

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

fn main() { let x = Box::new(5); let y = x.clone(); }
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

fn main() { let x = Box::new(5); let mut y = Box::new(10); y.clone_from(&x); assert_eq!(*y, 5); }
let x = Box::new(5);
let mut y = Box::new(10);

y.clone_from(&x);

assert_eq!(*y, 5);

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

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

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

fn default() -> Box<T>

impl<T> Boxed for Box<T>

type Data = T

Unstable (placement_new_protocol #27779)

type Place = IntermediateBox<T>

Unstable (placement_new_protocol #27779)

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

Unstable (placement_new_protocol #27779)

impl<'a, E: Error + 'a> From<E> for Box<Error + 'a>

fn from(err: E) -> Box<Error + 'a>

impl<'a, E: Error + Send + Sync + 'a> From<E> for Box<Error + Send + Sync + 'a>

fn from(err: E) -> Box<Error + Send + Sync + 'a>

impl From<String> for Box<Error + Send + Sync>

fn from(err: String) -> Box<Error + Send + Sync>

impl From<String> for Box<Error>1.7.0

fn from(str_err: String) -> Box<Error>

impl<'a, 'b> From<&'b str> for Box<Error + Send + Sync + 'a>

fn from(err: &'b str) -> Box<Error + Send + Sync + 'a>

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

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

impl<T: Error> Error for Box<T>1.7.0

fn description(&self) -> &str

fn cause(&self) -> Option<&Error>

impl<R: Read + ?Sized> Read for Box<R>

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

fn read_to_string(&mut self, buf: &mut String) -> Result<usize>

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

fn by_ref(&mut self) -> &mut Self where Self: Sized

fn bytes(self) -> Bytes<Self> where Self: Sized

fn chars(self) -> Chars<Self> where Self: Sized

fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized

fn take(self, limit: u64) -> Take<Self> where Self: Sized

impl<W: Write + ?Sized> Write for Box<W>

fn write(&mut self, buf: &[u8]) -> Result<usize>

fn flush(&mut self) -> Result<()>

fn write_all(&mut self, buf: &[u8]) -> Result<()>

fn write_fmt(&mut self, fmt: Arguments) -> Result<()>

fn by_ref(&mut self) -> &mut Self where Self: Sized

impl<S: Seek + ?Sized> Seek for Box<S>

fn seek(&mut self, pos: SeekFrom) -> Result<u64>

impl<B: BufRead + ?Sized> BufRead for Box<B>

fn fill_buf(&mut self) -> Result<&[u8]>

fn consume(&mut self, amt: usize)

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize>

fn read_line(&mut self, buf: &mut String) -> Result<usize>

fn split(self, byte: u8) -> Split<Self> where Self: Sized

fn lines(self) -> Lines<Self> where Self: Sized