ifc-model 0.3.0

The IFC entity graph: storage and structural queries, free of domain semantics and serialization.
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

//! `ifc-model` — the IFC entity graph, free of both domain semantics and
//! serialization.
//!
//! # The two separations this crate exists to enforce
//!
//! **1. Model vs. domain meaning.** [`Model`] stores entities. It does not know
//! what a cost item, a task, a wall, or a material *is*. Domain crates
//! (`ifc-cost`, `ifc-schedule`, `ifc-properties`, ...) borrow a `&Model` and
//! interpret it. Consequences:
//!
//! - a thin application compiles only the domains it uses;
//! - **data we do not understand still round-trips perfectly**, because it is
//!   stored structurally rather than as a domain struct. A file full of cost
//!   entities parses and re-exports intact in a build with no cost crate at
//!   all. This is verified by `tests/roundtrip.rs`.
//!
//! **2. Model vs. serialization.** [`Model`] is not "the STEP model". STEP,
//! ifcXML and a prospective IFC-JSON are encodings of the same graph, and each
//! is a separate crate implementing [`codec::Codec`]. Nothing here depends on
//! any of them — which is why format conversion is just "read with one, write
//! with another".
//!
//! ```text
//!   ifc-step ──┐                        ┌── ifc-cost
//!   ifc-xml  ──┼── Codec ──> Model <────┼── ifc-schedule      (views)
//!   ifc-json ──┘   (this crate)         └── ifc-properties
//! ```
//!
//! # Modules
//!
//! | Module | Role |
//! | --- | --- |
//! | [`value`] | The serialization-independent value model |
//! | [`entity`] | Type name plus positional attributes |
//! | [`model`] | Storage, ordering, type index, reference integrity |
//! | [`header`] | File metadata and the declared schema token |
//! | [`codec`] | The read/write trait every serialization implements |
//! | [`guid`] | IFC's base-64 GlobalId encoding |
//! | [`diagnostic`] | Non-fatal findings a codec attaches after a recovered read |
//! | `index` | Derived indices: inverse references |
//! | [`mutation`] | Transactional authoring: staged edits, preflight, commit |
//! | `relation` | Structural relationship traversal (no domain meaning) |
//! | `spatial` | The spatial containment tree |
//! | `traverse` | Graph walks over references |
//! | [`error`] | Failure modes |

#[cfg(feature = "authored-dump")]
pub mod authored_dump;
pub mod codec;
pub mod diagnostic;
pub mod entity;
pub mod error;
pub mod guid;
pub mod header;
pub mod index;
mod lazy;
pub mod model;
pub mod mutation;
mod provenance;
mod relation;
mod spatial;
pub mod traverse;
pub mod value;

pub use codec::Codec;
pub use diagnostic::{Diagnostic, Severity};
pub use entity::Entity;
pub use error::{ModelError, ModelResult};
pub use header::Header;
pub use index::{Referrer, ReverseIndex};
pub use lazy::EntitySource;
pub use model::Model;
pub use mutation::{Applied, Conflict, Edit, Transaction};
pub use traverse::{breadth_first, depth_first, find_cycle, Budget, Stop, Walk};
pub use value::{EntityId, Value};