Struct ruststep::ast::SubSuperRecord

pub struct SubSuperRecord(pub Vec<Record>);

A set of Record mapping to complex entity instance, e.g. (A(1) B(2.0) C("3"))

FromStr

use ruststep::ast::*;
use std::str::FromStr;

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

Deserialize as a map

Similar to Record, SubSuperRecord can be deserialized as a “map”:

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

let p = SubSuperRecord::from_str("(A(1, 2) B(3, 4))").unwrap();

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

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

External mapping to complex entity instance

As discussed in Record for internal mapping,

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;

The instance of person may have three partial complex entity. External mapping has different looks in exchange structure:

#3 = (PERSON('Hitori Goto') EMPLOYEE(10));
#4 = (PERSON('Ikuno Kita') STUDENT('Shuka));
#5 = (PERSON('Nizika Iziti') EMPLOYEE(15) STUDENT('Simokitazawa'))

Each components enclosed by () corresponds to a partial entity instance, which consists of fields declared in its entity definition.

#5 = (PERSON('Nizika Iziti') EMPLOYEE(15) STUDENT('Simokitazawa'))
             ▲                        ▲           ▲
             │                        │           └─ school_name in student
             │                        └─ pay in employee
             └─ name in person

The detail of external mapping is defined in 12.2.5.3 “External mapping” of ISO-10303-21.

SubSuperRecord is not self-describing because EXPRESS does not defines memory layout of complex entities.

Tuple Fields

0: Vec<Record>

Trait Implementations

impl AST for SubSuperRecord

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

impl Clone for SubSuperRecord

fn clone(&self) -> SubSuperRecord

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SubSuperRecord

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

Formats the value using the given formatter.

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

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_bool<V>(self, visitor: V) -> Result<V::Value, Self::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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::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_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_tuple_struct<V>(
    self,
    name: &'static str,
    len: usize,
    visitor: V
) -> Result<V::Value, Self::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::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::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::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::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 SubSuperRecord

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 IntoIterator for SubSuperRecord

type Item = Record

The type of the elements being iterated over.

type IntoIter = IntoIter<Self::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a SubSuperRecord

type Item = &'a Record

The type of the elements being iterated over.

type IntoIter = Iter<'a, Record>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq<SubSuperRecord> for SubSuperRecord

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for SubSuperRecord