Trait gluon_vm::api::Pushable

pub trait Pushable<'vm>: AsyncPushable<'vm> {
    fn push(self, vm: &'vm Thread, context: &mut Context) -> Result<()>;

    fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status
    where
        Self: Sized,
    { ... }
    unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value>
    where
        Self: Sized,
    { ... }
    fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>>
    where
        Self: Sized,
        T: VmRoot<'vm>,
    { ... }
}

Trait which allows a rust value to be pushed to the virtual machine

Required Methods

fn push(self, vm: &'vm Thread, context: &mut Context) -> Result<()>

Pushes self to stack. If the call is successful a single element should have been added to the stack and Ok(()) should be returned. If the call is unsuccessful Status:Error should be returned and the stack should be left intact

Provided Methods

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where
    Self: Sized, 

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where
    Self: Sized, 

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where
    Self: Sized,
    T: VmRoot<'vm>, 

Implementations on Foreign Types

impl<'vm> Pushable<'vm> for ()

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for u8

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for i16

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for i32

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for i64

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for u16

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for u32

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for u64

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for usize

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for isize

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for f64

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for bool

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for Ordering

fn push(self, _vm: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, 's> Pushable<'vm> for &'s String

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, 's> Pushable<'vm> for &'s str

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for String

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm> Pushable<'vm> for char

fn push(self, _: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'s, 'vm, T> Pushable<'vm> for Ref<'s, T> where     &'t T: Pushable<'vm>,     T: VmType,

fn push(self, vm: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, 's, T> Pushable<'vm> for &'s [T] where     T: Traverseable + Pushable<'vm> + 's,     &'s [T]: DataDef<Value = ValueArray>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, T> Pushable<'vm> for Vec<T> where     T: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, T: Pushable<'vm>> Pushable<'vm> for Option<T>

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, T: Pushable<'vm>, E: Pushable<'vm>> Pushable<'vm> for StdResult<T, E>

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, A, B, C, D, E, F, G, H, I, J, K, L> Pushable<'vm> for (A, B, C, D, E, F, G, H, I, J, K, L) where     A: Pushable<'vm>,     B: Pushable<'vm>,     C: Pushable<'vm>,     D: Pushable<'vm>,     E: Pushable<'vm>,     F: Pushable<'vm>,     G: Pushable<'vm>,     H: Pushable<'vm>,     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, B, C, D, E, F, G, H, I, J, K, L> Pushable<'vm> for (B, C, D, E, F, G, H, I, J, K, L) where     B: Pushable<'vm>,     C: Pushable<'vm>,     D: Pushable<'vm>,     E: Pushable<'vm>,     F: Pushable<'vm>,     G: Pushable<'vm>,     H: Pushable<'vm>,     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, C, D, E, F, G, H, I, J, K, L> Pushable<'vm> for (C, D, E, F, G, H, I, J, K, L) where     C: Pushable<'vm>,     D: Pushable<'vm>,     E: Pushable<'vm>,     F: Pushable<'vm>,     G: Pushable<'vm>,     H: Pushable<'vm>,     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, D, E, F, G, H, I, J, K, L> Pushable<'vm> for (D, E, F, G, H, I, J, K, L) where     D: Pushable<'vm>,     E: Pushable<'vm>,     F: Pushable<'vm>,     G: Pushable<'vm>,     H: Pushable<'vm>,     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, E, F, G, H, I, J, K, L> Pushable<'vm> for (E, F, G, H, I, J, K, L) where     E: Pushable<'vm>,     F: Pushable<'vm>,     G: Pushable<'vm>,     H: Pushable<'vm>,     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, F, G, H, I, J, K, L> Pushable<'vm> for (F, G, H, I, J, K, L) where     F: Pushable<'vm>,     G: Pushable<'vm>,     H: Pushable<'vm>,     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, G, H, I, J, K, L> Pushable<'vm> for (G, H, I, J, K, L) where     G: Pushable<'vm>,     H: Pushable<'vm>,     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, H, I, J, K, L> Pushable<'vm> for (H, I, J, K, L) where     H: Pushable<'vm>,     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, I, J, K, L> Pushable<'vm> for (I, J, K, L) where     I: Pushable<'vm>,     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, J, K, L> Pushable<'vm> for (J, K, L) where     J: Pushable<'vm>,     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

impl<'vm, K, L> Pushable<'vm> for (K, L) where     K: Pushable<'vm>,     L: Pushable<'vm>,

fn push(self, thread: &'vm Thread, context: &mut Context) -> Result<()>

fn status_push(self, vm: &'vm Thread, context: &mut Context) -> Status where     Self: Sized,

unsafe fn marshal_unrooted(self, vm: &'vm Thread) -> Result<Value> where     Self: Sized,

fn marshal<T>(self, vm: &'vm Thread) -> Result<RootedValue<T>> where     Self: Sized,     T: VmRoot<'vm>,

Implementors

• impl<'vm, T, U> Pushable<'vm> for Record<T, U> where     U: PushableFieldList<'vm>,

• impl<'vm, T: VmType> Pushable<'vm> for Generic<T>

• impl<'vm, T: Userdata> Pushable<'vm> for T

• impl<'vm, T> Pushable<'vm> for WithVM<'vm, T> where     T: Pushable<'vm>,

• impl<'vm, T: Pushable<'vm>, E: Display> Pushable<'vm> for RuntimeResult<T, E>

• impl<'vm, T: Pushable<'vm>> Pushable<'vm> for IO<T>

• impl<'vm, T, V> Pushable<'vm> for OpaqueValue<T, V> where     T: Deref<Target = Thread>,     V: VmType,     V::Type: Sized,

• impl<'vm, T: VmType> Pushable<'vm> for Array<'vm, T> where     T::Type: Sized,

• impl<'vm, T, R: ?Sized> Pushable<'vm> for PushAsRef<T, R> where     T: AsRef<R>,     &'a R: Pushable<'vm>,

• impl<'vm, F> Pushable<'vm> for Primitive<F> where     F: FunctionType + VmType,

• impl<'vm, F> Pushable<'vm> for RefPrimitive<'vm, F> where     F: VmFunction<'vm> + FunctionType + VmType + 'vm,

• impl<'vm> Pushable<'vm> for CPrimitive

• impl<'vm, T, F: Any> Pushable<'vm> for Function<T, F> where     T: Deref<Target = Thread>,     F: VmType,

• impl<'vm, T: VmType> Pushable<'vm> for TypedBytecode<T>

• impl<'vm> Pushable<'vm> for RootedThread