Struct RefContainer

pub struct RefContainer<'r, T>(/* private fields */);

Container implementation via exclusive reference to MaybeUninit

Implements ExclusiveContainer

Example

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

Note that this container has a non-() allocator, and you might want to explicitly allocate MaybeUninit:

let mut tmp = MaybeUninit::uninit();
let container = RefContainer::init_value(&mut tmp, 42);

This works just fine too, although a bit verbose

Implementations

impl<'r, T> RefContainer<'r, T>

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

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

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

Trait Implementations

impl<'r, T> AsRef<<RefContainer<'r, T> as Container>::Inner> for RefContainer<'r, T>

fn as_ref(&self) -> &<RefContainer<'r, T> as Container>::Inner

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

impl<'r, T> Container for RefContainer<'r, T>

type Allocator = &'r mut MaybeUninit<T>

Type used to create uninitialized version of the container

type Inner = T

Contained type

type Uninit = UninitRefContainer<'r, T>

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

fn uninit(allocator: Self::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<'r, T: Debug> Debug for RefContainer<'r, T>

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

Formats the value using the given formatter.

impl<T> Deref for RefContainer<'_, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: Display> Display for RefContainer<'_, T>

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

Formats the value using the given formatter.

impl<T> Drop for RefContainer<'_, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> ExclusiveContainer for RefContainer<'_, 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, 'r, T> IntoIterator for &'r0 RefContainer<'r, T>

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

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.