use std::collections::VecDeque;
use super::Graph;
use crate::p21::{Exchange, Instance, Param, Record};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum RuleKind {
Owned,
Shared,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct Rule {
pub entities: &'static [&'static str],
pub attribute: &'static str,
pub simple: usize,
pub partial: Option<(&'static str, usize)>,
pub kind: RuleKind,
pub follow: &'static [&'static str],
}
const fn owned(
entities: &'static [&'static str],
attribute: &'static str,
simple: usize,
partial: Option<(&'static str, usize)>,
) -> Rule {
Rule {
entities,
attribute,
simple,
partial,
kind: RuleKind::Owned,
follow: &[],
}
}
const fn shared(
entities: &'static [&'static str],
attribute: &'static str,
simple: usize,
partial: Option<(&'static str, usize)>,
) -> Rule {
shared_following(entities, attribute, simple, partial, &[])
}
const fn shared_following(
entities: &'static [&'static str],
attribute: &'static str,
simple: usize,
partial: Option<(&'static str, usize)>,
follow: &'static [&'static str],
) -> Rule {
Rule {
entities,
attribute,
simple,
partial,
kind: RuleKind::Shared,
follow,
}
}
const SHAPE_ASPECTS: &[&str] = &[
"SHAPE_ASPECT",
"ALL_AROUND_SHAPE_ASPECT",
"APEX",
"BETWEEN_SHAPE_ASPECT",
"CENTRE_OF_SYMMETRY",
"COMMON_DATUM",
"COMPOSITE_GROUP_SHAPE_ASPECT",
"COMPOSITE_SHAPE_ASPECT",
"CONTINUOUS_SHAPE_ASPECT",
"DATUM",
"DATUM_FEATURE",
"DATUM_REFERENCE_COMPARTMENT",
"DATUM_REFERENCE_ELEMENT",
"DATUM_SYSTEM",
"DATUM_TARGET",
"DERIVED_SHAPE_ASPECT",
"EXTENSION",
"GENERAL_DATUM_REFERENCE",
"GEOMETRIC_ALIGNMENT",
"PARALLEL_OFFSET",
"PERPENDICULAR_TO",
"PLACED_DATUM_TARGET_FEATURE",
"SYMMETRIC_SHAPE_ASPECT",
"TANGENT",
"TOLERANCE_ZONE",
];
const SHAPE_ASPECT_RELATIONSHIPS: &[&str] = &[
"SHAPE_ASPECT_RELATIONSHIP",
"ANGULAR_LOCATION",
"DIMENSIONAL_LOCATION",
"DIMENSIONAL_LOCATION_WITH_PATH",
"DIRECTED_DIMENSIONAL_LOCATION",
"FEATURE_FOR_DATUM_TARGET_RELATIONSHIP",
"SHAPE_ASPECT_DERIVING_RELATIONSHIP",
];
const GEOMETRIC_TOLERANCES: &[&str] = &[
"GEOMETRIC_TOLERANCE",
"ANGULARITY_TOLERANCE",
"CIRCULAR_RUNOUT_TOLERANCE",
"COAXIALITY_TOLERANCE",
"CONCENTRICITY_TOLERANCE",
"CYLINDRICITY_TOLERANCE",
"FLATNESS_TOLERANCE",
"GEOMETRIC_TOLERANCE_WITH_DATUM_REFERENCE",
"GEOMETRIC_TOLERANCE_WITH_DEFINED_AREA_UNIT",
"GEOMETRIC_TOLERANCE_WITH_DEFINED_UNIT",
"GEOMETRIC_TOLERANCE_WITH_MAXIMUM_TOLERANCE",
"GEOMETRIC_TOLERANCE_WITH_MODIFIERS",
"LINE_PROFILE_TOLERANCE",
"PARALLELISM_TOLERANCE",
"PERPENDICULARITY_TOLERANCE",
"POSITION_TOLERANCE",
"ROUNDNESS_TOLERANCE",
"STRAIGHTNESS_TOLERANCE",
"SURFACE_PROFILE_TOLERANCE",
"SYMMETRY_TOLERANCE",
"TOTAL_RUNOUT_TOLERANCE",
"UNEQUALLY_DISPOSED_GEOMETRIC_TOLERANCE",
];
const ASSOCIATIONS: &[&str] = &[
"ITEM_IDENTIFIED_REPRESENTATION_USAGE",
"DRAUGHTING_MODEL_ITEM_ASSOCIATION",
"DRAUGHTING_MODEL_ITEM_ASSOCIATION_WITH_PLACEHOLDER",
"GEOMETRIC_ITEM_SPECIFIC_USAGE",
];
pub const RULES: &[Rule] = &[
owned(
&["PROPERTY_DEFINITION", "PRODUCT_DEFINITION_SHAPE"],
"definition",
2,
Some(("PROPERTY_DEFINITION", 2)),
),
owned(
&[
"PROPERTY_DEFINITION_REPRESENTATION",
"SHAPE_DEFINITION_REPRESENTATION",
],
"definition",
0,
Some(("PROPERTY_DEFINITION_REPRESENTATION", 0)),
),
owned(&["SHAPE_REPRESENTATION_RELATIONSHIP"], "rep_1", 2, None),
owned(&["SHAPE_REPRESENTATION_RELATIONSHIP"], "rep_2", 3, None),
owned(
&["GENERAL_PROPERTY_ASSOCIATION"],
"derived_definition",
3,
Some(("GENERAL_PROPERTY_ASSOCIATION", 3)),
),
owned(
&[
"NEXT_ASSEMBLY_USAGE_OCCURRENCE",
"QUANTIFIED_ASSEMBLY_COMPONENT_USAGE",
],
"relating_product_definition",
3,
Some(("PRODUCT_DEFINITION_RELATIONSHIP", 3)),
),
owned(
&["CONTEXT_DEPENDENT_SHAPE_REPRESENTATION"],
"represented_product_relation",
1,
Some(("CONTEXT_DEPENDENT_SHAPE_REPRESENTATION", 1)),
),
owned(
&["STYLED_ITEM", "OVER_RIDING_STYLED_ITEM"],
"item",
2,
Some(("STYLED_ITEM", 1)),
),
owned(
&["ANNOTATION_PLANE"],
"elements",
3,
Some(("ANNOTATION_PLANE", 0)),
),
owned(
&["MECHANICAL_DESIGN_AND_DRAUGHTING_RELATIONSHIP"],
"rep_2",
3,
Some(("REPRESENTATION_RELATIONSHIP", 3)),
),
owned(
&["MODEL_GEOMETRIC_VIEW", "DEFAULT_MODEL_GEOMETRIC_VIEW"],
"rep",
3,
Some(("CHARACTERIZED_ITEM_WITHIN_REPRESENTATION", 1)),
),
owned(
&["DEFAULT_MODEL_GEOMETRIC_VIEW"],
"of_shape",
6,
Some(("SHAPE_ASPECT", 2)),
),
owned(
&["CAMERA_USAGE"],
"mapped_representation",
1,
Some(("REPRESENTATION_MAP", 1)),
),
owned(
&["CHARACTERIZED_ITEM_WITHIN_REPRESENTATION"],
"item",
2,
Some(("CHARACTERIZED_ITEM_WITHIN_REPRESENTATION", 0)),
),
owned(
&["PRESENTED_ITEM_REPRESENTATION"],
"item",
1,
Some(("PRESENTED_ITEM_REPRESENTATION", 1)),
),
owned(&["AREA_IN_SET"], "in_set", 1, Some(("AREA_IN_SET", 1))),
owned(
&["PRESENTATION_SIZE"],
"unit",
0,
Some(("PRESENTATION_SIZE", 0)),
),
owned(
&["CONSTRUCTIVE_GEOMETRY_REPRESENTATION_RELATIONSHIP"],
"rep_1",
2,
Some(("REPRESENTATION_RELATIONSHIP", 2)),
),
owned(SHAPE_ASPECTS, "of_shape", 2, Some(("SHAPE_ASPECT", 2))),
owned(
SHAPE_ASPECT_RELATIONSHIPS,
"relating_shape_aspect",
2,
Some(("SHAPE_ASPECT_RELATIONSHIP", 2)),
),
owned(
SHAPE_ASPECT_RELATIONSHIPS,
"related_shape_aspect",
3,
Some(("SHAPE_ASPECT_RELATIONSHIP", 3)),
),
owned(
&[
"DIMENSIONAL_SIZE",
"ANGULAR_SIZE",
"DIMENSIONAL_SIZE_WITH_PATH",
],
"applies_to",
0,
Some(("DIMENSIONAL_SIZE", 0)),
),
owned(
&["DIMENSIONAL_CHARACTERISTIC_REPRESENTATION"],
"dimension",
0,
Some(("DIMENSIONAL_CHARACTERISTIC_REPRESENTATION", 0)),
),
owned(
&["MEASURE_QUALIFICATION"],
"qualified_measure",
2,
Some(("MEASURE_QUALIFICATION", 2)),
),
owned(
&["DRAUGHTING_CALLOUT_RELATIONSHIP"],
"relating_draughting_callout",
2,
Some(("DRAUGHTING_CALLOUT_RELATIONSHIP", 2)),
),
owned(
&["NAME_ATTRIBUTE"],
"named_item",
1,
Some(("NAME_ATTRIBUTE", 1)),
),
owned(
&["ID_ATTRIBUTE"],
"identified_item",
1,
Some(("ID_ATTRIBUTE", 1)),
),
owned(
&["DESCRIPTION_ATTRIBUTE"],
"described_item",
1,
Some(("DESCRIPTION_ATTRIBUTE", 1)),
),
owned(
&["PERSONAL_ADDRESS"],
"people",
12,
Some(("PERSONAL_ADDRESS", 0)),
),
owned(
&["ORGANIZATIONAL_ADDRESS"],
"organizations",
12,
Some(("ORGANIZATIONAL_ADDRESS", 0)),
),
owned(
&["APPROVAL_DATE_TIME"],
"dated_approval",
1,
Some(("APPROVAL_DATE_TIME", 1)),
),
owned(
&["APPROVAL_PERSON_ORGANIZATION"],
"authorized_approval",
1,
Some(("APPROVAL_PERSON_ORGANIZATION", 1)),
),
owned(
GEOMETRIC_TOLERANCES,
"toleranced_shape_aspect",
3,
Some(("GEOMETRIC_TOLERANCE", 3)),
),
owned(
&["PLUS_MINUS_TOLERANCE"],
"toleranced_dimension",
1,
Some(("PLUS_MINUS_TOLERANCE", 1)),
),
owned(
&["GEOMETRIC_TOLERANCE_RELATIONSHIP"],
"relating_geometric_tolerance",
2,
Some(("GEOMETRIC_TOLERANCE_RELATIONSHIP", 2)),
),
owned(
&[
"TOLERANCE_ZONE_DEFINITION",
"PROJECTED_ZONE_DEFINITION",
"NON_UNIFORM_ZONE_DEFINITION",
"RUNOUT_ZONE_DEFINITION",
],
"zone",
0,
Some(("TOLERANCE_ZONE_DEFINITION", 0)),
),
owned(
&["PRODUCT_DEFINITION_CONTEXT_ASSOCIATION"],
"definition",
0,
Some(("PRODUCT_DEFINITION_CONTEXT_ASSOCIATION", 0)),
),
owned(
&["ROLE_ASSOCIATION"],
"item_with_role",
1,
Some(("ROLE_ASSOCIATION", 1)),
),
owned(
&["DOCUMENT_PRODUCT_EQUIVALENCE"],
"relating_document",
2,
Some(("DOCUMENT_PRODUCT_ASSOCIATION", 2)),
),
owned(
ASSOCIATIONS,
"definition",
2,
Some(("ITEM_IDENTIFIED_REPRESENTATION_USAGE", 2)),
),
owned(
&["APPLICATION_PROTOCOL_DEFINITION"],
"application",
3,
Some(("APPLICATION_PROTOCOL_DEFINITION", 3)),
),
owned(
&["PRODUCT_CATEGORY_RELATIONSHIP"],
"sub_category",
3,
Some(("PRODUCT_CATEGORY_RELATIONSHIP", 3)),
),
shared(
&["PRODUCT_RELATED_PRODUCT_CATEGORY"],
"products",
2,
Some(("PRODUCT_RELATED_PRODUCT_CATEGORY", 0)),
),
shared(
&["PRESENTATION_LAYER_ASSIGNMENT"],
"assigned_items",
2,
Some(("PRESENTATION_LAYER_ASSIGNMENT", 2)),
),
shared(
&["MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION"],
"items",
1,
Some(("REPRESENTATION", 1)),
),
shared_following(
&["DRAUGHTING_MODEL"],
"items",
1,
Some(("REPRESENTATION", 1)),
&[
"CAMERA_MODEL_D2",
"CAMERA_MODEL_D3",
"CAMERA_MODEL_D3_MULTI_CLIPPING",
"CAMERA_MODEL_D3_WITH_HLHSR",
"MAPPED_ITEM",
"ANNOTATION_PLANE",
],
),
shared(
&["APPLIED_PRESENTED_ITEM"],
"items",
0,
Some(("APPLIED_PRESENTED_ITEM", 0)),
),
shared(
&["INVISIBILITY"],
"invisible_items",
0,
Some(("INVISIBILITY", 0)),
),
shared(
&[
"APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT",
"APPLIED_DATE_AND_TIME_ASSIGNMENT",
"APPLIED_DATE_ASSIGNMENT",
"APPLIED_ORGANIZATION_ASSIGNMENT",
"APPLIED_DOCUMENT_REFERENCE",
"APPLIED_IDENTIFICATION_ASSIGNMENT",
"APPLIED_CLASSIFICATION_ASSIGNMENT",
"CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT",
"CC_DESIGN_DATE_AND_TIME_ASSIGNMENT",
"CC_DESIGN_SPECIFICATION_REFERENCE",
],
"items",
2,
None,
),
shared(
&[
"APPLIED_APPROVAL_ASSIGNMENT",
"APPLIED_SECURITY_CLASSIFICATION_ASSIGNMENT",
"APPLIED_GROUP_ASSIGNMENT",
"CC_DESIGN_APPROVAL",
"CC_DESIGN_SECURITY_CLASSIFICATION",
"CC_DESIGN_CERTIFICATION",
"CC_DESIGN_CONTRACT",
],
"items",
1,
None,
),
];
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Extraction {
nodes: Vec<usize>,
pruned: Vec<usize>,
}
impl Extraction {
pub fn nodes(&self) -> &[usize] {
&self.nodes
}
pub fn pruned(&self) -> &[usize] {
&self.pruned
}
pub fn contains(&self, node: usize) -> bool {
self.nodes.binary_search(&node).is_ok()
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum State {
Out,
Owned,
Shared(&'static Rule),
Excluded,
}
pub fn extract(graph: &Graph<'_>, seeds: &[usize]) -> Extraction {
extract_excluding(graph, seeds, &[])
}
pub fn extract_excluding(graph: &Graph<'_>, seeds: &[usize], excluded: &[usize]) -> Extraction {
let exchange = graph.exchange();
let mut state = vec![State::Out; graph.len()];
for &node in excluded {
state[node] = State::Excluded;
}
let mut queue = VecDeque::new();
let take = |node: usize, state: &mut [State], queue: &mut VecDeque<usize>| {
if state[node] == State::Out {
state[node] =
shared_rule(exchange, graph.instance(node)).map_or(State::Owned, State::Shared);
queue.push_back(node);
}
};
for &seed in seeds {
take(seed, &mut state, &mut queue);
}
let mut targets = Vec::new();
while let Some(node) = queue.pop_front() {
let instance = graph.instance(node);
match state[node] {
State::Shared(rule) => {
targets.clear();
references_outside(exchange, instance, rule, &mut targets);
followed_items(graph, instance, rule, &mut targets);
for &id in &targets {
if let Some(target) = graph.node(id) {
take(target, &mut state, &mut queue);
}
}
}
_ => {
for &target in graph.references(node) {
take(target, &mut state, &mut queue);
}
}
}
for &referrer in graph.referenced_by(node) {
if state[referrer] == State::Out
&& matching_rule(exchange, graph.instance(referrer), instance.id).is_some()
{
take(referrer, &mut state, &mut queue);
}
}
}
let mut nodes = Vec::new();
let mut pruned = Vec::new();
let state_of = &state;
for (node, state) in state.iter().enumerate() {
match state {
State::Out | State::Excluded => {}
State::Owned => {
nodes.push(node);
let lists_excluded = || {
graph
.references(node)
.iter()
.any(|&target| state_of[target] == State::Excluded)
};
if !excluded.is_empty() && lists_excluded() {
pruned.push(node);
}
}
State::Shared(_) => {
nodes.push(node);
pruned.push(node);
}
}
}
Extraction { nodes, pruned }
}
pub fn orphans(graph: &Graph<'_>, extractions: &[Extraction]) -> Vec<usize> {
let mut taken = vec![false; graph.len()];
for extraction in extractions {
for &node in extraction.nodes() {
taken[node] = true;
}
}
(0..graph.len()).filter(|&node| !taken[node]).collect()
}
pub fn unreachable(graph: &Graph<'_>, orphans: &[usize]) -> Vec<usize> {
let mut orphan = vec![false; graph.len()];
for &node in orphans {
orphan[node] = true;
}
let mut reached = vec![false; graph.len()];
let mut queue = VecDeque::new();
let reach = |target: usize, reached: &mut [bool], queue: &mut VecDeque<usize>| {
if orphan[target] && !reached[target] {
reached[target] = true;
queue.push_back(target);
}
};
for node in (0..graph.len()).filter(|&node| !orphan[node]) {
for &target in graph.references(node) {
reach(target, &mut reached, &mut queue);
}
}
while let Some(node) = queue.pop_front() {
for &target in graph.references(node) {
reach(target, &mut reached, &mut queue);
}
}
orphans
.iter()
.copied()
.filter(|&node| !reached[node])
.collect()
}
fn matching_rule(
exchange: &Exchange<'_>,
instance: &Instance,
target: u64,
) -> Option<&'static Rule> {
RULES.iter().find(|rule| {
rule_param(exchange, instance, rule).is_some_and(|param| {
let mut ids = Vec::new();
collect_references(¶m, &mut ids);
ids.contains(&target)
})
})
}
fn shared_rule(exchange: &Exchange<'_>, instance: &Instance) -> Option<&'static Rule> {
RULES
.iter()
.filter(|rule| rule.kind == RuleKind::Shared)
.find(|rule| rule_record(exchange, instance, rule).is_some())
}
fn rule_record<'e>(
exchange: &'e Exchange<'_>,
instance: &Instance,
rule: &Rule,
) -> Option<(Record<'e>, usize)> {
let mut records = exchange.records(instance);
if instance.is_complex() {
let (partial, index) = rule.partial?;
let has_entity = records
.clone()
.any(|record| rule.entities.iter().any(|entity| record.is(entity)));
if !has_entity {
return None;
}
records
.find(|record| record.is(partial))
.map(|record| (record, index))
} else {
let record = records.next()?;
rule.entities
.iter()
.any(|entity| record.is(entity))
.then_some((record, rule.simple))
}
}
fn rule_param<'e>(
exchange: &'e Exchange<'_>,
instance: &Instance,
rule: &Rule,
) -> Option<Param<'e>> {
let (record, index) = rule_record(exchange, instance, rule)?;
record.param(index)
}
fn references_outside(
exchange: &Exchange<'_>,
instance: &Instance,
rule: &Rule,
out: &mut Vec<u64>,
) {
let skip = rule_record(exchange, instance, rule);
for record in exchange.records(instance) {
for (index, param) in record.params().enumerate() {
let skipped = skip.is_some_and(|(held, position)| {
position == index && held.name().eq_ignore_ascii_case(record.name())
});
if !skipped {
collect_references(¶m, out);
}
}
}
}
fn followed_items(graph: &Graph<'_>, instance: &Instance, rule: &Rule, out: &mut Vec<u64>) {
if rule.follow.is_empty() {
return;
}
let exchange = graph.exchange();
let Some(list) = rule_param(exchange, instance, rule) else {
return;
};
let mut items = Vec::new();
collect_references(&list, &mut items);
let is_association = |node: usize| {
exchange.records(graph.instance(node)).any(|record| {
ASSOCIATIONS
.iter()
.any(|association| record.is(association))
})
};
for id in items {
let Some(node) = graph.node(id) else {
continue;
};
let mut records = exchange.records(graph.instance(node));
if !records
.clone()
.any(|record| rule.follow.iter().any(|entity| record.is(entity)))
{
continue;
}
let plane = records.any(|record| record.is("ANNOTATION_PLANE"));
let associated = || {
graph.references(node).iter().any(|&element| {
graph
.referenced_by(element)
.iter()
.any(|&referrer| is_association(referrer))
})
};
if !plane || !associated() {
out.push(id);
}
}
}
fn collect_references(param: &Param<'_>, out: &mut Vec<u64>) {
match param {
Param::Reference(id) => out.push(*id),
Param::List(items) => {
for item in items.clone() {
collect_references(&item, out);
}
}
Param::Typed(record) => {
for item in record.params() {
collect_references(&item, out);
}
}
_ => {}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::p21::parse;
const SAMPLE: &str = "ISO-10303-21;HEADER;FILE_SCHEMA(('AP214'));ENDSEC;DATA;
#1=APPLICATION_CONTEXT('design');
#2=APPLICATION_PROTOCOL_DEFINITION('international standard','automotive_design',2001,#1);
#3=PRODUCT_CONTEXT('',#1,'mechanical');
#4=PRODUCT_DEFINITION_CONTEXT('part definition',#1,'design');
#11=PRODUCT('A','assembly','',(#3));
#12=PRODUCT_DEFINITION_FORMATION('1','',#11);
#10=PRODUCT_DEFINITION('a','',#12,#4);
#31=PRODUCT('C','bolt','',(#3));
#32=PRODUCT_DEFINITION_FORMATION('1','',#31);
#30=PRODUCT_DEFINITION('c','',#32,#4);
#40=PRODUCT_RELATED_PRODUCT_CATEGORY('part','',(#11,#31));
#50=SHAPE_REPRESENTATION('a',(#60),#90);
#52=SHAPE_REPRESENTATION('c',(#60,#53),#90);
#53=MANIFOLD_SOLID_BREP('solid',#54);
#54=CLOSED_SHELL('',());
#60=AXIS2_PLACEMENT_3D('',#61,$,$);
#61=CARTESIAN_POINT('',(0.,0.,0.));
#70=PRODUCT_DEFINITION_SHAPE('','',#10);
#72=PRODUCT_DEFINITION_SHAPE('','',#30);
#80=SHAPE_DEFINITION_REPRESENTATION(#70,#50);
#82=SHAPE_DEFINITION_REPRESENTATION(#72,#52);
#90=GEOMETRIC_REPRESENTATION_CONTEXT(3);
#100=NEXT_ASSEMBLY_USAGE_OCCURRENCE('u1','C1','',#10,#30,$);
#101=PRODUCT_DEFINITION_SHAPE('','',#100);
#102=(REPRESENTATION_RELATIONSHIP('','',#52,#50)REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION(#103)SHAPE_REPRESENTATION_RELATIONSHIP());
#103=ITEM_DEFINED_TRANSFORMATION('','',#60,#60);
#104=CONTEXT_DEPENDENT_SHAPE_REPRESENTATION(#102,#101);
#110=STYLED_ITEM('',(#111),#53);
#111=PRESENTATION_STYLE_ASSIGNMENT(());
#120=PRESENTATION_LAYER_ASSIGNMENT('layer 1','',(#53,#61));
#130=MECHANICAL_DESIGN_GEOMETRIC_PRESENTATION_REPRESENTATION('',(#110),#90);
ENDSEC;END-ISO-10303-21;";
fn ids(graph: &Graph<'_>, nodes: &[usize]) -> Vec<u64> {
let mut ids: Vec<u64> = nodes.iter().map(|&n| graph.instance(n).id).collect();
ids.sort_unstable();
ids
}
fn graph() -> Graph<'static> {
Graph::new(parse(SAMPLE.as_bytes()).unwrap()).unwrap()
}
#[test]
fn a_part_takes_its_shape_style_and_filtered_aggregates_but_not_its_parent() {
let graph = graph();
let part = graph.node(30).unwrap();
let extraction = extract(&graph, &[part]);
assert_eq!(
ids(&graph, extraction.nodes()),
[
1, 2, 3, 4, 30, 31, 32, 40, 52, 53, 54, 60, 61, 72, 82, 90, 110, 111, 120, 130
]
);
assert_eq!(ids(&graph, extraction.pruned()), [40, 120, 130]);
for parent_side in [10, 11, 100, 102, 104] {
assert!(
!extraction.contains(graph.node(parent_side).unwrap()),
"#{parent_side}"
);
}
}
#[test]
fn an_assembly_takes_its_usages_placements_and_components() {
let graph = graph();
let assembly = graph.node(10).unwrap();
let extraction = extract(&graph, &[assembly]);
let everything: Vec<u64> = graph.exchange().instances().iter().map(|i| i.id).collect();
let mut everything = everything;
everything.sort_unstable();
assert_eq!(ids(&graph, extraction.nodes()), everything);
let left = orphans(&graph, &[extraction]);
assert!(left.is_empty(), "{left:?}");
}
#[test]
fn excluded_nodes_and_what_only_they_bring_are_left_out() {
let graph = graph();
let part = graph.node(30).unwrap();
let solid = graph.node(53).unwrap();
let extraction = extract_excluding(&graph, &[part], &[solid]);
for gone in [53, 54, 110, 111] {
assert!(!extraction.contains(graph.node(gone).unwrap()), "#{gone}");
}
assert_eq!(
ids(&graph, extraction.nodes()),
[1, 2, 3, 4, 30, 31, 32, 40, 52, 60, 61, 72, 82, 90, 120]
);
assert_eq!(ids(&graph, extraction.pruned()), [40, 52, 120]);
assert_eq!(
extract_excluding(&graph, &[part], &[]),
extract(&graph, &[part])
);
}
#[test]
fn shared_aggregates_are_not_followed_through_their_list() {
let graph = graph();
let extraction = extract(&graph, &[graph.node(30).unwrap()]);
assert!(extraction.contains(graph.node(40).unwrap()));
assert!(!extraction.contains(graph.node(11).unwrap()));
}
#[test]
fn saved_views_and_addresses_go_with_their_product() {
let src = "ISO-10303-21;HEADER;FILE_SCHEMA(('AP214'));ENDSEC;DATA;
#1=APPLICATION_CONTEXT('design');
#3=PRODUCT_CONTEXT('',#1,'mechanical');
#4=PRODUCT_DEFINITION_CONTEXT('part definition',#1,'design');
#31=PRODUCT('C','bolt','',(#3));
#32=PRODUCT_DEFINITION_FORMATION('1','',#31);
#30=PRODUCT_DEFINITION('c','',#32,#4);
#90=GEOMETRIC_REPRESENTATION_CONTEXT(2);
#200=APPLIED_PRESENTED_ITEM((#30));
#201=PRESENTATION_SET();
#202=PRESENTED_ITEM_REPRESENTATION(#201,#200);
#203=PRESENTATION_AREA('',(#205),#90);
#204=AREA_IN_SET(#203,#201);
#205=PLANAR_BOX('',1.,1.,#206);
#206=AXIS2_PLACEMENT_2D('',#207,$);
#207=CARTESIAN_POINT('',(0.,0.));
#300=PERSON('p','Smith',$,$,$,$);
#301=PERSONAL_ADDRESS($,$,$,$,$,$,$,'US',$,$,$,$,(#300),$);
#302=ORGANIZATION('o','Org',$);
#303=PERSON_AND_ORGANIZATION(#300,#302);
#304=PERSON_AND_ORGANIZATION_ROLE('creator');
#305=APPLIED_PERSON_AND_ORGANIZATION_ASSIGNMENT(#303,#304,(#30));
#400=COLOUR_RGB('',0.,0.,1.);
ENDSEC;END-ISO-10303-21;";
let graph = Graph::new(parse(src.as_bytes()).unwrap()).unwrap();
let extraction = extract(&graph, &[graph.node(30).unwrap()]);
assert_eq!(
ids(&graph, extraction.nodes()),
[
1, 3, 4, 30, 31, 32, 90, 200, 201, 202, 203, 204, 205, 206, 207, 300, 301, 302,
303, 304, 305
]
);
assert_eq!(ids(&graph, extraction.pruned()), [200, 305]);
assert_eq!(ids(&graph, &orphans(&graph, &[extraction])), [400]);
}
#[test]
fn a_draughting_model_brings_views_and_notes_but_not_other_products_pmi() {
let src = "ISO-10303-21;HEADER;FILE_SCHEMA(('AP242'));ENDSEC;DATA;
#1=APPLICATION_CONTEXT('design');
#3=PRODUCT_CONTEXT('',#1,'mechanical');
#4=PRODUCT_DEFINITION_CONTEXT('part definition',#1,'design');
#31=PRODUCT('C','bolt','',(#3));
#32=PRODUCT_DEFINITION_FORMATION('1','',#31);
#30=PRODUCT_DEFINITION('c','',#32,#4);
#34=PRODUCT('D','nut','',(#3));
#35=PRODUCT_DEFINITION_FORMATION('1','',#34);
#33=PRODUCT_DEFINITION('d','',#35,#4);
#52=SHAPE_REPRESENTATION('c',(#60),#90);
#60=AXIS2_PLACEMENT_3D('',#61,$,$);
#61=CARTESIAN_POINT('',(0.,0.,0.));
#72=PRODUCT_DEFINITION_SHAPE('','',#30);
#73=PRODUCT_DEFINITION_SHAPE('','',#33);
#82=SHAPE_DEFINITION_REPRESENTATION(#72,#52);
#90=GEOMETRIC_REPRESENTATION_CONTEXT(3);
#400=SHAPE_ASPECT('face','',#72,.F.);
#401=DRAUGHTING_MODEL_ITEM_ASSOCIATION('a','',#400,#500,#531);
#402=SHAPE_ASPECT('face','',#73,.F.);
#403=DRAUGHTING_MODEL_ITEM_ASSOCIATION('b','',#402,#500,#541);
#500=DRAUGHTING_MODEL('MBD',(#501,#510,#520,#530,#540),#90);
#501=CAMERA_MODEL_D3('view',#60,#502);
#502=VIEW_VOLUME(.PARALLEL.,#61,1.,0.,.F.,0.,.F.,.T.,#503);
#503=PLANAR_BOX('',1.,1.,#60);
#510=MAPPED_ITEM('',#511,#60);
#511=REPRESENTATION_MAP(#60,#52);
#520=ANNOTATION_PLANE('notes',(),#521,(#522));
#521=PLANE('',#60);
#522=ANNOTATION_OCCURRENCE('note',(),#523);
#523=GEOMETRIC_CURVE_SET('',(#61));
#530=ANNOTATION_PLANE('pmi c',(),#521,(#531));
#531=DRAUGHTING_CALLOUT('c',(#532));
#532=ANNOTATION_OCCURRENCE('dim c',(),#523);
#540=ANNOTATION_PLANE('pmi d',(),#521,(#541));
#541=DRAUGHTING_CALLOUT('d',(#542));
#542=ANNOTATION_OCCURRENCE('dim d',(),#543);
#543=GEOMETRIC_CURVE_SET('',(#61));
ENDSEC;END-ISO-10303-21;";
let graph = Graph::new(parse(src.as_bytes()).unwrap()).unwrap();
let c = extract(&graph, &[graph.node(30).unwrap()]);
assert_eq!(
ids(&graph, c.nodes()),
[
1, 3, 4, 30, 31, 32, 52, 60, 61, 72, 82, 90, 400, 401, 500, 501, 502, 503, 510,
511, 520, 521, 522, 523, 530, 531, 532
]
);
assert_eq!(ids(&graph, c.pruned()), [500]);
let d = extract(&graph, &[graph.node(33).unwrap()]);
for taken in [402, 403, 540, 541, 542, 543, 520, 501] {
assert!(d.contains(graph.node(taken).unwrap()), "#{taken}");
}
assert!(!d.contains(graph.node(530).unwrap()));
}
#[test]
fn orphans_are_what_no_extraction_takes() {
let graph = graph();
let part = extract(&graph, &[graph.node(30).unwrap()]);
let orphaned = orphans(&graph, &[part]);
assert_eq!(
ids(&graph, &orphaned),
[10, 11, 12, 50, 70, 80, 100, 101, 102, 103, 104]
);
assert_eq!(
ids(&graph, &unreachable(&graph, &orphaned)),
[10, 12, 50, 70, 80, 100, 101, 102, 103, 104]
);
}
#[test]
fn rules_are_well_formed() {
for rule in RULES {
assert!(!rule.entities.is_empty(), "{rule:?}");
assert!(
rule.entities
.iter()
.all(|e| e.chars().all(|c| c.is_ascii_uppercase() || c == '_'))
);
assert!(
rule.attribute
.chars()
.all(|c| c.is_ascii_lowercase() || c == '_' || c.is_ascii_digit())
);
}
}
}