Struct CppUniquePtrPin

pub struct CppUniquePtrPin<T: UniquePtrTarget>(/* private fields */);

Any newtype wrapper which causes the contained UniquePtr target to obey C++ reference semantics rather than Rust reference semantics. That is, multiple aliasing mutable C++ references may exist to the contents.

C++ references are permitted to alias one another, and commonly do. Rust references must alias according only to the narrow rules of the borrow checker.

Implementations

impl<T: UniquePtrTarget> CppUniquePtrPin<T>

pub fn new(item: UniquePtr<T>) -> Self

Imprison the type within a CppPin. This eliminates any remaining Rust references (since we take the item by value) and this object subsequently only vends C++ style references, not Rust references.

pub fn as_ptr(&self) -> *const T

Get an immutable pointer to the underlying object.

Methods from Deref<Target = CppMutRef<T>>

pub fn as_mut_ptr(&self) -> *mut T

Retrieve the underlying C++ pointer.

Methods from Deref<Target = CppRef<T>>

pub fn as_ptr(&self) -> *const T

Retrieve the underlying C++ pointer.

pub unsafe fn as_ref(&self) -> &T

Get a regular Rust reference out of this C++ reference.

Safety

Callers must guarantee that the referent is not modified by any other C++ or Rust code while the returned reference exists. Callers must also guarantee that no mutable Rust reference is created to the referent while the returned reference exists.

Callers must also be sure that the C++ reference is properly aligned, not null, pointing to valid data, etc.

pub fn const_cast(&self) -> CppMutRef<T>

Create a mutable version of this reference, roughly equivalent to C++ const_cast.

The opposite is to use AsCppRef::as_cpp_ref on a CppMutRef to obtain a CppRef.

Safety

Because we never dereference a CppRef in Rust, this cannot create undefined behavior within Rust and is therefore not unsafe. It is however generally unwise, just as it is in C++. Use sparingly.

Trait Implementations

impl<T: UniquePtrTarget> AsCppMutRef<T> for CppUniquePtrPin<T>

fn as_cpp_mut_ref(&mut self) -> CppMutRef<T>

Returns a mutable reference which obeys C++ reference semantics

impl<T: UniquePtrTarget> AsCppRef<T> for CppUniquePtrPin<T>

fn as_cpp_ref(&self) -> CppRef<T>

Returns a reference which obeys C++ reference semantics

impl<T: UniquePtrTarget> Deref for CppUniquePtrPin<T>

type Target = CppMutRef<T>

The resulting type after dereferencing.

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

Dereferences the value.