iso-10303 0.5.0

A Rust crate for generating STEP reader code.
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

#[derive(Debug, Clone)]
pub struct Expression {
    pub operand: SimpleExpression,
    pub operations: Vec<(Operator, SimpleExpression)>,
}

#[derive(Debug, Clone)]
pub struct SimpleExpression {
    pub operand: Term,
    pub operations: Vec<(Operator, Term)>,
}

#[derive(Debug, Clone)]
pub struct Term {
    pub operand: Factor,
    pub operations: Vec<(Operator, Factor)>,
}

#[derive(Debug, Clone)]
pub struct Factor {
    pub operand: SimpleFactor,
    pub operations: Vec<(Operator, SimpleFactor)>,
}

#[derive(Debug, Clone)]
pub enum Operator {
    Equal,
    NotEqual,
    Greater,
    Less,
    GreaterOrEqual,
    LessOrEqual,
    InstanceEqual,
    InstanceNotEqual,
    In,
    Like,
    Add,
    Sub,
    Mul,
    Div,
    Mod,
    Or,
    Xor,
    And,
    Not,
    Neg,
    Power,
}

#[derive(Debug, Clone)]
pub enum SimpleFactor {
    AggregateInitializer {
        elements: Vec<Box<Expression>>,
    },
    EnityConstructor {
        entity: String,
        parameters: Vec<Box<Expression>>,
    },
    EnumReference,
    Interval {
        low: Box<SimpleExpression>,
        op1: Operator,
        term: Box<SimpleExpression>,
        op2: Operator,
        high: Box<SimpleExpression>,
    },
    QueryExpression {
        variable: String,
        source: Box<SimpleExpression>,
        condition: Box<Expression>,
    },
    UnaryExpression {
        op: Operator,
        operand: QualifiedAccess,
    },
    QualifiedAccess(QualifiedAccess),
}

#[derive(Debug, Clone)]
pub struct QualifiedAccess {
    pub base: Primary,
    pub accessors: Vec<Accessor>,
}

#[derive(Debug, Clone)]
pub enum Primary {
    Literal(Literal),
    Constant(String),
    Reference(String),
    Grouped(Box<Expression>),
}

#[derive(Debug, Clone)]
pub enum Literal {
    Binary(String),
    Integer(i64),
    Real(f64),
    Logical(Option<bool>),
    String(String),
}

#[derive(Debug, Clone)]
pub enum Accessor {
    FunctionCall {
        parameters: Vec<Box<Expression>>,
    },
    Indexer {
        start: Box<SimpleExpression>,
        end: Option<Box<SimpleExpression>>,
    },
    Attribute {
        name: String,
    },
    Group {
        entity: String,
    },
}