Trait Emplace 

pub trait Emplace<T>: Sized + Deref {
    type Output: Deref<Target = Self::Target>;

    // Required method
    fn try_emplace<N: TryNew<Output = T>>(
        n: N,
    ) -> Result<Self::Output, N::Error>;

    // Provided method
    fn emplace<N: New<Output = T>>(n: N) -> Self::Output { ... }
}

A pointer type that may be “emplaced” as a stable address which a New may be used to construct a value with.

The Emplace<T>::Output type is usually either Self or Pin<Self> depending on the API of Self with respect to DerefMut.

For example, Arc<T>, Box<T>, and Rc<T> are all Emplace<T, Output = Pin<Self>>.

However, cxx::UniquePtr<T>: Emplace<T, Output = Self>, since cxx::UniquePtr<T> already only allows obtaining pinned mutable references to T due to its more restrictive API, and hence cxx::UniquePtr<T> does not need to be pinned itself.

Required Associated Types

type Output: Deref<Target = Self::Target>

The stable address type within which a value of type T is emplaced.

Required Methods

fn try_emplace<N: TryNew<Output = T>>(n: N) -> Result<Self::Output, N::Error>

Constructs a new smart pointer and tries to emplace n into its storage.

Provided Methods

fn emplace<N: New<Output = T>>(n: N) -> Self::Output

Constructs a new smart pointer and emplaces n into its storage.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<T: MakeCppStorage + UniquePtrTarget> Emplace<T> for UniquePtr<T>

type Output = UniquePtr<T>

fn try_emplace<N: TryNew<Output = T>>(n: N) -> Result<Self, N::Error>

impl<T> Emplace<T> for Arc<T>

type Output = Pin<Arc<T>>

fn try_emplace<N: TryNew<Output = T>>(n: N) -> Result<Self::Output, N::Error>

impl<T> Emplace<T> for Box<T>

type Output = Pin<Box<T>>

fn try_emplace<N: TryNew<Output = T>>(n: N) -> Result<Self::Output, N::Error>

impl<T> Emplace<T> for Rc<T>

type Output = Pin<Rc<T>>

fn try_emplace<N: TryNew<Output = T>>(n: N) -> Result<Self::Output, N::Error>

Implementors