Struct ParseOptions 

#[non_exhaustive]
pub struct ParseOptions {
    pub on_malformed_record: OnMalformed,
    pub check_references: bool,
    pub accept_real_without_point: bool,
}

Malformed-record policy, re-exported so consumers need not depend on openbim-step directly to configure a reader. Parse behavior toggles.

Constructed with ParseOptions::default (strict) and adjusted through ParseOptions::on_malformed_record, so later options cannot break existing call sites.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

on_malformed_record: OnMalformed

Policy for unparsable data records.

check_references: bool

Whether to report duplicate instance ids and references to ids that are never defined. Off by default: strict parsing means syntax only.

accept_real_without_point: bool

Whether a data-section real written without its decimal point (1E-05) is read as a real. Off by default; see Self::accept_real_without_point.

Implementations

impl ParseOptions

pub const fn strict() -> ParseOptions

Strict options: any malformed record aborts the parse.

pub const fn lenient() -> ParseOptions

Options that skip and report malformed data records, and read reals written without their decimal point (see Self::accept_real_without_point).

pub const fn on_malformed_record(self, policy: OnMalformed) -> ParseOptions

Sets the malformed-record policy.

pub const fn check_references(self, enabled: bool) -> ParseOptions

Enables or disables reference-integrity diagnostics.

When enabled, every data record whose instance id was already defined yields a DiagnosticKind::DuplicateId, and every record referencing an id that no record in the DATA section defines yields one DiagnosticKind::DanglingReference per distinct missing id. Forward references are legal (ISO 10303-21:2016 §11.2) and are only reported if the target is still undefined at ENDSEC. Ids compare numerically, so #07 and #7 name the same instance.

Nothing is dropped or rewritten, so these diagnostics never make an outcome lossy. The check keeps one entry per defined id, so memory is linear in the number of records, including for crate::parse_events_with.

pub const fn accept_real_without_point(self, enabled: bool) -> ParseOptions

Enables or disables reading reals written without a decimal point.

ISO 10303-21 writes a real as [sign] digits "." [digits] [exponent], but some exporters omit the point before an exponent (1E-05, -2E3, 3e+2), including buildingSMART’s own IFC4.x alignment test files. Strict parsing refuses such a number with an error for which StepError::is_real_without_point holds. When enabled, a data record keeps it as the real it means, with the point inserted (1.E-05), and yields one DiagnosticKind::RealWithoutPoint over the number’s bytes. The stored value carries the point, so writing the model back produces valid Part 21.

Only complete numbers are read: 1E, 1E- and 1EE2 stay errors, as do numbers without leading digits such as .5E2. Text inside strings is never touched. The header section stays strict, as it does for every other recovery.

Trait Implementations

impl Clone for ParseOptions

fn clone(&self) -> ParseOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ParseOptions

impl Debug for ParseOptions

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

Formats the value using the given formatter.

impl Default for ParseOptions

fn default() -> ParseOptions

Returns the “default value” for a type.

impl Eq for ParseOptions

impl Hash for ParseOptions

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ParseOptions

fn eq(&self, other: &ParseOptions) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ParseOptions