Struct OcelLog 

pub struct OcelLog { /* private fields */ }

A complete object-centric event log: objects, events, E2O & O2O links, and object changes.

This is the OCEL canon as one value. OcelLog::validate checks structural integrity (no dangling links, no duplicate ids, no empty types); it does not mine anything.

Structure-only: an admitted OcelLog is a substrate for object-centric discovery and conformance, which graduate to wasm4pm.

Implementations

impl OcelLog

pub fn new( objects: impl IntoIterator<Item = OcelObject>, events: impl IntoIterator<Item = OcelEvent>, e2o: impl IntoIterator<Item = EventObjectLink>, o2o: impl IntoIterator<Item = ObjectObjectLink>, changes: impl IntoIterator<Item = ObjectChange>, ) -> Self

Construct an OCEL log from its five constituent tables.

use wasm4pm_compat::ocel::{OcelObject, OcelEvent, EventObjectLink, OcelLog};
let log = OcelLog::new(
    [OcelObject::new("ord-1", "order")],
    [OcelEvent::new("e1", "place_order")],
    [EventObjectLink::new("e1", "ord-1")],
    [],
    [],
);
assert!(log.validate().is_ok());

pub fn objects(&self) -> &[OcelObject]

The declared objects.

pub fn events(&self) -> &[OcelEvent]

The declared events.

pub fn event_object_links(&self) -> &[EventObjectLink]

The event-to-object (E2O) links.

pub fn object_object_links(&self) -> &[ObjectObjectLink]

The object-to-object (O2O) links.

pub fn object_changes(&self) -> &[ObjectChange]

The recorded object changes.

pub fn validate(&self) -> Result<(), OcelRefusal>

Structurally validate the OCEL log.

This is a structure check, not mining. It verifies, in order:

• there is at least one object (OcelRefusal::MissingObject) and one event (OcelRefusal::MissingEvent);
• object and event ids are each unique (OcelRefusal::DuplicateObjectId, OcelRefusal::DuplicateEventId);
• every object names a non-empty type (OcelRefusal::MissingObjectType);
• at least one E2O link exists (OcelRefusal::EmptyEventObjectLinks);
• every E2O link references a declared event and object (OcelRefusal::DanglingEventObjectLink);
• every O2O link references declared objects (OcelRefusal::DanglingObjectObjectLink);
• every object change references a declared object and names an attribute (OcelRefusal::InvalidObjectChange).

use wasm4pm_compat::ocel::{OcelObject, OcelEvent, EventObjectLink, OcelLog, OcelRefusal};
// Dangling E2O link: references object "ghost" that was never declared.
let log = OcelLog::new(
    [OcelObject::new("ord-1", "order")],
    [OcelEvent::new("e1", "a")],
    [EventObjectLink::new("e1", "ghost")],
    [],
    [],
);
assert_eq!(log.validate(), Err(OcelRefusal::DanglingEventObjectLink));

Trait Implementations

impl Clone for OcelLog

fn clone(&self) -> OcelLog

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OcelLog

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

Formats the value using the given formatter.

impl Default for OcelLog

fn default() -> OcelLog

Returns the “default value” for a type.

impl<'a> IntoIterator for &'a OcelLog

fn into_iter(self) -> Self::IntoIter

Iterate over the OcelEvents of this log.

The idiomatic OCEL iteration surface. Objects, E2O links, and O2O links are accessible via OcelLog::objects, OcelLog::event_object_links, and OcelLog::object_object_links respectively.

use wasm4pm_compat::ocel::{OcelLog, OcelObject, OcelEvent, EventObjectLink};
let log = OcelLog::new(
    [OcelObject::new("o1", "order")],
    [OcelEvent::new("e1", "place"), OcelEvent::new("e2", "ship")],
    [EventObjectLink::new("e1", "o1"), EventObjectLink::new("e2", "o1")],
    [],
    [],
);
let activities: Vec<&str> = (&log).into_iter().map(|e| e.activity()).collect();
assert_eq!(activities, ["place", "ship"]);

type Item = &'a OcelEvent

The type of the elements being iterated over.

type IntoIter = Iter<'a, OcelEvent>

Which kind of iterator are we turning this into?

impl IntoIterator for OcelLog

fn into_iter(self) -> Self::IntoIter

Consume the log and iterate over its OcelEvents by value.

use wasm4pm_compat::ocel::{OcelLog, OcelObject, OcelEvent, EventObjectLink};
let log = OcelLog::new(
    [OcelObject::new("o1", "order")],
    [OcelEvent::new("e1", "place")],
    [EventObjectLink::new("e1", "o1")],
    [],
    [],
);
let v: Vec<OcelEvent> = log.into_iter().collect();
assert_eq!(v.len(), 1);

type Item = OcelEvent

The type of the elements being iterated over.

type IntoIter = IntoIter<OcelEvent>

Which kind of iterator are we turning this into?

impl PartialEq for OcelLog

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for OcelLog