iso_10303/step/
structure.rs

1use super::Real;
2use std::collections::HashSet;
3use std::hash::Hash;
4use std::iter::FromIterator;
5
6#[derive(Debug)]
7pub enum Parameter {
8    TypedParameter(TypedParameter),
9    UnTypedParameter(UnTypedParameter),
10    OmittedParameter,
11}
12
13#[derive(Debug)]
14pub struct TypedParameter {
15    pub type_name: String,
16    pub parameters: Vec<Parameter>,
17}
18
19#[derive(Debug)]
20pub enum UnTypedParameter {
21    List(Vec<Parameter>),
22    EnumValue(String),
23    EntityRef(i64),
24    ConstantRef(String),
25    Integer(i64),
26    Real(f64),
27    String(String),
28    Binary(()),
29    Null,
30}
31
32#[derive(Debug)]
33pub struct EntityInstance {
34    pub id: i64,
35    pub value: Vec<TypedParameter>,
36}
37
38#[derive(Eq, PartialEq, Hash, Debug, Default)]
39pub struct EntityRef(pub i64);
40
41#[derive(Debug)]
42pub struct ExchangeFile {
43    pub header: Vec<TypedParameter>,
44    pub data: Vec<EntityInstance>,
45}
46
47impl Parameter {
48    pub fn is_null(&self) -> bool {
49        match self {
50            Parameter::UnTypedParameter(parameter) => match parameter {
51                UnTypedParameter::Null => true,
52                _ => false,
53            },
54            Parameter::OmittedParameter => true,
55            _ => false,
56        }
57    }
58}
59
60impl From<Parameter> for bool {
61    fn from(parameter: Parameter) -> Self {
62        match parameter {
63            Parameter::UnTypedParameter(parameter) => parameter.into(),
64            _ => panic!("can not convert"),
65        }
66    }
67}
68
69impl From<Parameter> for Option<bool> {
70    fn from(parameter: Parameter) -> Self {
71        match parameter {
72            Parameter::UnTypedParameter(parameter) => parameter.into(),
73            Parameter::OmittedParameter => None,
74            _ => panic!("can not convert"),
75        }
76    }
77}
78
79impl From<Parameter> for i64 {
80    fn from(parameter: Parameter) -> Self {
81        match parameter {
82            Parameter::UnTypedParameter(parameter) => parameter.into(),
83            _ => panic!("can not convert"),
84        }
85    }
86}
87
88impl From<Parameter> for Real {
89    fn from(parameter: Parameter) -> Self {
90        match parameter {
91            Parameter::UnTypedParameter(parameter) => parameter.into(),
92            _ => panic!("can not convert"),
93        }
94    }
95}
96
97impl From<Parameter> for String {
98    fn from(parameter: Parameter) -> Self {
99        match parameter {
100            Parameter::UnTypedParameter(parameter) => parameter.into(),
101            _ => panic!("can not convert"),
102        }
103    }
104}
105
106impl From<Parameter> for EntityRef {
107    fn from(parameter: Parameter) -> Self {
108        match parameter {
109            Parameter::UnTypedParameter(parameter) => parameter.into(),
110            Parameter::OmittedParameter => EntityRef(0),
111            _ => panic!("can not convert"),
112        }
113    }
114}
115
116impl<T: From<Parameter>> From<Parameter> for Vec<T> {
117    fn from(parameter: Parameter) -> Self {
118        match parameter {
119            Parameter::UnTypedParameter(untyped_parameter) => match untyped_parameter {
120                UnTypedParameter::List(list) => list.into_iter().map(|item| item.into()).collect(),
121                _ => panic!("parameter is not an list"),
122            },
123            Parameter::OmittedParameter => Vec::new(),
124            _ => panic!("parameter is not an list"),
125        }
126    }
127}
128
129impl<T: From<Parameter> + Eq + Hash> From<Parameter> for HashSet<T> {
130    fn from(parameter: Parameter) -> Self {
131        match parameter {
132            Parameter::UnTypedParameter(parameter) => parameter.into(),
133            Parameter::OmittedParameter => HashSet::new(),
134            _ => panic!("can not convert"),
135        }
136    }
137}
138
139impl From<UnTypedParameter> for bool {
140    fn from(parameter: UnTypedParameter) -> Self {
141        match parameter {
142            UnTypedParameter::EnumValue(value) => match value.as_str() {
143                "T" => true,
144                "F" => false,
145                _ => panic!("invalid boolean value {}", value),
146            },
147            _ => panic!("can not convert to boolean"),
148        }
149    }
150}
151
152impl From<UnTypedParameter> for Option<bool> {
153    fn from(parameter: UnTypedParameter) -> Self {
154        match parameter {
155            UnTypedParameter::EnumValue(value) => match value.as_str() {
156                "T" => Some(true),
157                "F" => Some(false),
158                "U" => None,
159                _ => panic!("invalid boolean value {}", value),
160            },
161            _ => panic!("can not convert to boolean"),
162        }
163    }
164}
165
166impl From<UnTypedParameter> for i64 {
167    fn from(parameter: UnTypedParameter) -> Self {
168        match parameter {
169            UnTypedParameter::Integer(number) => number,
170            _ => panic!("can not convert to integer"),
171        }
172    }
173}
174
175impl From<UnTypedParameter> for Real {
176    fn from(parameter: UnTypedParameter) -> Self {
177        match parameter {
178            UnTypedParameter::Real(number) => Real(number),
179            _ => panic!("can not convert to real"),
180        }
181    }
182}
183
184impl From<UnTypedParameter> for String {
185    fn from(parameter: UnTypedParameter) -> Self {
186        match parameter {
187            UnTypedParameter::String(string) => string,
188            UnTypedParameter::Null => String::default(),
189            _ => panic!("can not convert to string"),
190        }
191    }
192}
193
194impl From<UnTypedParameter> for EntityRef {
195    fn from(parameter: UnTypedParameter) -> Self {
196        match parameter {
197            UnTypedParameter::EntityRef(id) => EntityRef(id),
198            _ => panic!("can not convert"),
199        }
200    }
201}
202
203impl<T: From<Parameter> + Eq + Hash> From<UnTypedParameter> for HashSet<T> {
204    fn from(parameter: UnTypedParameter) -> Self {
205        match parameter {
206            UnTypedParameter::List(values) => HashSet::from_iter(values.into_iter().map(|value| T::from(value))),
207            _ => panic!("can not convert"),
208        }
209    }
210}
iso_10303/step/structure.rs

iso_10303/step/
structure.rs
