Struct gluon_vm::api::de::De

pub struct De<T>(pub T);

Getable wrapper which extracts T by deserializing it into a rust value.

Struct

#[macro_use]
extern crate serde_derive;

#[macro_use]
extern crate gluon_vm;

use gluon::{Thread, ThreadExt, new_vm};
use gluon::base::types::ArcType;
use gluon::vm::api::VmType;
use gluon::vm::api::de::De;

#[derive(Debug, PartialEq, Deserialize)]
struct Vec2 {
    x: f64,
    y: f64
}

impl VmType for Vec2 {
    type Type = Self;

    fn make_type(thread: &Thread) -> ArcType {
        field_decl!{ x, y }
        type T = record_type! {
            x => f64,
            y => f64
        };
        T::make_type(thread)
    }
}


let thread = new_vm();

let (De(vec), _) = thread
    .run_expr::<De<Vec2>>("test", "{ x = 1.0, y = 2.0 }")
    .unwrap_or_else(|err| panic!("{}", err));
assert_eq!(vec, Vec2 {
        x: 1.0,
        y: 2.0
    });

Enum

#[macro_use]
extern crate serde_derive;

use gluon::{Thread, ThreadExt, new_vm};
use gluon::base::types::ArcType;
use gluon::vm::api::VmType;
use gluon::vm::api::de::De;

#[derive(Debug, PartialEq, Deserialize)]
enum Enum {
    A(i32),
    B { string: String, test: f64 },
}

impl VmType for Enum {
    type Type = Self;

    fn make_type(thread: &Thread) -> ArcType {
        // Use the enum type declared in gluon
        thread.find_type_info("test.Enum").unwrap().into_type()
    }
}


let thread = new_vm();

thread
    .load_script(
        "test",
        r#" type Enum = | A Int | B { string : String, test : Float } in { Enum } "#,
    )
    .unwrap_or_else(|err| panic!("{}", err));

let (De(enum_), _) = thread
    .run_expr::<De<Enum>>(
        "test",
        r#" let { Enum } = import! "test" in A 123 "#,
    )
    .unwrap_or_else(|err| panic!("{}", err));
assert_eq!(enum_, Enum::A(123));

// The field names of record variants are ignored so make sure the fields are declared correctly
let (De(enum_), _) = thread
    .run_expr::<De<Enum>>(
        "test",
        r#" let { Enum } = import! "test" in B { string = "abc", test = 3.14 } "#,
    )
    .unwrap_or_else(|err| panic!("{}", err));
assert_eq!(
    enum_,
    Enum::B {
        string: "abc".to_string(),
        test: 3.14,
    }
);

Tuple Fields

0: T

Trait Implementations

impl<'vm, 'value, T> Getable<'vm, 'value> for De<T>

where T: VmType + DeserializeOwned,

type Proxy = Variants<'value>

fn to_proxy(_vm: &'vm Thread, value: Variants<'value>) -> Result<Self::Proxy>

fn from_proxy(vm: &'vm Thread, proxy: &'value mut Self::Proxy) -> Self

fn from_value(thread: &'vm Thread, value: Variants<'value>) -> Self

impl<T> VmType for De<T>

where T: VmType,

type Type = <T as VmType>::Type

A version of Self which implements Any allowing a TypeId to be retrieved

fn make_type(thread: &Thread) -> ArcType

Creates an gluon type which maps to Self in rust

fn make_forall_type(vm: &Thread) -> ArcType

const EXTRA_ARGS: VmIndex = 0u32

How many extra arguments a function returning this type requires. Used for abstract types which when used in return position should act like they still need more arguments before they are called