Struct fj_kernel::services::Service

pub struct Service<S: State> { /* private fields */ }

A service that controls access to some state

Service is a generic wrapper around some state, as well as code that knows how to operate on that state. It processes commands, changes the state based on those command, and produces events that capture these changes. These events are stored, providing a log of all changes to the state, and can be replayed later to re-create the state at any point in time.

The wrapped state must implement State, which defines the type of command that this service processes, and the type of event that captures state changes. It also defines methods that operate on the state, commands, and events.

Implementations of State might also define an extension trait for a specific Service<MyState>, to provide a convenient API to callers.

This design takes inspiration from, and uses the nomenclature of, this article: https://thinkbeforecoding.com/post/2021/12/17/functional-event-sourcing-decider

Implementations

impl<S: State> Service<S>

pub fn new(state: S) -> Self

Create an instance of Service

pub fn subscribe(&mut self, subscriber: Arc<Mutex<dyn Subscriber<S::Event>>>)

Add a subscriber

pub fn execute(&mut self, command: S::Command)

Execute a command

The command is executed synchronously. When this method returns, the state has been updated and any events have been logged.

pub fn events(&self) -> impl Iterator<Item = &S::Event>

Access the events

pub fn replay<'event>(
    state: &mut S,
    events: impl IntoIterator<Item = &'event S::Event>
)where
    <S as State>::Event: 'event,

Replay the provided events on the given state

Trait Implementations

impl<S> Default for Service<S>where
    S: Default + State,

fn default() -> Self

Returns the “default value” for a type.

impl<S: State> Deref for Service<S>

type Target = S

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl ServiceObjectsExt for Service<Objects>

fn insert<T>(&mut self, handle: Handle<T>, object: T)where
    (Handle<T>, T): Into<Object<WithHandle>>,

Insert an object