Struct Engine 

pub struct Engine<A: Action> { /* private fields */ }

The enforcement engine — applies actions to situations with precondition checking.

Implements the .next() pattern with back/forward history:

let engine = Engine::new(initial_situation, preconditions, apply_fn);
let engine = engine.next(action1)?;   // validates + applies
let engine = engine.next(action2)?;   // validates + applies
let engine = engine.back()?;          // undo
let engine = engine.forward()?;       // redo
engine.trace().dump()                 // full history

Implementations

impl<A: Action> Engine<A>

pub fn new( situation: A::Sit, preconditions: Vec<Box<dyn Precondition<A>>>, apply_fn: impl Fn(&A::Sit, &A) -> Result<A::Sit, String> + 'static, ) -> Self

Create a new engine with an initial situation, preconditions, and apply function.

pub fn step(&self) -> usize

Current step number (derived from history depth).

pub fn situation(&self) -> &A::Sit

The current situation.

pub fn trace(&self) -> &Trace

The full trace of all actions.

pub fn is_terminal(&self) -> bool

Is the current situation terminal?

pub fn next(self, action: A) -> Result<Self, EngineError<A>>

Apply an action — the .next() method.

Checks all preconditions. If any fail, returns EngineError::Violated. If all pass but apply fails, returns EngineError::LogicalError. Both variants return the engine for rollback.

pub fn back(self) -> Result<Self, Self>

Go back one step. The current situation moves to the redo stack.

pub fn forward(self) -> Result<Self, Self>

Go forward one step (redo). Only available after back().

pub fn back_depth(&self) -> usize

How many steps back are available.

pub fn forward_depth(&self) -> usize

How many steps forward are available (after back).

pub fn try_next(self, action: A) -> Result<Self, Vec<String>>

Try to apply an action, returning the new engine or the violations as strings.

Trait Implementations

impl<A: Action> Debug for Engine<A>

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

Formats the value using the given formatter.