Struct EventLog 

pub struct EventLog { /* private fields */ }

A collection of Traces — the classical case-centric event log.

An EventLog is the substrate of discovery and conformance. This crate only represents and structurally validates it; the actual mining graduates to wasm4pm.

Structure-only: EventLog::validate runs each trace’s structural checks but performs no analysis.

Implementations

impl EventLog

pub fn from_traces(traces: impl IntoIterator<Item = Trace>) -> Self

Construct a log from an iterator of traces.

use wasm4pm_compat::eventlog::{Event, Trace, EventLog};
let log = EventLog::from_traces([Trace::new("c", [Event::new("a")])]);
assert_eq!(log.trace_count(), 1);

pub fn traces(&self) -> &[Trace]

The traces of this log.

use wasm4pm_compat::eventlog::EventLog;
assert!(EventLog::default().traces().is_empty());

pub fn trace_count(&self) -> usize

The number of traces in this log.

use wasm4pm_compat::eventlog::{Event, Trace, EventLog};
let log = EventLog::from_traces([Trace::new("c", [Event::new("a")])]);
assert_eq!(log.trace_count(), 1);

pub fn event_count(&self) -> usize

The total number of events across all traces.

use wasm4pm_compat::eventlog::{Event, Trace, EventLog};
let log = EventLog::from_traces([
    Trace::new("c1", [Event::new("a"), Event::new("b")]),
    Trace::new("c2", [Event::new("a")]),
]);
assert_eq!(log.event_count(), 3);

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

Validate every trace structurally, returning the first refusal.

This is a shape check across the whole log; it does not discover or score anything. For mining, graduate to wasm4pm.

use wasm4pm_compat::eventlog::{Trace, EventLog, EventLogRefusal};
let bad = EventLog::from_traces([Trace::from_events([])]);
assert_eq!(bad.validate(), Err(EventLogRefusal::EmptyTrace));

Trait Implementations

impl Clone for EventLog

fn clone(&self) -> EventLog

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventLog

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

Formats the value using the given formatter.

impl Default for EventLog

fn default() -> EventLog

Returns the “default value” for a type.

impl Eq for EventLog

impl<'a> IntoIterator for &'a EventLog

fn into_iter(self) -> Self::IntoIter

Iterate over the Traces of this log.

This makes EventLog idiomatic to use in for loops and iterator chains without a separate .traces() call:

use wasm4pm_compat::eventlog::{Event, Trace, EventLog};
let log = EventLog::from_traces([
    Trace::new("c1", [Event::new("a")]),
    Trace::new("c2", [Event::new("b")]),
]);
let cases: Vec<&str> = (&log).into_iter().map(|t| t.case_id()).collect();
assert_eq!(cases, ["c1", "c2"]);

type Item = &'a Trace

The type of the elements being iterated over.

type IntoIter = Iter<'a, Trace>

Which kind of iterator are we turning this into?

impl IntoIterator for EventLog

fn into_iter(self) -> Self::IntoIter

Consume the log and iterate over its Traces by value.

use wasm4pm_compat::eventlog::{Event, Trace, EventLog};
let log = EventLog::from_traces([Trace::new("c", [Event::new("a")])]);
let v: Vec<Trace> = log.into_iter().collect();
assert_eq!(v.len(), 1);

type Item = Trace

The type of the elements being iterated over.

type IntoIter = IntoIter<Trace>

Which kind of iterator are we turning this into?

impl PartialEq for EventLog

fn eq(&self, other: &EventLog) -> 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 EventLog