cadmpeg-ir 0.6.5

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
137
138
139

// SPDX-License-Identifier: Apache-2.0
//! Rewrite the identities owned by these fields.

use super::{AttributeTarget, AttributeValue, SourceAttribute};

impl crate::schema::rewrite::typed::RewriteIdentities for AttributeTarget {
    fn rewrite_native_value<F: FnMut(&str) -> Result<String, cadmpeg_core::CodecError>>(
        ctx: &cadmpeg_core::decode::DecodeContext<'_>,
        value: &mut serde_json::Value,
        map: &mut crate::schema::rewrite::typed::IdentityMap<'_, F>,
    ) -> Result<(), cadmpeg_core::CodecError> {
        let _depth = ctx.enter_nested("walk native attribute target")?;

        let kind = value.get("kind").and_then(serde_json::Value::as_str);

        match kind {
            Some("body") => crate::schema::rewrite::typed::native_fields::rewrite_field(
                ctx,
                value,
                "id",
                map,
                |owner: &Self| match owner {
                    Self::Body(id) => Some(id),
                    _ => None,
                },
            ),
            Some("face") => crate::schema::rewrite::typed::native_fields::rewrite_field(
                ctx,
                value,
                "id",
                map,
                |owner: &Self| match owner {
                    Self::Face(id) => Some(id),
                    _ => None,
                },
            ),
            Some("shell") => crate::schema::rewrite::typed::native_fields::rewrite_field(
                ctx,
                value,
                "id",
                map,
                |owner: &Self| match owner {
                    Self::Shell(id) => Some(id),
                    _ => None,
                },
            ),
            Some("loop") => crate::schema::rewrite::typed::native_fields::rewrite_field(
                ctx,
                value,
                "id",
                map,
                |owner: &Self| match owner {
                    Self::Loop(id) => Some(id),
                    _ => None,
                },
            ),
            Some("coedge") => crate::schema::rewrite::typed::native_fields::rewrite_field(
                ctx,
                value,
                "id",
                map,
                |owner: &Self| match owner {
                    Self::Coedge(id) => Some(id),
                    _ => None,
                },
            ),
            Some("edge") => crate::schema::rewrite::typed::native_fields::rewrite_field(
                ctx,
                value,
                "id",
                map,
                |owner: &Self| match owner {
                    Self::Edge(id) => Some(id),
                    _ => None,
                },
            ),
            Some("vertex") => crate::schema::rewrite::typed::native_fields::rewrite_field(
                ctx,
                value,
                "id",
                map,
                |owner: &Self| match owner {
                    Self::Vertex(id) => Some(id),
                    _ => None,
                },
            ),
            Some("document") => Ok(()),
            _ => Err(cadmpeg_core::CodecError::malformed(
                "native attribute target has an invalid kind",
            )),
        }
    }
    fn visit_identity_references(
        &self,
        ctx: &cadmpeg_core::decode::DecodeContext<'_>,
        visitor: &mut dyn FnMut(&str) -> Result<(), cadmpeg_core::CodecError>,
    ) -> Result<(), cadmpeg_core::CodecError> {
        let _depth = ctx.enter_nested("walk typed reference fields")?;

        match self {
            Self::Document => Ok(()),
            Self::Body(id) => id.visit_identity_references(ctx, visitor),
            Self::Face(id) => id.visit_identity_references(ctx, visitor),
            Self::Shell(id) => id.visit_identity_references(ctx, visitor),
            Self::Loop(id) => id.visit_identity_references(ctx, visitor),
            Self::Coedge(id) => id.visit_identity_references(ctx, visitor),
            Self::Edge(id) => id.visit_identity_references(ctx, visitor),
            Self::Vertex(id) => id.visit_identity_references(ctx, visitor),
        }
    }
    fn rewrite_identities<F: FnMut(&str) -> Result<String, cadmpeg_core::CodecError>>(
        self,
        ctx: &cadmpeg_core::decode::DecodeContext<'_>,
        map: &mut crate::schema::rewrite::typed::IdentityMap<'_, F>,
    ) -> Result<Self, cadmpeg_core::CodecError> {
        let _depth = ctx.enter_nested("typed rewrite variant")?;

        Ok(match self {
            Self::Document => Self::Document,
            Self::Body(id) => Self::Body(id.rewrite_identities(ctx, map)?),
            Self::Face(id) => Self::Face(id.rewrite_identities(ctx, map)?),
            Self::Shell(id) => Self::Shell(id.rewrite_identities(ctx, map)?),
            Self::Loop(id) => Self::Loop(id.rewrite_identities(ctx, map)?),
            Self::Coedge(id) => Self::Coedge(id.rewrite_identities(ctx, map)?),
            Self::Edge(id) => Self::Edge(id.rewrite_identities(ctx, map)?),
            Self::Vertex(id) => Self::Vertex(id.rewrite_identities(ctx, map)?),
        })
    }
}

rewrite_enum!(AttributeValue, []; {
    Integer(field0),
    Float(field0),
    String(field0),
    Boolean(field0),
    Reference(field0),
    Vector(field0),
});
rewrite_record!(SourceAttribute, []; {id, target, name, values});