Struct LnmpRecord

Source

pub struct LnmpRecord { /* private fields */ }

Expand description

A complete LNMP record (collection of fields)

Implementations§

Source §

impl LnmpRecord

Source

pub fn new() -> Self

Creates a new empty record

Source

pub fn add_field(&mut self, field: LnmpField)

Adds a field to the record

Source

pub fn get_field(&self, fid: FieldId) -> Option<&LnmpField>

Gets a field by field ID (returns the first match if duplicates exist)

Source

pub fn remove_field(&mut self, fid: FieldId)

Removes all fields with the given field ID

Source

pub fn fields(&self) -> &[LnmpField]

Returns a slice of all fields in the record

Source

pub fn into_fields(self) -> Vec<LnmpField>

Consumes the record and returns the fields vector

Source

pub fn sorted_fields(&self) -> Vec<LnmpField>

Returns fields sorted by field ID (stable sort preserves insertion order for duplicates)

Source

pub fn from_sorted_fields(fields: Vec<LnmpField>) -> Self

Creates a record from a vector of fields (typically already sorted)

Source

pub fn from_fields(fields: Vec<LnmpField>) -> Self

Creates a record from fields, automatically sorting by FID

This ensures canonical field ordering regardless of input order. Use this constructor when building records from unsorted field collections.

§Example

use lnmp_core::{LnmpRecord, LnmpField, LnmpValue};

let fields = vec![
    LnmpField { fid: 23, value: LnmpValue::Int(3) },
    LnmpField { fid: 7, value: LnmpValue::Int(1) },
    LnmpField { fid: 12, value: LnmpValue::Int(2) },
];

let record = LnmpRecord::from_fields(fields);

// Fields are automatically sorted by FID
assert_eq!(record.fields()[0].fid, 7);
assert_eq!(record.fields()[1].fid, 12);
assert_eq!(record.fields()[2].fid, 23);

Source

pub fn validate_with_limits( &self, limits: &StructuralLimits, ) -> Result<(), StructuralError>

Validates this record against structural limits (depth, field counts, lengths).

Source

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

Compares two records based on canonical form (field order independent).

This method compares records semantically by comparing their sorted fields. Two records are canonically equal if they have the same fields (same FID and value), regardless of the order in which fields were added.

§Example

use lnmp_core::{LnmpRecord, LnmpField, LnmpValue};

let mut rec1 = LnmpRecord::new();
rec1.add_field(LnmpField { fid: 12, value: LnmpValue::Int(1) });
rec1.add_field(LnmpField { fid: 7, value: LnmpValue::Int(2) });

let mut rec2 = LnmpRecord::new();
rec2.add_field(LnmpField { fid: 7, value: LnmpValue::Int(2) });
rec2.add_field(LnmpField { fid: 12, value: LnmpValue::Int(1) });

// Structural equality: order matters
assert_ne!(rec1, rec2);

// Canonical equality: order doesn't matter
assert!(rec1.canonical_eq(&rec2));

Source

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

Computes a hash based on canonical field ordering.

This method computes a hash using sorted fields, ensuring that the hash is independent of field insertion order. This is useful for using LnmpRecord in HashMap or HashSet with semantic equality.

§Example

use lnmp_core::{LnmpRecord, LnmpField, LnmpValue};
use std::hash::{Hash, Hasher};
use std::collections::hash_map::DefaultHasher;

let mut rec1 = LnmpRecord::new();
rec1.add_field(LnmpField { fid: 12, value: LnmpValue::Int(1) });
rec1.add_field(LnmpField { fid: 7, value: LnmpValue::Int(2) });

let mut rec2 = LnmpRecord::new();
rec2.add_field(LnmpField { fid: 7, value: LnmpValue::Int(2) });
rec2.add_field(LnmpField { fid: 12, value: LnmpValue::Int(1) });

let mut hasher1 = DefaultHasher::new();
rec1.canonical_hash(&mut hasher1);
let hash1 = hasher1.finish();

let mut hasher2 = DefaultHasher::new();
rec2.canonical_hash(&mut hasher2);
let hash2 = hasher2.finish();

// Same canonical hash despite different insertion order
assert_eq!(hash1, hash2);

Source

pub fn validate_field_ordering(&self) -> Result<(), FieldOrderingError>

Validates that fields are in canonical order (sorted by FID).

Returns Ok(()) if fields are sorted, or an error with details about the first out-of-order field.

§Example

use lnmp_core::{LnmpRecord, LnmpField, LnmpValue};

// Sorted record
let record = LnmpRecord::from_fields(vec![
    LnmpField { fid: 7, value: LnmpValue::Int(1) },
    LnmpField { fid: 12, value: LnmpValue::Int(2) },
]);
assert!(record.validate_field_ordering().is_ok());

// Unsorted record
let mut record = LnmpRecord::new();
record.add_field(LnmpField { fid: 12, value: LnmpValue::Int(2) });
record.add_field(LnmpField { fid: 7, value: LnmpValue::Int(1) });
assert!(record.validate_field_ordering().is_err());

Source

pub fn is_canonical_order(&self) -> bool

Returns whether fields are in canonical order (sorted by FID).

This is a convenience method that returns a boolean instead of a Result.

§Example

use lnmp_core::{RecordBuilder, LnmpField, LnmpValue};

let record = RecordBuilder::new()
    .add_field(LnmpField { fid: 7, value: LnmpValue::Int(1) })
    .build();

assert!(record.is_canonical_order());

Source

pub fn count_ordering_violations(&self) -> usize

Returns the number of out-of-order field pairs.

A count of 0 means the record is in canonical order. Higher counts indicate more disorder.

§Example

use lnmp_core::{LnmpRecord, LnmpField, LnmpValue};

let mut record = LnmpRecord::new();
record.add_field(LnmpField { fid: 23, value: LnmpValue::Int(3) });
record.add_field(LnmpField { fid: 7, value: LnmpValue::Int(1) });
record.add_field(LnmpField { fid: 12, value: LnmpValue::Int(2) });

// 23 > 7 (disorder), 7 < 12 (ok), so 1 disorder
assert_eq!(record.count_ordering_violations(), 1);