1use std::collections::{HashMap, HashSet};
16use std::io;
17
18use crate::error::{Error, Result};
19use crate::model::{Graph, ProductStructure};
20use crate::p21::{Exchange, Numbering, Replacements, TokenKind, Writer, parse};
21use crate::record::text;
22
23#[derive(Debug, Clone, PartialEq, Eq)]
25#[non_exhaustive]
26pub struct Assembled {
27 pub text: Vec<u8>,
29 pub files: Vec<String>,
32}
33
34pub type Load<'a> = dyn FnMut(&str) -> io::Result<Vec<u8>> + 'a;
36
37pub fn assemble(src: &[u8], load: &mut Load<'_>) -> Result<Assembled> {
47 let graph = Graph::new(parse(src)?)?;
48 let exchange = graph.exchange();
49 if links(&graph).is_empty() {
50 return Ok(Assembled {
51 text: src.to_vec(),
52 files: Vec::new(),
53 });
54 }
55 let mut merger = Merger {
56 load,
57 next: max_id(exchange),
58 merged: HashMap::new(),
59 active: Vec::new(),
60 out: Vec::new(),
61 files: Vec::new(),
62 };
63 let (kept, replacements) = merger.resolve(&graph)?;
64 let mut out = Vec::new();
65 Writer::new(exchange)
66 .replacements(&replacements)
67 .append(&merger.out)
68 .write_selection(kept, &mut out)?;
69 Ok(Assembled {
70 text: out,
71 files: merger.files,
72 })
73}
74
75#[derive(Debug, Clone, Copy)]
77struct Target {
78 definition: u64,
79 product: Option<u64>,
80 formation: Option<u64>,
81 shape: Option<u64>,
82 shape_link: Option<u64>,
83 representation: Option<u64>,
84}
85
86struct Candidate {
88 product: Option<String>,
89 root: bool,
90 target: Target,
91}
92
93struct Merger<'l, 'a> {
94 load: &'l mut Load<'a>,
95 next: u64,
97 merged: HashMap<String, Vec<Candidate>>,
98 active: Vec<String>,
100 out: Vec<u8>,
102 files: Vec<String>,
103}
104
105impl Merger<'_, '_> {
106 fn resolve(&mut self, graph: &Graph<'_>) -> Result<(Vec<usize>, Replacements)> {
109 let exchange = graph.exchange();
110 let structure = ProductStructure::new(graph);
111 let mut dropped: HashSet<usize> = HashSet::new();
112 let mut rename: HashMap<u64, u64> = HashMap::new();
113 for link in links(graph) {
114 dropped.extend(link.chain.iter().copied());
115 let stub = structure
116 .definitions()
117 .iter()
118 .find(|definition| definition.instance == link.stub)
119 .ok_or_else(|| Error::ExternalReference {
120 file: link.file.clone(),
121 message: format!("#{} is not a product definition", link.stub),
122 })?;
123 let wanted = stub.product.as_ref().and_then(|p| p.id.as_deref());
124 let target = self.merge(&link.file, wanted)?;
125
126 let mut pair = |stub: Option<u64>, component: Option<u64>| {
127 if let (Some(stub), Some(component)) = (stub, component) {
128 rename.insert(stub, component);
129 if let Some(node) = graph.node(stub) {
130 dropped.insert(node);
131 }
132 }
133 };
134 pair(Some(stub.instance), Some(target.definition));
135 pair(stub.product.as_ref().map(|p| p.instance), target.product);
136 pair(formation(exchange, stub.instance), target.formation);
137 for (shape, links) in shape_definitions(graph, stub.instance) {
138 pair(Some(shape), target.shape);
139 for sdr in links {
140 pair(Some(sdr), target.shape_link);
141 }
142 }
143 for &rep in &stub.shape_representations {
144 pair(Some(rep), target.representation);
145 }
146 }
147
148 let mut replacements = Replacements::new();
149 let kept: Vec<usize> = (0..graph.len())
150 .filter(|node| !dropped.contains(node))
151 .collect();
152 for &node in &kept {
153 for token in exchange.instance_tokens(graph.instance(node)) {
154 if let TokenKind::InstanceName(id) = token.kind {
155 if let Some(new) = rename.get(&id) {
156 replacements.replace(token.span, format!("#{new}"));
157 }
158 }
159 }
160 }
161 Ok((kept, replacements))
162 }
163
164 fn merge(&mut self, file: &str, wanted: Option<&str>) -> Result<Target> {
167 let failed = |message: String| Error::ExternalReference {
168 file: file.to_owned(),
169 message,
170 };
171 if !self.merged.contains_key(file) {
172 if self.active.iter().any(|active| active == file) {
173 return Err(failed("files refer to each other in a cycle".to_owned()));
174 }
175 let bytes = (self.load)(file).map_err(|error| failed(error.to_string()))?;
176 let graph = Graph::new(parse(&bytes)?)?;
177 let exchange = graph.exchange();
178 let offset = self.next;
179 self.next += max_id(exchange);
180 self.files.push(file.to_owned());
181 self.active.push(file.to_owned());
182 let (kept, replacements) = self.resolve(&graph)?;
183 self.active.pop();
184 Writer::new(exchange)
185 .numbering(Numbering::Offset(offset))
186 .replacements(&replacements)
187 .write_instances(kept, &mut self.out)?;
188 self.merged
189 .insert(file.to_owned(), candidates(&graph, offset));
190 }
191 let candidates = &self.merged[file];
192 candidates
193 .iter()
194 .find(|candidate| candidate.product.as_deref() == wanted)
195 .or_else(|| candidates.iter().find(|candidate| candidate.root))
196 .map(|candidate| candidate.target)
197 .ok_or_else(|| failed("holds no product definition".to_owned()))
198 }
199}
200
201fn candidates(graph: &Graph<'_>, offset: u64) -> Vec<Candidate> {
203 let exchange = graph.exchange();
204 let structure = ProductStructure::new(graph);
205 let renamed = |id: Option<u64>| id.map(|id| id + offset);
206 structure
207 .definitions()
208 .iter()
209 .enumerate()
210 .map(|(index, definition)| {
211 let shapes = shape_definitions(graph, definition.instance);
212 let first = shapes.first();
213 Candidate {
214 product: definition
215 .product
216 .as_ref()
217 .and_then(|p| p.id.as_deref())
218 .map(str::to_owned),
219 root: structure.roots().contains(&index),
220 target: Target {
221 definition: definition.instance + offset,
222 product: renamed(definition.product.as_ref().map(|p| p.instance)),
223 formation: renamed(formation(exchange, definition.instance)),
224 shape: renamed(first.map(|(shape, _)| *shape)),
225 shape_link: renamed(first.and_then(|(_, links)| links.first().copied())),
226 representation: renamed(definition.shape_representations.first().copied()),
227 },
228 }
229 })
230 .collect()
231}
232
233struct Link {
236 file: String,
237 stub: u64,
238 chain: Vec<usize>,
239}
240
241fn links(graph: &Graph<'_>) -> Vec<Link> {
243 let exchange = graph.exchange();
244 let first = |node: usize| exchange.records(graph.instance(node)).next();
245 let only_from = |node: usize, owner: usize| graph.referenced_by(node) == [owner];
247 let mut links = Vec::new();
248 for node in 0..graph.len() {
249 let Some(reference) = first(node).filter(|r| r.is("APPLIED_DOCUMENT_REFERENCE")) else {
250 continue;
251 };
252 if graph.instance(node).is_complex() {
253 continue;
254 }
255 let Some(document) = reference
256 .param(0)
257 .and_then(|p| p.reference())
258 .and_then(|id| graph.node(id))
259 else {
260 continue;
261 };
262 let Some(file_record) = exchange
263 .records(graph.instance(document))
264 .find(|r| r.is("DOCUMENT_FILE"))
265 else {
266 continue;
267 };
268 let mut file = text(file_record.param(0)).unwrap_or_default();
269 let mut chain = vec![node, document];
270 chain.extend(
271 graph
272 .references(document)
273 .iter()
274 .copied()
275 .filter(|&kind| only_from(kind, document)),
276 );
277 for &user in graph.referenced_by(document) {
278 let Some(record) = first(user) else {
279 continue;
280 };
281 if record.is("APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT") {
282 if let Some(id) =
283 text(record.param(0)).filter(|id| !id.is_empty() && !id.starts_with('#'))
284 {
285 file = id;
286 }
287 chain.push(user);
288 chain.extend(
289 graph
290 .references(user)
291 .iter()
292 .copied()
293 .filter(|&part| part != document && only_from(part, user)),
294 );
295 } else if record.is("DOCUMENT_REPRESENTATION_TYPE")
296 || (record.is("PROPERTY_DEFINITION")
297 && text(record.param(0)).as_deref() == Some("external definition"))
298 {
299 chain.push(user);
300 chain.extend(graph.referenced_by(user).iter().copied().filter(|&link| {
301 first(link).is_some_and(|r| r.is("PROPERTY_DEFINITION_REPRESENTATION"))
302 }));
303 }
304 }
305 for &user in graph.referenced_by(node) {
306 if first(user).is_some_and(|r| r.is("ROLE_ASSOCIATION")) {
307 chain.push(user);
308 chain.extend(
309 graph
310 .references(user)
311 .iter()
312 .copied()
313 .filter(|&role| role != node && only_from(role, user)),
314 );
315 }
316 }
317 let items = reference
318 .param(2)
319 .and_then(|p| p.list())
320 .into_iter()
321 .flatten()
322 .filter_map(|p| p.reference());
323 for stub in items {
324 links.push(Link {
325 file: file.clone(),
326 stub,
327 chain: chain.clone(),
328 });
329 }
330 }
331 links
332}
333
334fn max_id(exchange: &Exchange<'_>) -> u64 {
335 exchange.instances().iter().map(|i| i.id).max().unwrap_or(0)
336}
337
338fn formation(exchange: &Exchange<'_>, definition: u64) -> Option<u64> {
340 let record = exchange.records(exchange.get(definition)?).next()?;
341 record.param(2)?.reference()
342}
343
344fn shape_definitions(graph: &Graph<'_>, definition: u64) -> Vec<(u64, Vec<u64>)> {
347 let exchange = graph.exchange();
348 let points_at = |node: usize, entity: &str, index: usize, target: u64| {
349 exchange
350 .records(graph.instance(node))
351 .next()
352 .is_some_and(|record| {
353 record.is(entity) && record.param(index).and_then(|p| p.reference()) == Some(target)
354 })
355 };
356 let Some(node) = graph.node(definition) else {
357 return Vec::new();
358 };
359 graph
360 .referenced_by(node)
361 .iter()
362 .copied()
363 .filter(|&shape| points_at(shape, "PRODUCT_DEFINITION_SHAPE", 2, definition))
364 .map(|shape| {
365 let id = graph.instance(shape).id;
366 let links = graph
367 .referenced_by(shape)
368 .iter()
369 .copied()
370 .filter(|&sdr| points_at(sdr, "SHAPE_DEFINITION_REPRESENTATION", 0, id))
371 .map(|sdr| graph.instance(sdr).id)
372 .collect();
373 (id, links)
374 })
375 .collect()
376}
377
378#[cfg(test)]
379mod tests {
380 use super::*;
381
382 const MASTER: &str = "ISO-10303-21;HEADER;FILE_SCHEMA(('AUTOMOTIVE_DESIGN'));ENDSEC;DATA;
385#1=APPLICATION_CONTEXT('design');
386#2=APPLICATION_PROTOCOL_DEFINITION('international standard','automotive_design',2001,#1);
387#3=PRODUCT_CONTEXT('',#1,'mechanical');
388#4=PRODUCT_DEFINITION_CONTEXT('part definition',#1,'design');
389#5=GEOMETRIC_REPRESENTATION_CONTEXT(3);
390#11=PRODUCT('A','assembly','',(#3));
391#12=PRODUCT_DEFINITION_FORMATION('1','',#11);
392#10=PRODUCT_DEFINITION('a','',#12,#4);
393#13=PRODUCT_DEFINITION_SHAPE('','',#10);
394#14=SHAPE_DEFINITION_REPRESENTATION(#13,#15);
395#15=SHAPE_REPRESENTATION('',(#34),#5);
396#21=PRODUCT('P','plate','',(#3));
397#22=PRODUCT_DEFINITION_FORMATION('1','',#21);
398#20=PRODUCT_DEFINITION('p','',#22,#4);
399#23=PRODUCT_DEFINITION_SHAPE('','',#20);
400#24=SHAPE_DEFINITION_REPRESENTATION(#23,#25);
401#25=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#34),#5);
402#34=AXIS2_PLACEMENT_3D('',#35,$,$);
403#35=CARTESIAN_POINT('',(0.,0.,0.));
404#40=NEXT_ASSEMBLY_USAGE_OCCURRENCE('u1','P1','',#10,#20,$);
405#41=PRODUCT_DEFINITION_SHAPE('','',#40);
406#42=(REPRESENTATION_RELATIONSHIP('','',#25,#15)REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#43)SHAPE_REPRESENTATION_RELATIONSHIP());
407#43=ITEM_DEFINED_TRANSFORMATION('','',#34,#34);
408#44=CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#42,#41);
409#52=DOCUMENT_TYPE('geometry');
410#53=DOCUMENT_FILE('P.stp','',$,#52,'',$);
411#54=DOCUMENT_REPRESENTATION_TYPE('digital',#53);
412#55=IDENTIFICATION_ROLE('external document id and location',$);
413#56=EXTERNAL_SOURCE(IDENTIFIER(''));
414#57=APPLIED_EXTERNAL_IDENTIFICATION_ASSIGNMENT('P.stp',#55,#56,(#53));
415#58=APPLIED_DOCUMENT_REFERENCE(#53,'',(#20));
416#59=OBJECT_ROLE('mandatory',$);
417#60=ROLE_ASSOCIATION(#59,#58);
418#61=PROPERTY_DEFINITION('external definition',$,#53);
419#62=PROPERTY_DEFINITION_REPRESENTATION(#61,#25);
420ENDSEC;END-ISO-10303-21;";
421
422 const PART: &str = "ISO-10303-21;HEADER;FILE_SCHEMA(('AUTOMOTIVE_DESIGN'));ENDSEC;DATA;
423#1=APPLICATION_CONTEXT('design');
424#2=APPLICATION_PROTOCOL_DEFINITION('international standard','automotive_design',2001,#1);
425#3=PRODUCT_CONTEXT('',#1,'mechanical');
426#4=PRODUCT_DEFINITION_CONTEXT('part definition',#1,'design');
427#5=GEOMETRIC_REPRESENTATION_CONTEXT(3);
428#6=PRODUCT('P','plate','',(#3));
429#7=PRODUCT_DEFINITION_FORMATION('1','',#6);
430#8=PRODUCT_DEFINITION('p','',#7,#4);
431#9=PRODUCT_DEFINITION_SHAPE('','',#8);
432#10=SHAPE_DEFINITION_REPRESENTATION(#9,#11);
433#11=ADVANCED_BREP_SHAPE_REPRESENTATION('',(#12,#14),#5);
434#12=AXIS2_PLACEMENT_3D('',#13,$,$);
435#13=CARTESIAN_POINT('',(0.,0.,0.));
436#14=MANIFOLD_SOLID_BREP('plate',#15);
437#15=CLOSED_SHELL('',());
438ENDSEC;END-ISO-10303-21;";
439
440 fn loader(name: &str) -> io::Result<Vec<u8>> {
441 match name {
442 "P.stp" => Ok(PART.as_bytes().to_vec()),
443 _ => Err(io::Error::new(io::ErrorKind::NotFound, "no such file")),
444 }
445 }
446
447 #[test]
448 fn stubs_are_replaced_by_the_component_file() {
449 let assembled = assemble(MASTER.as_bytes(), &mut loader).unwrap();
450 assert_eq!(assembled.files, ["P.stp"]);
451 let text = String::from_utf8(assembled.text).unwrap();
452 for expected in [
454 "#40=NEXT_ASSEMBLY_USAGE_OCCURRENCE('u1','P1','',#10,#70,$);",
455 "#42=(REPRESENTATION_RELATIONSHIP('','',#73,#15)",
456 "#68=PRODUCT('P','plate','',(#65));",
457 "#70=PRODUCT_DEFINITION('p','',#69,#66);",
458 "#76=MANIFOLD_SOLID_BREP('plate',#77);",
459 ] {
460 assert!(text.contains(expected), "missing {expected}\n{text}");
461 }
462 for gone in [
463 "#20=",
464 "#21=",
465 "#22=",
466 "#23=",
467 "#24=",
468 "#25=",
469 "DOCUMENT_FILE",
470 "DOCUMENT_TYPE",
471 "APPLIED_DOCUMENT_REFERENCE",
472 "ROLE_ASSOCIATION",
473 "OBJECT_ROLE",
474 "IDENTIFICATION_ROLE",
475 "EXTERNAL_SOURCE",
476 "external definition",
477 ] {
478 assert!(!text.contains(gone), "{gone} is still there\n{text}");
479 }
480
481 let graph = Graph::new(parse(text.as_bytes()).unwrap()).unwrap();
482 let structure = ProductStructure::new(&graph);
483 assert_eq!(structure.usages().len(), 1);
484 let child = &structure.definitions()[structure.usages()[0].child];
485 assert_eq!(child.product.as_ref().unwrap().id.as_deref(), Some("P"));
486 assert_eq!(child.shape_representations, [73]);
487 }
488
489 #[test]
490 fn a_file_without_references_comes_back_unchanged() {
491 let assembled = assemble(PART.as_bytes(), &mut loader).unwrap();
492 assert_eq!(assembled.text, PART.as_bytes());
493 assert!(assembled.files.is_empty(), "{:?}", assembled.files);
494 }
495
496 #[test]
497 fn missing_files_and_cycles_are_errors() {
498 let mut missing = |_: &str| Err(io::Error::new(io::ErrorKind::NotFound, "no such file"));
499 let error = assemble(MASTER.as_bytes(), &mut missing).unwrap_err();
500 assert_eq!(
501 error.to_string(),
502 "external reference to P.stp: no such file"
503 );
504
505 let mut itself = |_: &str| Ok(MASTER.as_bytes().to_vec());
506 let error = assemble(MASTER.as_bytes(), &mut itself).unwrap_err();
507 assert_eq!(
508 error.to_string(),
509 "external reference to P.stp: files refer to each other in a cycle"
510 );
511 }
512}