ifc_resource/resource/
type.rs1use ifc_model::EntityId;
7
8use crate::error::{ResourceError, ResourceResult};
9use crate::view::Record;
10
11#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15#[non_exhaustive]
16pub enum ResourceTypeKind {
17 Labor,
19 Equipment,
21 Crew,
23 Material,
25 Product,
27 Subcontract,
29}
30
31impl ResourceTypeKind {
32 fn from_type(type_name: &str) -> Option<Self> {
33 if type_name.eq_ignore_ascii_case("IfcLaborResourceType") {
34 Some(Self::Labor)
35 } else if type_name.eq_ignore_ascii_case("IfcConstructionEquipmentResourceType") {
36 Some(Self::Equipment)
37 } else if type_name.eq_ignore_ascii_case("IfcCrewResourceType") {
38 Some(Self::Crew)
39 } else if type_name.eq_ignore_ascii_case("IfcConstructionMaterialResourceType") {
40 Some(Self::Material)
41 } else if type_name.eq_ignore_ascii_case("IfcConstructionProductResourceType") {
42 Some(Self::Product)
43 } else if type_name.eq_ignore_ascii_case("IfcSubContractResourceType") {
44 Some(Self::Subcontract)
45 } else {
46 None
47 }
48 }
49}
50
51#[derive(Debug, Clone, Copy)]
52pub struct ConstructionResourceType<'m, 's> {
55 record: Record<'m, 's>,
56 kind: ResourceTypeKind,
57}
58
59impl<'m, 's> ConstructionResourceType<'m, 's> {
60 pub(crate) fn from_record(record: Record<'m, 's>) -> ResourceResult<Self> {
61 let kind = ResourceTypeKind::from_type(&record.entity.type_name).ok_or_else(|| {
62 ResourceError::WrongType {
63 id: record.id,
64 expected: "concrete IfcConstructionResourceType occurrence",
65 actual: record.entity.type_name.to_string(),
66 }
67 })?;
68 Ok(Self { record, kind })
69 }
70
71 #[must_use]
73 pub fn id(&self) -> EntityId {
74 self.record.id
75 }
76
77 #[must_use]
79 pub fn kind(&self) -> ResourceTypeKind {
80 self.kind
81 }
82
83 pub fn name(&self) -> ResourceResult<&'m str> {
85 self.record.required_text("Name")
86 }
87
88 pub fn identification(&self) -> ResourceResult<Option<&'m str>> {
90 self.record.optional_text("Identification")
91 }
92
93 pub fn long_description(&self) -> ResourceResult<Option<&'m str>> {
95 self.record.optional_text("LongDescription")
96 }
97
98 pub fn resource_type(&self) -> ResourceResult<Option<&'m str>> {
100 self.record.optional_text("ResourceType")
101 }
102
103 pub fn predefined_type(&self) -> ResourceResult<Option<&'m str>> {
107 let value = self.record.optional_enum("PredefinedType")?;
108 if value.is_some_and(|value| value.eq_ignore_ascii_case("USERDEFINED"))
109 && self
110 .record
111 .optional_text("ResourceType")?
112 .is_none_or(|value| value.trim().is_empty())
113 {
114 return Err(ResourceError::SemanticViolation {
115 entity: Some(self.record.id),
116 rule: "CorrectPredefinedType requires ResourceType for USERDEFINED",
117 });
118 }
119 Ok(value)
120 }
121
122 pub fn base_costs(&self) -> ResourceResult<Vec<EntityId>> {
124 self.record
125 .refs("BaseCosts", "IfcAppliedValue", 1, true, false)
126 }
127
128 pub fn base_quantity(&self) -> ResourceResult<Option<EntityId>> {
131 self.record
132 .optional_ref("BaseQuantity", "IfcPhysicalQuantity")
133 }
134}
135
136impl<'m, 's> crate::view::ResourceView<'m, 's> {
137 pub fn resource_type(&self, id: EntityId) -> ResourceResult<ConstructionResourceType<'m, 's>> {
139 ConstructionResourceType::from_record(self.record(id, "IfcConstructionResourceType")?)
140 }
141
142 pub fn assigned_resource_type(&self, occurrence: EntityId) -> ResourceResult<Option<EntityId>> {
155 self.require_entity("IfcConstructionResourceType")?;
156 self.resource(occurrence)?;
157 let mut found = None;
158 for relation in self.ids_of_ancestor("IfcRelDefinesByType") {
159 let record = self.record(relation, "IfcRelDefinesByType")?;
160 let related = record.refs("RelatedObjects", "IfcObject", 1, false, true)?;
161 if !related.contains(&occurrence) {
162 continue;
163 }
164 let relating_type =
165 record.required_ref("RelatingType", "IfcConstructionResourceType")?;
166 if let Some(existing) = found.replace(relating_type) {
167 if existing != relating_type {
168 return Err(ResourceError::SemanticViolation {
169 entity: Some(occurrence),
170 rule: "IfcTypeObject.Types permits at most one type assignment",
171 });
172 }
173 }
174 }
175 Ok(found)
176 }
177}