Trait BoxUnboxVmValue

pub trait BoxUnboxVmValue {
    type Unboxed;
    type Guarded;

    const RUBY_TYPE: &'static str;

    // Required methods
    unsafe fn unbox_from_value<'a>(
        value: &'a mut Value,
        interp: &mut Artichoke,
    ) -> Result<UnboxedValueGuard<'a, Self::Guarded>, Error>;
    fn alloc_value(
        value: Self::Unboxed,
        interp: &mut Artichoke,
    ) -> Result<Value, Error>;
    fn box_into_value(
        value: Self::Unboxed,
        into: Value,
        interp: &mut Artichoke,
    ) -> Result<Value, Error>;
    fn free(data: *mut c_void);
}

Required Associated Constants

const RUBY_TYPE: &'static str

Required Associated Types

type Unboxed

type Guarded

Required Methods

unsafe fn unbox_from_value<'a>( value: &'a mut Value, interp: &mut Artichoke, ) -> Result<UnboxedValueGuard<'a, Self::Guarded>, Error>

Safety

Implementations may return owned values. These values must not outlive the underlying mrb_value, which may be garbage collected by mruby.

The values returned by this method should not be stored for more than the current FFI trampoline entry point.

fn alloc_value( value: Self::Unboxed, interp: &mut Artichoke, ) -> Result<Value, Error>

fn box_into_value( value: Self::Unboxed, into: Value, interp: &mut Artichoke, ) -> Result<Value, Error>

fn free(data: *mut c_void)

Safety

Implementations must ensure that the data pointer is valid and that the memory it points to is properly deallocated. This method is called in an extern "C" fn and may never panic.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl BoxUnboxVmValue for String

const RUBY_TYPE: &'static str = "String"

type Unboxed = String

type Guarded = String

unsafe fn unbox_from_value<'a>( value: &'a mut Value, interp: &mut Artichoke, ) -> Result<UnboxedValueGuard<'a, Self::Guarded>, Error>

fn alloc_value( value: Self::Unboxed, interp: &mut Artichoke, ) -> Result<Value, Error>

fn box_into_value( value: Self::Unboxed, into: Value, interp: &mut Artichoke, ) -> Result<Value, Error>

fn free(data: *mut c_void)

impl BoxUnboxVmValue for Symbol

const RUBY_TYPE: &'static str = "Symbol"

type Unboxed = Symbol

type Guarded = Immediate<<Symbol as BoxUnboxVmValue>::Unboxed>

unsafe fn unbox_from_value<'a>( value: &'a mut Value, interp: &mut Artichoke, ) -> Result<UnboxedValueGuard<'a, Self::Guarded>, Error>

fn alloc_value( value: Self::Unboxed, interp: &mut Artichoke, ) -> Result<Value, Error>

fn box_into_value( value: Self::Unboxed, into: Value, interp: &mut Artichoke, ) -> Result<Value, Error>

fn free(data: *mut c_void)

Implementors

impl<T> BoxUnboxVmValue for T

where T: HeapAllocatedData + Sized + 'static,

const RUBY_TYPE: &'static str = <Self as HeapAllocatedData>::RUBY_TYPE

type Unboxed = T

type Guarded = HeapAllocated<<T as BoxUnboxVmValue>::Unboxed>