Trait runestick::UnsafeFromValue

pub trait UnsafeFromValue: Sized {
    type Output: 'static;
    type Guard: 'static;
    fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>;
    unsafe fn unsafe_coerce(output: Self::Output) -> Self;
}

A potentially unsafe conversion for value conversion.

This trait is used to convert values to references, which can be safely used while an external function call is used. That sort of use is safe because we hold onto the guard returned by the conversion during external function calls.

Associated Types

type Output: 'static

The output type from the unsafe coercion.

type Guard: 'static

The raw guard returned.

Must only be dropped after the value returned from this function is no longer live.

Loading content...

Required methods

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

Convert the given reference using unsafe assumptions to a value.

Safety

The return value of this function may only be used while a virtual machine is not being modified.

You must also make sure that the returned value does not outlive the guard.

unsafe fn unsafe_coerce(output: Self::Output) -> Self

Coerce the output of an unsafe from value into the final output type.

Safety

The return value of this function may only be used while a virtual machine is not being modified.

You must also make sure that the returned value does not outlive the guard.

Loading content...

Implementations on Foreign Types

impl UnsafeFromValue for &Error

type Output = *const Error

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Error

type Output = *mut Error

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Error

type Output = *const Error

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Error

type Output = *mut Error

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Error

type Output = *const Error

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Error

type Output = *mut Error

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Ordering

type Output = *const Ordering

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Ordering

type Output = *mut Ordering

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<'a> UnsafeFromValue for &'a [u8]

type Output = *const [u8]

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Option<Value>

type Output = *const Option<Value>

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Option<Value>

type Output = *mut Option<Value>

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Result<Value, Value>

type Output = *mut Result<Value, Value>

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &str

type Output = *const str

type Guard = StrGuard

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut str

type Output = *mut str

type Guard = Option<RawMut>

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &String

type Output = *const String

type Guard = StrGuard

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut String

type Output = *mut String

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Result<Value, Value>

type Output = *const Result<Value, Value>

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &ParseCharError

type Output = *const ParseCharError

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut ParseCharError

type Output = *mut ParseCharError

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &ParseFloatError

type Output = *const ParseFloatError

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut ParseFloatError

type Output = *mut ParseFloatError

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &ParseIntError

type Output = *const ParseIntError

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut ParseIntError

type Output = *mut ParseIntError

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<'a> UnsafeFromValue for &'a [Value]

type Output = *const [Value]

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

Loading content...

Implementors

impl UnsafeFromValue for &GeneratorState

type Output = *const GeneratorState

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Future

type Output = *const Future

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Generator

type Output = *const Generator

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Object

type Output = *const Object

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Range

type Output = *const Range

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Stream

type Output = *const Stream

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &Function

type Output = *const Function

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut GeneratorState

type Output = *mut GeneratorState

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Future

type Output = *mut Future

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Generator

type Output = *mut Generator

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Object

type Output = *mut Object

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Range

type Output = *mut Range

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl UnsafeFromValue for &mut Stream

type Output = *mut Stream

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<'a> UnsafeFromValue for &'a Bytes

type Output = *const Bytes

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<'a> UnsafeFromValue for &'a Iterator

type Output = *const Iterator

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<'a> UnsafeFromValue for &'a Vec

type Output = *const Vec

type Guard = RawRef

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<'a> UnsafeFromValue for &'a mut Bytes

type Output = *mut Bytes

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<'a> UnsafeFromValue for &'a mut Iterator

type Output = *mut Iterator

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<'a> UnsafeFromValue for &'a mut Vec

type Output = *mut Vec

type Guard = RawMut

fn from_value(value: Value) -> Result<(Self::Output, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

impl<T> UnsafeFromValue for T where
    T: FromValue, 

type Output = T

type Guard = ()

fn from_value(value: Value) -> Result<(Self, Self::Guard), VmError>

unsafe fn unsafe_coerce(output: Self::Output) -> Self

Loading content...