Struct abi_stable::sabi_types::move_ptr::MovePtr

#[repr(transparent)]
pub struct MovePtr<'a, T> { /* fields omitted */ }

A move pointer,which allows moving the value from the reference, consuming it in the process.

if MovePtr::into_inner isn't called, this drops the referenced value when its dropped

Safety

This is unsafe to construct since the user must ensure that the value being referenced is not read again,even when being dropped.

Motivation

MovePtr was created as a way to pass self by value to ffi-safe trait object methods, since one can't simply pass self by value(because the type is erased).

Examples

Using OwnedPointer::in_move_ptr

This is how one can use MovePtr without unsafe.

This simply moves the contents of an RBox<T> into a Box<T>.

use abi_stable::{
    pointer_trait::OwnedPointer,
    sabi_types::MovePtr,
    std_types::RBox,
};


fn move_rbox_to_box<T>(rbox:RBox<T>)->Box<T>{
    rbox.in_move_ptr(|move_ptr|{
        MovePtr::into_box(move_ptr)
    })
}

assert_eq!( move_rbox_to_box(RBox::new(99)), Box::new(99) );

assert_eq!( move_rbox_to_box(RBox::new(())), Box::new(()) );

assert_eq!(
    move_rbox_to_box(RBox::new(String::from("SHIT"))), 
    Box::new(String::from("SHIT")) 
);

Using the (unsafe) MovePtr::new

This is (sort of) how RBox<T> implements moving the T it owns out of its allocation

This is basically what OwnedPointer::{with_move_ptr,in_move_ptr} do.

use abi_stable::{
    pointer_trait::OwnedPointer,
    sabi_types::MovePtr,
    std_types::RBox,
};

use std::mem::ManuallyDrop;

let rbox=RBox::new(0x100);

let second_rbox;
unsafe{ 
    let mut rbox=ManuallyDrop::new(rbox);
    let move_ptr=unsafe{ MovePtr::new( &mut **rbox ) };
    second_rbox=RBox::from_move_ptr(move_ptr);
    OwnedPointer::drop_allocation(&mut rbox); 
}

assert_eq!( second_rbox, RBox::new(0x100) );

Methods

impl<'a, T> MovePtr<'a, T>

pub unsafe fn new(ptr: &'a mut T) -> Self

Constructs this more pointer from a mutable reference, moving the value out of the reference.

Safety

Callers must ensure that the value the reference points at is never read again.

Example

use abi_stable::sabi_types::MovePtr;
 
use std::mem::ManuallyDrop;
 
let mut manual=ManuallyDrop::new(String::from("hello"));
 
let moveptr=unsafe{ MovePtr::new(&mut *manual) };

drop(moveptr); // moveptr drops the String here.

pub const fn as_ptr(this: &Self) -> *const T

Gets a raw pointer to the value being moved.

Example

use abi_stable::{
    pointer_trait::OwnedPointer,
    sabi_types::MovePtr,
    std_types::RBox,
};
 
let rbox=RBox::new(String::from("NOPE"));
let address_rbox=&*rbox as *const String as usize;

rbox.in_move_ptr(|move_ptr|{
    assert_eq!( address_rbox, MovePtr::as_ptr(&move_ptr) as usize );
});
 

pub fn as_mut_ptr(this: &mut Self) -> *mut T

Gets a raw pointer to the value being moved.

Example

Example

use abi_stable::{
    pointer_trait::OwnedPointer,
    sabi_types::MovePtr,
    std_types::RBox,
};
 
let rbox=RBox::new(String::from("NOPE"));
let address_rbox=&*rbox as *const String as usize;

rbox.in_move_ptr(|mut move_ptr|{
    assert_eq!( address_rbox, MovePtr::as_mut_ptr(&mut move_ptr) as usize );
});
 

pub const fn into_raw(this: Self) -> *mut T

Converts this MovePtr into a raw pointer, which must be moved from before the pointed to value is deallocated.

Example

use abi_stable::{
    pointer_trait::OwnedPointer,
    sabi_types::MovePtr,
    std_types::RBox,
};
 
let rbox=RBox::new(String::from("NOPE"));

let string=rbox.in_move_ptr(|move_ptr|unsafe{
    MovePtr::into_raw(move_ptr).read()
});
 
assert_eq!(string,String::from("NOPE"));
 

pub fn into_box(this: Self) -> Box<T>

Moves the value into a new Box<T>

Example

use abi_stable::{
    pointer_trait::OwnedPointer,
    sabi_types::MovePtr,
    std_types::RBox,
};
 
let rbox=RBox::new(String::from("WHAT!!!"));

let boxed=rbox.in_move_ptr(|move_ptr|unsafe{
    MovePtr::into_box(move_ptr)
});
 
assert_eq!(boxed,Box::new(String::from("WHAT!!!")));
 

pub fn into_rbox(this: Self) -> RBox<T>

Moves the value into a new RBox<T>

Example

use abi_stable::{
    pointer_trait::OwnedPointer,
    sabi_types::MovePtr,
    std_types::RBox,
};
 
let rbox=RBox::new(String::from("WHAT!!!"));

let boxed=rbox.in_move_ptr(|move_ptr|unsafe{
    MovePtr::into_rbox(move_ptr)
});
 
assert_eq!( boxed, RBox::new(String::from("WHAT!!!")) );
 

pub fn into_inner(this: Self) -> T

Moves the value out of the reference

Example

use abi_stable::{
    pointer_trait::OwnedPointer,
    sabi_types::MovePtr,
    std_types::RBox,
};
 
let rbox=RBox::new(String::from("(The Wi)zard(of)oz"));

let string=rbox.in_move_ptr(|ptr| MovePtr::into_inner(ptr) );
 
assert_eq!( string, String::from("(The Wi)zard(of)oz") );
 

Trait Implementations

impl<'a, T> IntoInner for MovePtr<'a, T>

type Element = T

The type of the value this owns.

fn into_inner_(self) -> T

Unwraps this type into its owned value.

impl<'a, T> GetStaticEquivalent_ for MovePtr<'a, T> where
    T: __StableAbi,
    T: 'a, 

type StaticEquivalent = _static_MovePtr<'static, __GetStaticEquivalent<T>>

impl<'a, T> SharedStableAbi for MovePtr<'a, T> where
    T: __StableAbi,
    T: 'a, 

type IsNonZeroType = <*mut T as __SharedStableAbi>::IsNonZeroType

Whether this type has a single invalid bit-pattern.

type Kind = __ValueKind

The kind of abi stability of this type,there are 2:

const S_LAYOUT: &'static TypeLayout

The layout of the type provided by implementors.

const S_ABI_CONSTS: AbiConsts

impl<'a, T> Drop for MovePtr<'a, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> Eq for MovePtr<'a, T> where
    T: Eq, 

impl<'a, T> PartialOrd<MovePtr<'a, T>> for MovePtr<'a, T> where
    T: PartialOrd, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use] fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use] fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use] fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use] fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, T> PartialEq<MovePtr<'a, T>> for MovePtr<'a, T> where
    T: PartialEq, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, T> Ord for MovePtr<'a, T> where
    T: Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a, T> DerefMut for MovePtr<'a, T>

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

Mutably dereferences the value.

impl<'a, T> Hash for MovePtr<'a, T> where
    T: Hash, 

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<'a, T> Deref for MovePtr<'a, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'a, T> Debug for MovePtr<'a, T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<'a, T> Display for MovePtr<'a, T> where
    T: Display, 

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

Formats the value using the given formatter.