Struct DataRecord 

pub struct DataRecord<S = String> {
    pub id: InstanceId,
    pub records: Vec<Record<S>>,
}

A simple or complex #id=...; instance in DATA;.

Fields

id: InstanceId

Source instance id.

records: Vec<Record<S>>

One record for a simple instance, multiple for a complex instance.

Implementations

impl<S> DataRecord<S>

pub fn simple(id: InstanceId, name: S, parameters: Vec<Parameter<S>>) -> Self

Creates a simple instance containing one named record.

pub fn as_simple(&self) -> Option<&Record<S>>

Returns the sole record of a simple instance.

Examples found in repository

examples/recovery_probe.rs (line 34)

fn main() {
    let path = std::env::args().nth(1).expect("path");
    let bytes = std::fs::read(&path).expect("read");

    match openbim_step::parse(&bytes) {
        Ok(_) => println!("strict: OK (unexpected)"),
        Err(error) => println!("strict: {error}"),
    }

    let outcome = openbim_step::parse_with(&bytes, openbim_step::ParseOptions::lenient())
        .expect("lenient parse");
    println!(
        "lenient: {} records, {} diagnostics",
        outcome.exchange.data.records.len(),
        outcome.diagnostics.len()
    );
    for diagnostic in &outcome.diagnostics {
        println!("  {diagnostic}");
        let span = diagnostic.span();
        println!(
            "  dropped bytes: {:?}",
            String::from_utf8_lossy(&bytes[span.start..span.end])
        );
    }
    let boundaries = outcome
        .exchange
        .data
        .records
        .iter()
        .filter(|record| {
            record
                .as_simple()
                .is_some_and(|simple| simple.name == "IFCRELSPACEBOUNDARY")
        })
        .count();
    println!("IfcRelSpaceBoundary: {boundaries}");
    println!("schema: {:?}", outcome.exchange.header.standard().schema);
}

Trait Implementations

impl<S: Clone> Clone for DataRecord<S>

fn clone(&self) -> DataRecord<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug> Debug for DataRecord<S>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S: PartialEq> PartialEq for DataRecord<S>

fn eq(&self, other: &DataRecord<S>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<S: PartialEq> StructuralPartialEq for DataRecord<S>