ifc-material 0.3.0

Material definitions: layer sets, profile sets, constituents, usage.
Documentation 
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

//! Ordered `IfcMaterialLayerSet` composition and total thickness.
//!
//! IFC2X3 declares `(MaterialLayers, LayerSetName)`; IFC4 and IFC4X3 append
//! `Description`.

use ifc_model::EntityId;

use crate::layer::definition::layer_thickness;
use crate::view::{borrowed_entity, optional_text, required_refs, MaterialView};
use crate::{MaterialError, MaterialResult};

borrowed_entity!(MaterialLayerSet, "IFCMATERIALLAYERSET");

impl<'m> MaterialLayerSet<'m> {
    /// `IfcMaterialLayerSet.MaterialLayers`, in set order. Required and
    /// must be non-empty.
    pub fn layer_ids(self) -> MaterialResult<Vec<EntityId>> {
        required_refs(
            "IFCMATERIALLAYERSET",
            self.id(),
            self.entity(),
            self.slot("MaterialLayers")?,
            "MaterialLayers",
            1,
        )
    }

    /// `IfcMaterialLayerSet.LayerSetName`, if given.
    pub fn name(self) -> MaterialResult<Option<&'m str>> {
        optional_text(
            "IFCMATERIALLAYERSET",
            self.id(),
            self.entity(),
            self.slot("LayerSetName")?,
            "LayerSetName",
        )
    }

    /// `IfcMaterialLayerSet.Description`, if given. `NotInSchema` for
    /// IFC2X3.
    pub fn description(self) -> MaterialResult<Option<&'m str>> {
        optional_text(
            "IFCMATERIALLAYERSET",
            self.id(),
            self.entity(),
            self.slot("Description")?,
            "Description",
        )
    }
}

impl<'m> MaterialView<'m> {
    /// Iterates every `IfcMaterialLayerSet` instance in the model.
    pub fn layer_sets(self) -> impl Iterator<Item = MaterialLayerSet<'m>> + 'm {
        let release = self.release();
        self.model()
            .of_type("IFCMATERIALLAYERSET")
            .map(move |(id, entity)| MaterialLayerSet::from_known(id, entity, release))
    }

    /// Evaluate the normative `IfcMlsTotalThickness` function.
    ///
    /// Each member is read against the set's release: an
    /// `IfcMaterialLayerWithOffsets` member of an IFC2X3 set is
    /// `EntityNotInSchema`, and a zero IFC2X3 thickness is invalid.
    pub fn total_thickness(self, set: MaterialLayerSet<'m>) -> MaterialResult<f64> {
        let mut total = 0.0;
        for layer_id in set.layer_ids()? {
            let layer = self.entity(set.id(), layer_id)?;
            let entity_type = if layer.is_type("IFCMATERIALLAYER") {
                "IFCMATERIALLAYER"
            } else if layer.is_type("IFCMATERIALLAYERWITHOFFSETS") {
                "IFCMATERIALLAYERWITHOFFSETS"
            } else {
                return Err(MaterialError::ReferenceType {
                    source_id: set.id(),
                    target: layer_id,
                    expected: "IFCMATERIALLAYER",
                    actual: layer.type_name.to_string(),
                });
            };
            total += layer_thickness(entity_type, layer_id, layer, set.release())?;
            if !total.is_finite() {
                return Err(MaterialError::InvalidValue {
                    entity: "IFCMATERIALLAYERSET",
                    id: set.id(),
                    attribute: "TotalThickness",
                    value: "finite layer thicknesses overflowed the aggregate".to_owned(),
                });
            }
        }
        Ok(total)
    }
}