Struct Record

pub struct Record {
    pub name: String,
    pub parameter: Parameter,
}

A struct typed in EXPRESS schema, e.g. A(1.0, 2.0)

FromStr

use ruststep::ast::{Record, Parameter};
use std::str::FromStr;

let record = Record::from_str("A(1, 2)").unwrap();
assert_eq!(
    record,
    Record {
        name: "A".to_string(),
        parameter: vec![Parameter::Integer(1), Parameter::Integer(2)].into(),
    }
)

Deserialize as a map

serde::Deserializer implementation for Record provides a mapping it into “map” in serde data model. The keyword is mapped into the key and the parameters are its value:

use std::{str::FromStr, collections::HashMap};
use ruststep::ast::*;
use serde::Deserialize;

let p = Record::from_str("DATA_KEYWORD(1, 2)").unwrap();

// Map can be deserialize as a hashmap
assert_eq!(
    HashMap::<String, Vec<i32>>::deserialize(&p).unwrap(),
    maplit::hashmap! {
        "DATA_KEYWORD".to_string() => vec![1, 2]
    }
);

// Map in serde can be interpreted as Rust field
#[derive(Debug, Clone, PartialEq, Deserialize)]
struct X {
    #[serde(rename = "DATA_KEYWORD")]
    a: Vec<i32>,
}
assert_eq!(
    X::deserialize(&p).unwrap(),
    X { a: vec![1, 2] }
);

Mapping to simple instance

It is deserialized as a “struct” only when the hint function serde::Deserializer::deserialize_struct is called and the struct name matches to its keyword appears in the exchange structure. See the manual of container attribute in serde for detail.

use std::{str::FromStr, collections::HashMap};
use ruststep::ast::*;
use serde::Deserialize;

let p = Record::from_str("DATA_KEYWORD(1, 2)").unwrap();

#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(rename = "DATA_KEYWORD")] // keyword matches
struct A {
    x: i32,
    y: i32,
}
assert_eq!(
    A::deserialize(&p).unwrap(),
    A { x: 1, y: 2 }
);

#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(rename = "ANOTHER_KEYWORD")] // keyword does not match
struct B {
    x: i32,
    y: i32,
}
assert!(B::deserialize(&p).is_err());

Internal mapping to complex entity instance

Complex entity in EXPRESS language is a set of two or more primitive component called partial complex entity.

ENTITY person;
  name: STRING;
END_ENTITY;

ENTITY employee SUBTYPE OF (person);
  pay: INTEGER;
END_ENTITY;

ENTITY student SUBTYPE OF (person);
  school_name: STRING;
END_ENTITY;

In this EXPRESS schema, a complex entity of person can have three components representing person, employee, and student. There are two way of mapping it from an exchange structure. The internal mapping looks like usual case:

#1 = EMPLOYEE('Hitori Goto', 10);
#2 = STUDENT('Ikuno Kita', 'Shuka');

#1 has two parameters while employee definition has a field pay. These parameters are consumed by supertype person first, and then subtype employee consumes:

#1 = EMPLOYEE('Hitori Goto', 10);
              ▲              ▲
              │              └─ map to pay in employee
              └─ map to name in person

Internal mapping cannot handle the case where both employee and student components co-exist. This case will be handled by external mapping using SubSuperRecord.

The detail of internal mapping is defined in 12.2.5.2 “Internal mapping” of ISO-10303-21.

In terms of serde data model, Record is not self-describing when using internal mapping rule. Structs using internal mapping should implement serde::Deserialize as described in subtype-supertype constraint in EXPRESS schema.

Fields

name: String

parameter: Parameter

Trait Implementations

impl AST for Record

fn parse(input: &str) -> ParseResult<'_, Self>

impl Clone for Record

fn clone(&self) -> Record

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Record

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, 'record> Deserializer<'de> for &'record Record

type Error = Error

The error type that can be returned if some error occurs during deserialization.

fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Require the Deserializer to figure out how to drive the visitor based on what data type is in the input.

fn deserialize_struct<V>( self, name: &'static str, fields: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a struct with a particular name and fields.

fn deserialize_bool<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a bool value.

fn deserialize_i8<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i8 value.

fn deserialize_i16<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i16 value.

fn deserialize_i32<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i32 value.

fn deserialize_i64<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i64 value.

fn deserialize_i128<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an i128 value.

fn deserialize_u8<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u8 value.

fn deserialize_u16<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u16 value.

fn deserialize_u32<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u32 value.

fn deserialize_u64<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a u64 value.

fn deserialize_u128<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an u128 value.

fn deserialize_f32<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f32 value.

fn deserialize_f64<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a f64 value.

fn deserialize_char<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a char value.

fn deserialize_str<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_string<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a string value and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_bytes<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and does not benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_byte_buf<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a byte array and would benefit from taking ownership of buffered data owned by the Deserializer.

fn deserialize_option<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an optional value.

fn deserialize_unit<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit value.

fn deserialize_unit_struct<V>( self, name: &'static str, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a unit struct with a particular name.

fn deserialize_newtype_struct<V>( self, name: &'static str, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a newtype struct with a particular name.

fn deserialize_seq<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values.

fn deserialize_tuple<V>( self, len: usize, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a sequence of values and knows how many values there are without looking at the serialized data.

fn deserialize_tuple_struct<V>( self, name: &'static str, len: usize, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a tuple struct with a particular name and number of fields.

fn deserialize_map<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting a map of key-value pairs.

fn deserialize_enum<V>( self, name: &'static str, variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting an enum value with a particular name and possible variants.

fn deserialize_identifier<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type is expecting the name of a struct field or the discriminant of an enum variant.

fn deserialize_ignored_any<V>( self, visitor: V, ) -> Result<V::Value, <Self as Deserializer<'de>>::Error>

where V: Visitor<'de>,

Hint that the Deserialize type needs to deserialize a value whose type doesn’t matter because it is ignored.

fn is_human_readable(&self) -> bool

Determine whether Deserialize implementations should expect to deserialize their human-readable form.

impl<'a> FromIterator<&'a Record> for SubSuperRecord

fn from_iter<I: IntoIterator<Item = &'a Record>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Record> for SubSuperRecord

fn from_iter<I: IntoIterator<Item = Record>>(iter: I) -> Self

Creates a value from an iterator.

impl FromStr for Record

type Err = Error

The associated error which can be returned from parsing.

fn from_str(input: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl PartialEq for Record

fn eq(&self, other: &Record) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Record