Struct BoxContainer

pub struct BoxContainer<T>(/* private fields */);

Available on crate feature alloc only.

Container implementation via Box

Implements ExclusiveContainer

Example

let mut container = BoxContainer::init_value((), 42);
let shared: &i32 = &container;
let exclusive: Pin<&mut i32> = container.inner();
let container2 = container.mv::<BoxContainer<_>>(());

Implementations

impl<T> BoxContainer<T>

pub fn iter<'r0>(&'r0 self) -> <&'r0 Self as IntoIterator>::IntoIter

where for<'r1> &'r1 T: IntoIterator,

Same as <&Self as IntoIterator>::into_iter(self)

Trait Implementations

impl<T> AsRef<<BoxContainer<T> as Container>::Inner> for BoxContainer<T>

fn as_ref(&self) -> &<BoxContainer<T> as Container>::Inner

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

impl<T> Container for BoxContainer<T>

type Allocator = ()

Type used to create uninitialized version of the container

type Inner = T

Contained type

type Uninit = UninitBoxContainer<T>

Container in the uninitialized state. Usually somewhat similar to container itself

fn uninit(_allocator: ()) -> Self::Uninit

Creates container in the uninitialized state

fn uninit_inner_ptr(uninit: &mut Self::Uninit) -> *mut Self::Inner

Retrieves pointer to the contents of uninit container

unsafe fn init(uninit: Self::Uninit) -> Self

Safety

fn try_inner(&mut self) -> Option<Pin<&mut Self::Inner>>

Gets exclusive reference to inner value. Note that exclusive reference is always pinned

fn try_move_out<O>( self, action: impl FnOnce(*mut Self::Inner) -> O, ) -> Option<O>

Moves value out of the container. action is called at most once (i.e. 1 or 0 times) and provided with a pointer to contained value (i.e. it is valid for reads and points to valid Container::Inner)

unsafe fn init_ptr( allocator: Self::Allocator, initializer: impl FnOnce(*mut Self::Inner), ) -> Self

Provided helper function creating and initializing the container in a single call

fn try_mv<C: Container<Inner = Self::Inner>>( self, allocator: C::Allocator, ) -> Option<C>

where Self::Inner: Moveable,

Tries moving value out of the container into a different container

fn init_value(allocator: Self::Allocator, value: Self::Inner) -> Self

Provided helper function initializing the Container by moving a value into it

impl<T: Debug> Debug for BoxContainer<T>

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

Formats the value using the given formatter.

impl<T> Deref for BoxContainer<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: Display> Display for BoxContainer<T>

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

Formats the value using the given formatter.

impl<T> ExclusiveContainer for BoxContainer<T>

fn inner(&mut self) -> Pin<&mut Self::Inner>

Gets exclusive reference to inner value. Note that exclusive reference is always pinned

fn move_out<O>(self, action: impl FnOnce(*mut Self::Inner) -> O) -> O

Moves value out of the container. action is called exactly once, and provided with a pointer to contained value

fn mv<C: Container<Inner = Self::Inner>>(self, allocator: C::Allocator) -> C

where Self::Inner: Moveable,

Moves value out of the container into a different container

impl<'r0, T> IntoIterator for &'r0 BoxContainer<T>

where for<'r1> &'r1 T: IntoIterator,

type Item = <&'r0 T as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'r0 T as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.