cmajor 0.7.0

Rust bindings for the Cmajor JIT engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use {
    crate::value::types::{Array, Object, Primitive, Type},
    indexmap::IndexMap,
    serde::Deserialize,
    serde_json as json,
};

#[derive(Debug, Copy, Clone, Deserialize)]
enum TypeTag {
    #[serde(rename = "void")]
    Void,

    #[serde(rename = "bool")]
    Bool,

    #[serde(rename = "int32")]
    Int32,

    #[serde(rename = "int64")]
    Int64,

    #[serde(rename = "float32")]
    Float32,

    #[serde(rename = "float64")]
    Float64,

    #[serde(rename = "string")]
    String,

    #[serde(rename = "array")]
    Array,

    #[serde(rename = "object")]
    Object,

    #[serde(rename = "vector")]
    Vector,
}

#[derive(Debug, Clone, Deserialize)]
pub(crate) struct TypeDescription {
    #[serde(rename = "type")]
    type_tag: TypeTag,

    #[serde(rename = "class")]
    class: Option<String>,

    #[serde(rename = "members")]
    members: Option<IndexMap<String, Self>>,

    #[serde(rename = "element")]
    element: Option<Box<Self>>,

    #[serde(rename = "size")]
    size: Option<usize>,

    #[serde(flatten)]
    _extra: json::Map<String, json::Value>,
}

#[derive(Debug, thiserror::Error)]
pub(crate) enum TypeDescriptionError {
    #[error(transparent)]
    InvalidJson(#[from] json::Error),

    #[error("struct has no class")]
    StructHasNoClass,

    #[error("struct has no members")]
    StructHasNoMembers,

    #[error("array has no element")]
    ArrayHasNoElement,

    #[error("array has no size")]
    ArrayHasNoSize,

    #[error("endpoint has an unexpected number of types")]
    UnexpectedNumberOfTypes,
}

impl TryFrom<&TypeDescription> for Type {
    type Error = TypeDescriptionError;

    fn try_from(
        TypeDescription {
            type_tag,
            members,
            element,
            size,
            class,
            ..
        }: &TypeDescription,
    ) -> Result<Self, Self::Error> {
        match type_tag {
            TypeTag::Void => Ok(Type::Primitive(Primitive::Void)),
            TypeTag::Bool => Ok(Type::Primitive(Primitive::Bool)),
            TypeTag::Int32 => Ok(Type::Primitive(Primitive::Int32)),
            TypeTag::Int64 => Ok(Type::Primitive(Primitive::Int64)),
            TypeTag::Float32 => Ok(Type::Primitive(Primitive::Float32)),
            TypeTag::Float64 => Ok(Type::Primitive(Primitive::Float64)),
            TypeTag::Object => {
                let class = class.clone().ok_or(Self::Error::StructHasNoClass)?;

                let mut object = Object::new(class);
                for (name, type_description) in
                    members.as_ref().ok_or(Self::Error::StructHasNoMembers)?
                {
                    object.add_field(name, Type::try_from(type_description)?);
                }
                Ok(object.into())
            }
            TypeTag::Array | TypeTag::Vector => {
                let element_ty: Type = element
                    .as_ref()
                    .ok_or(TypeDescriptionError::ArrayHasNoElement)?
                    .as_ref()
                    .try_into()?;
                let size = size.ok_or(TypeDescriptionError::ArrayHasNoSize)?;

                Ok(Array::new(element_ty, size).into())
            }
            TypeTag::String => Ok(Type::String),
        }
    }
}