Struct InstanceId 

pub struct InstanceId(/* private fields */);

An arbitrary-precision instance identifier as written by #42.

The Part 21 grammar does not impose a machine-integer bound, so the decimal digits are retained lexically.

Up to 22 digits – every id a u64 can hold – are stored in the value itself; only longer ones allocate. A large file holds several ids per record, so this removes millions of allocations per parse. Comparison, hashing, ordering and Debug all go through Self::as_str, so the representation is invisible.

Implementations

impl InstanceId

pub fn new(value: &str) -> Option<Self>

Creates an identifier from non-empty ASCII decimal digits.

pub fn as_str(&self) -> &str

Returns the decimal digits without the leading #.

Examples found in repository

examples/recovery_property.rs (line 64)

fn main() {
    let base = "ISO-10303-21;\nHEADER;\nFILE_DESCRIPTION((''),'2;1');\n\
                FILE_NAME('n','t',(''),(''),'p','o','a');\nFILE_SCHEMA(('IFC4'));\nENDSEC;\nDATA;\n\
                #1= IFCPERSON($,$,'a;b',$,$,$,$,$);\n\
                #2= IFCPIXELTEXTURE(1,1,8,(\"00AA;BB\"));\n\
                #3= IFCORGANIZATION($,'o''x',$,$,$); /* c;c */\n\
                #4= IFCDOOR('real');\nENDSEC;\nEND-ISO-10303-21;\n";

    let mut state = 0x5eed_1234_u64;
    let mut recovered = 0usize;
    let mut fabricated = 0usize;
    let mut span_faults = 0usize;

    for _ in 0..20_000 {
        let mut bytes = base.as_bytes().to_vec();
        // Corrupt 1-3 bytes anywhere in the DATA region.
        let edits = 1 + (lcg(&mut state) % 3) as usize;
        for _ in 0..edits {
            let at = 150 + (lcg(&mut state) as usize % (bytes.len() - 150));
            match lcg(&mut state) % 3 {
                0 => bytes[at] = b'@',
                1 => {
                    bytes.remove(at);
                }
                _ => bytes[at] = (lcg(&mut state) % 128) as u8,
            }
        }

        let Ok(outcome) = parse_with(
            &bytes,
            ParseOptions::default().on_malformed_record(OnMalformed::Skip),
        ) else {
            continue;
        };
        recovered += 1;

        for diagnostic in &outcome.diagnostics {
            let span = diagnostic.span();
            if span.start > span.end || span.end > bytes.len() {
                span_faults += 1;
            }
        }

        // Every kept record must appear verbatim in the surviving source: its
        // `#id=` must exist outside any diagnostic-covered range.
        for record in &outcome.exchange.data.records {
            let needle = format!("#{}=", record.id.as_str());
            let found = String::from_utf8_lossy(&bytes).contains(&needle)
                || String::from_utf8_lossy(&bytes).contains(&format!("#{} =", record.id.as_str()));
            if !found {
                fabricated += 1;
                eprintln!(
                    "FABRICATED {} in:\n{}",
                    needle,
                    String::from_utf8_lossy(&bytes)
                );
            }
        }
    }

    println!("recovered={recovered} fabricated={fabricated} span_faults={span_faults}");
    assert_eq!(fabricated, 0, "recovery invented records");
    assert_eq!(span_faults, 0, "diagnostic span out of bounds");
    println!("PROPERTY PROBE OK");
}

Trait Implementations

impl Clone for InstanceId

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InstanceId

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

Formats the value using the given formatter.

impl Display for InstanceId

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

Formats the value using the given formatter.

impl Eq for InstanceId

impl From<u64> for InstanceId

fn from(value: u64) -> Self

Converts to this type from the input type.

impl Hash for InstanceId

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

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 Ord for InstanceId

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for InstanceId

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for InstanceId

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.