wow-core/me.ahoo.wow.eventsourcing.snapshot/SimpleSnapshot

SimpleSnapshot

data class SimpleSnapshot<S : Any>(val delegate: ReadOnlyStateAggregate<S>, val snapshotTime: Long = System.currentTimeMillis()) : Snapshot<S> , ReadOnlyStateAggregate<S> , Decorator<ReadOnlyStateAggregate<S>>

Simple implementation of Snapshot that wraps a ReadOnlyStateAggregate with a snapshot time.

Parameters

delegate

the state aggregate being snapshotted

snapshotTime

the time when the snapshot was taken (default: current time)

Constructors

SimpleSnapshot

constructor(delegate: ReadOnlyStateAggregate<S>, snapshotTime: Long = System.currentTimeMillis())

Properties

aggregateId

open override val aggregateId: AggregateId

The unique identifier of this aggregate.

delegate

open override val delegate: ReadOnlyStateAggregate<S>

deleted

open override val deleted: Boolean

eventId

open override val eventId: String

eventTime

open override val eventTime: Long

expectedNextVersion

open override val expectedNextVersion: Int

The expected version for the next event to be applied.

firstEventTime

open override val firstEventTime: Long

firstOperator

open override val firstOperator: String

initialized

open override val initialized: Boolean

isInitialVersion

open override val isInitialVersion: Boolean

operator

open override val operator: String

ownerId

open override val ownerId: String

snapshotTime

open override val snapshotTime: Long

spaceId

open override val spaceId: SpaceId

state

open override val state: S

version

open override val version: Int

The current version of this aggregate's state.

Functions

materialize

fun <S : Any, D : Any> Snapshot<S>.materialize(materialize: (S) -> D): MaterializedSnapshot<D>

toGroupKey

fun AggregateIdCapable.toGroupKey(parallelism: Int = DEFAULT_PARALLELISM): Int

Computes a grouping key for parallel processing based on the aggregate ID.

toMedium

fun <S : Any, D : Any> ReadOnlyStateAggregate<S>.toMedium(materialize: (S) -> D): MediumMaterializedSnapshot<D>

toSmall

fun <S : Any, D : Any> ReadOnlyStateAggregate<S>.toSmall(materialize: (S) -> D): SmallMaterializedSnapshot<D>

toStateAggregate

@JvmStatic

fun <S : Any> ReadOnlyStateAggregate<S>.toStateAggregate(): StateAggregate<S>