cadmpeg-ir 0.6.2

CAD data model, validation, diffing, and codec API for cadmpeg.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// SPDX-License-Identifier: Apache-2.0
//! Presentation state and layer validation.

use super::record_finding;
use crate::document::CadIr;
use crate::index::identities::{BorrowedIdentities, IdentitySet};
use crate::index::{ModelIndex, StandardIndex};
use crate::presentation::PresentationItem;
use crate::report::{
    check::{Check, Finding},
    Severity,
};

pub(super) fn check_presentation(ids: &ModelIndex<'_>, findings: &mut Vec<Finding>) {
    let ir: &CadIr = ids.ir();
    let all_ids: &dyn IdentitySet = ids;
    if ir.model.presentation_documents.len() > 1 {
        record_finding(
            findings,
            Check::ReferentialIntegrity,
            Severity::Error,
            None,
            format_args!("{}", "multiple document presentation records"),
        );
    }
    for document in &ir.model.presentation_documents {
        let native_valid = match &document.native_ref {
            Some(native) => all_ids.contains(native),
            None => true,
        };
        let mut assets_valid = true;
        'states: for state in document.states() {
            for asset in &state.assets {
                if !all_ids.contains(asset) {
                    assets_valid = false;
                    break 'states;
                }
            }
        }
        if !native_valid || !assets_valid {
            record_finding(
                findings,
                Check::ReferentialIntegrity,
                Severity::Error,
                Some(document.id.as_str()),
                format_args!("{}", "invalid document presentation state"),
            );
        }
    }

    let mut orders = std::collections::BTreeSet::new();
    for view in &ir.model.view_presentations {
        let mut references_valid = match &view.object {
            Some(object) => all_ids.contains(object),
            None => true,
        };
        if references_valid {
            if let Some(native) = &view.native_ref {
                references_valid = all_ids.contains(native);
            }
        }
        if !references_valid || !orders.insert(view.order) {
            record_finding(
                findings,
                Check::ReferentialIntegrity,
                Severity::Error,
                Some(view.id.as_str()),
                format_args!("{}", "invalid view presentation reference, order, or size"),
            );
        }
    }

    if ir.model.presentation_layers.is_empty() {
        return;
    }
    let products = BorrowedIdentities::build(|add| {
        for item in &ir.model.product_definitions {
            add(item.id.as_str(), ());
        }
    });
    let occurrences = BorrowedIdentities::build(|add| {
        for item in &ir.model.occurrences {
            add(item.id.as_str(), ());
        }
    });
    let pmi = BorrowedIdentities::build(|add| {
        for item in &ir.model.pmi {
            add(item.id.as_str(), ());
        }
    });
    for layer in &ir.model.presentation_layers {
        for item in &layer.items {
            let resolved = match item {
                PresentationItem::Body { body } => {
                    ids.bodies(body.as_str(), StandardIndex).is_some()
                }
                PresentationItem::Face { face } => {
                    ids.faces(face.as_str(), StandardIndex).is_some()
                }
                PresentationItem::Edge { edge } => {
                    ids.edges(edge.as_str(), StandardIndex).is_some()
                }
                PresentationItem::Vertex { vertex } => {
                    ids.vertices(vertex.as_str(), StandardIndex).is_some()
                }
                PresentationItem::Point { point } => {
                    ids.points(point.as_str(), StandardIndex).is_some()
                }
                PresentationItem::Curve { curve } => {
                    ids.curves(curve.as_str(), StandardIndex).is_some()
                }
                PresentationItem::Surface { surface } => {
                    ids.surfaces(surface.as_str(), StandardIndex).is_some()
                }
                PresentationItem::Product { product } => products.contains(product.as_str()),
                PresentationItem::Occurrence { occurrence } => {
                    occurrences.contains(occurrence.as_str())
                }
                PresentationItem::Pmi { annotation } => pmi.contains(annotation.as_str()),
                PresentationItem::Tessellation { tessellation } => ids
                    .tessellations(tessellation.as_str(), StandardIndex)
                    .is_some(),
                PresentationItem::Source { .. } => true,
            };
            if !resolved {
                record_finding(
                    findings,
                    Check::Presentation,
                    crate::report::Severity::Error,
                    Some(layer.id.as_str()),
                    format_args!("{}", "unresolved presentation-layer item"),
                );
            }
        }
    }
}