Function replay_with_optional_snapshot 

pub fn replay_with_optional_snapshot<A>(
    id: &<A as Entity>::Id,
    history: &StreamHistory<<A as AggregateRoot>::Event>,
    snapshot: Option<AggregateSnapshot<<A as AggregateReplay>::Snapshot>>,
) -> Result<RehydratedAggregate<A>, SnapshotReplayError<<A as AggregateReplay>::InitializationError, <A as AggregateReplay>::ApplicationError, <A as AggregateReplay>::SnapshotValidationError, <A as AggregateReplay>::SnapshotStateError>>
where
    A: AggregateReplay,

English:
Reconstructs A using an optional snapshot and a complete history for id. With no snapshot, or a SnapshotUse::Stale or SnapshotUse::Inapplicable classification, initializes state and replays all events. For SnapshotUse::Applicable, selects events strictly after the snapshot revision, restores state, then applies that tail in order. A snapshot at the history’s final revision requires no event applications.

Classification errors abort; an invalid tail yields SnapshotReplayError::SnapshotRevision before state restoration. Initialization, restoration, and application errors are wrapped in their corresponding variants with no fallback or retry. On failure the local state is dropped. Returns the complete history’s revision on success. No storage, publishing, identity checking, or panic catching is performed; the caller must supply matching history and snapshot data.

日本語:
id の完全な history と任意のスナップショットから A を復元します。 スナップショットがない場合や、分類が SnapshotUse::Stale または SnapshotUse::Inapplicable の場合は初期状態から全件再生します。 SnapshotUse::Applicable ならスナップショットのリビジョンより後のイベントを選び、 状態を復元して後続イベントを順に適用します。履歴の最終リビジョンと一致すれば適用は不要です。

分類エラーは処理を中断し、後続部分を選べなければ状態復元前に SnapshotReplayError::SnapshotRevision を返します。初期化・復元・適用のエラーは 対応するバリアントで包み、フォールバックや再試行はしません。失敗時はローカル状態を破棄します。 成功時は完全な履歴のリビジョンを返します。保存、発行、識別子検証、パニック捕捉は行いません。 呼び出し側は対応する履歴とスナップショットを指定する必要があります。

Examples found in repository

examples/event_sourcing.rs (line 209)

fn main() {
    let mut store = MemoryEvents::default();
    assert!(matches!(store.load(&1).unwrap(), LoadResult::NoStream(_)));
    let first = store
        .append(&1, ExpectedRevision::NoStream(NoStream), vec![Added::V1(2)])
        .unwrap();
    assert_eq!(first.resulting_revision, StreamRevision::new(0));
    let mut replayed = replay_aggregate::<Counter>(&1, &history(&store)).unwrap();
    assert_eq!(replayed.aggregate.value, 2);
    assert!(replayed.aggregate.pull_events().is_empty());
    let mut snapshots = MemorySnapshots::default();
    snapshots
        .save(
            &1,
            AggregateSnapshot::new(replayed.aggregate.value, replayed.revision),
        )
        .unwrap();
    store
        .append(
            &1,
            ExpectedRevision::Revision(replayed.revision),
            vec![Added::V2 { amount: 3 }],
        )
        .unwrap();
    assert!(matches!(
        store.append(
            &1,
            ExpectedRevision::Revision(replayed.revision),
            vec![Added::V1(99)]
        ),
        Err(AppendError::Conflict(_))
    ));
    let history = history(&store);
    let mut restored =
        replay_with_optional_snapshot::<Counter>(&1, &history, snapshots.load(&1).unwrap())
            .unwrap();
    let full = replay_aggregate::<Counter>(&1, &history).unwrap();
    assert_eq!(restored.aggregate.value, 5);
    assert_eq!(restored.aggregate.value, full.aggregate.value);
    assert_eq!(restored.revision, StreamRevision::new(1));
    assert!(restored.aggregate.pull_events().is_empty());
    println!("event_sourcing: upcast v1; rejected stale write; snapshot + tail = 5");
}