Trait runestick::UnsafeFromValue

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

A potentially unsafe conversion for value conversion.

This trait is specifically implemented for reference types to allow registered functions to take references to their inner value.

This is specifically safe, because a guard is always held to the reference.

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

unsafe fn unsafe_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 to_arg(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<'a> UnsafeFromValue for &'a ParseFloatError

type Output = *const ParseFloatError

type Guard = RawOwnedRef

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

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

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

type Output = *mut ParseFloatError

type Guard = RawOwnedMut

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

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

impl<'a> UnsafeFromValue for &'a ParseIntError

type Output = *const ParseIntError

type Guard = RawOwnedRef

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

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

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

type Output = *mut ParseIntError

type Guard = RawOwnedMut

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

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

impl<'a> UnsafeFromValue for &'a Rev<Iter>

type Output = *const Rev<Iter>

type Guard = RawOwnedRef

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

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

impl<'a> UnsafeFromValue for &'a mut Rev<Iter>

type Output = *mut Rev<Iter>

type Guard = RawOwnedMut

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

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

impl<'a> UnsafeFromValue for &'a Rev<Iter>

type Output = *const Rev<Iter>

type Guard = RawOwnedRef

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

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

impl<'a> UnsafeFromValue for &'a mut Rev<Iter>

type Output = *mut Rev<Iter>

type Guard = RawOwnedMut

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

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

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

type Output = *const [u8]

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ Option<Value>

type Output = *const Option<Value>

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ mut Option<Value>

type Output = *mut Option<Value>

type Guard = RawOwnedMut

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

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

impl<'a> UnsafeFromValue for &'a Error

type Output = *const Error

type Guard = RawOwnedRef

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

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

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

type Output = *mut Error

type Guard = RawOwnedMut

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

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

impl<'a> UnsafeFromValue for &'a Error

type Output = *const Error

type Guard = RawOwnedRef

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

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

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

type Output = *mut Error

type Guard = RawOwnedMut

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

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

impl<'_> UnsafeFromValue for &'_ Result<Value, Value>

type Output = *const Result<Value, Value>

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ str

type Output = *const str

type Guard = Option<RawOwnedRef>

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

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

impl<'_> UnsafeFromValue for &'_ mut str

type Output = *mut str

type Guard = Option<RawOwnedMut>

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

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

impl<'_> UnsafeFromValue for &'_ String

type Output = *const String

type Guard = Option<RawOwnedRef>

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

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

impl<'_> UnsafeFromValue for &'_ mut String

type Output = *mut String

type Guard = RawOwnedMut

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

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

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

type Output = *const [Value]

type Guard = RawOwnedRef

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

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

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

type Output = *const Vec<Value>

type Guard = RawOwnedRef

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

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

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

type Output = *mut Vec<Value>

type Guard = RawOwnedMut

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

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

impl<'a> UnsafeFromValue for &'a Error

type Output = *const Error

type Guard = RawOwnedRef

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

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

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

type Output = *mut Error

type Guard = RawOwnedMut

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

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

Loading content...

Implementors

impl<'_> UnsafeFromValue for &'_ GeneratorState

type Output = *const GeneratorState

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ Function

type Output = *const Function

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ Future

type Output = *const Future

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ Generator

type Output = *const Generator

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ Stream

type Output = *const Stream

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ Object<Value>

type Output = *const Object<Value>

type Guard = RawOwnedRef

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

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

impl<'_> UnsafeFromValue for &'_ mut GeneratorState

type Output = *mut GeneratorState

type Guard = RawOwnedMut

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

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

impl<'_> UnsafeFromValue for &'_ mut Future

type Output = *mut Future

type Guard = RawOwnedMut

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

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

impl<'_> UnsafeFromValue for &'_ mut Generator

type Output = *mut Generator

type Guard = RawOwnedMut

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

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

impl<'_> UnsafeFromValue for &'_ mut Stream

type Output = *mut Stream

type Guard = RawOwnedMut

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

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

impl<'_> UnsafeFromValue for &'_ mut Object<Value>

type Output = *mut Object<Value>

type Guard = RawOwnedMut

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

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

impl<'a> UnsafeFromValue for &'a runestick::modules::object::Iter

type Output = *const Iter

type Guard = RawOwnedRef

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

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

impl<'a> UnsafeFromValue for &'a runestick::modules::vec::Iter

type Output = *const Iter

type Guard = RawOwnedRef

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

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

impl<'a> UnsafeFromValue for &'a Bytes

type Output = *const Bytes

type Guard = RawOwnedRef

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

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

impl<'a> UnsafeFromValue for &'a mut runestick::modules::object::Iter

type Output = *mut Iter

type Guard = RawOwnedMut

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

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

impl<'a> UnsafeFromValue for &'a mut runestick::modules::vec::Iter

type Output = *mut Iter

type Guard = RawOwnedMut

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

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

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

type Output = *mut Bytes

type Guard = RawOwnedMut

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

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

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

type Output = T

type Guard = ()

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

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

Loading content...