Struct EntityEvents 

pub struct EntityEvents<T: EsEvent, S: EsSnapshot = NoSnapshot> {
    pub entity_id: <T as EsEvent>::EntityId,
    /* private fields */
}

A Vec wrapper that manages event-stream of an entity with helpers for event-sourcing operations

Provides event sourcing operations for loading, appending, and persisting events in chronological sequence. Required field for all event-sourced entities to maintain their state change history.

Fields

entity_id: <T as EsEvent>::EntityId

The entity’s id

Implementations

impl<T, S> EntityEvents<T, S>

where T: EsEvent, S: EsSnapshot,

pub fn init( id: <T as EsEvent>::EntityId, initial_events: impl IntoIterator<Item = T>, ) -> Self

Initializes a new EntityEvents instance with the given entity ID and initial events which is returned by IntoEvents method

pub fn id(&self) -> &<T as EsEvent>::EntityId

Returns a reference to the entity’s identifier

pub fn entity_first_persisted_at(&self) -> Option<DateTime<Utc>>

Returns the timestamp of the first persisted event, indicating when the entity was created

pub fn entity_last_modified_at(&self) -> Option<DateTime<Utc>>

Returns the timestamp of the last persisted event, indicating when the entity was last modified

pub fn push(&mut self, event: T)

Appends a single new event to the entity’s event stream to be persisted later

pub fn extend(&mut self, events: impl IntoIterator<Item = T>)

Appends multiple new events to the entity’s event stream to be persisted later

pub fn any_new(&self) -> bool

Returns true if there are any unpersisted events waiting to be saved

pub fn len_persisted(&self) -> usize

Returns the count of persisted events, including those folded into the snapshot. This is the OCC offset used by every write path.

pub fn tail_len(&self) -> usize

Returns the count of events after the snapshot: the persisted tail plus any events staged for the write in flight. This is what HeadSnapshot::capture() thresholds on.

pub fn snapshot(&self) -> Option<&SnapshotRecord<S>>

Returns the loaded snapshot, if any.

pub fn last_persisted(&self, n: usize) -> LastPersisted<'_, T>

Returns an iterator over the last n persisted events after the snapshot, if any. This is what post-persist hooks receive.

pub fn replay( &self, ) -> impl DoubleEndedIterator<Item = Replay<'_, T, S>> + Clone

Returns an iterator over the full replay: the snapshot (if any), first, followed by the tail and any new events, in chronological order.

pub fn replay_persisted( &self, ) -> impl DoubleEndedIterator<Item = Replay<'_, PersistedEvent<T>, SnapshotRecord<S>>> + Clone

Like replay but only over persisted state: the snapshot record (if any) followed by the persisted tail. No new events.

pub fn load_first<E>( events: impl IntoIterator<Item = impl Into<HydrationRow<<T as EsEvent>::EntityId>>>, ) -> Result<Option<E>, EntityHydrationError>

where E: EsEntity<Event = T, Snapshot = S>,

Loads and reconstructs the first entity from a stream of hydration rows, marking events as persisted.

Returns Ok(None) if no events are present, Ok(Some(entity)) on success.

pub fn load_n<E>( events: impl IntoIterator<Item = impl Into<HydrationRow<<T as EsEvent>::EntityId>>>, n: usize, ) -> Result<(Vec<E>, bool), EntityHydrationError>

where E: EsEntity<Event = T, Snapshot = S>,

Loads and reconstructs up to n entities from a stream of hydration rows. Assumes the rows are grouped by id and ordered by sequence per id.

Returns both the entities and a flag indicating whether more entities were available in the stream.

impl<T: EsEvent> EntityEvents<T, NoSnapshot>

pub fn iter_persisted( &self, ) -> impl DoubleEndedIterator<Item = &PersistedEvent<T>> + Clone

Returns an iterator over all persisted events

pub fn iter_all(&self) -> impl DoubleEndedIterator<Item = &T> + Clone

Returns an iterator over all events (both persisted and new) in chronological order.

Only exists for EntityEvents<T, NoSnapshot> — a switch to a real snapshot type is a compile error at every such scan, rather than a silently-wrong fold that skips whatever the snapshot summarised:

use es_entity::*;
use serde::{Serialize, Deserialize};

es_entity::entity_id! { IterAllMeterId }

#[derive(EsEvent, Debug, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
#[es_event(id = "IterAllMeterId")]
pub enum IterAllMeterEvent {
    Initialized { id: IterAllMeterId },
}

#[derive(EsSnapshot, Debug, Clone, Serialize, Deserialize)]
#[es_snapshot(version = 1)]
pub struct IterAllMeterSnapshot {
    pub id: IterAllMeterId,
}

fn count_all(events: &EntityEvents<IterAllMeterEvent, IterAllMeterSnapshot>) -> usize {
    // error[E0599]: no method named `iter_all` on this type — it is
    // only defined for `EntityEvents<T, NoSnapshot>`. Use `replay()`,
    // which forces every match to account for `Replay::Snapshot`.
    events.iter_all().count()
}

Trait Implementations

impl<T: Clone + EsEvent, S: EsSnapshot + Clone> Clone for EntityEvents<T, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.