Uses of Interface
io.fluxzero.sdk.modeling.Entity

Packages that use Entity

Package	Description
io.fluxzero.sdk
io.fluxzero.sdk.modeling
io.fluxzero.sdk.persisting.eventsourcing
io.fluxzero.sdk.persisting.repository
io.fluxzero.sdk.tracking.handling

Uses of Entity in io.fluxzero.sdk

Methods in io.fluxzero.sdk that return Entity

Modifier and Type	Method	Description
static <T> Entity<T>	Fluxzero.asEntity(T value)	Returns an Entity containing given value.
static <T> Entity<T>	Fluxzero.loadAggregate(Id<T> aggregateId)	Loads the aggregate root of type <T> with given aggregateId.
static <T> Entity<T>	Fluxzero.loadAggregate(Object aggregateId)	Loads the aggregate root with the given aggregateId.
static <T> Entity<T>	Fluxzero.loadAggregate(Object aggregateId, Class<T> aggregateType)	Loads the aggregate root of type <T> with given aggregateId.
static <T> Entity<T>	Fluxzero.loadAggregateFor(Object entityId)	Loads the aggregate root that currently contains the entity with given entityId.
static <T> Entity<T>	Fluxzero.loadAggregateFor(Object entityId, Class<?> defaultType)	Loads the aggregate root of type <T> that currently contains the entity with given entityId.
static <T> Entity<T>	Fluxzero.loadEntity(Id<T> entityId)	Loads the entity with given id.
static <T> Entity<T>	Fluxzero.loadEntity(Object entityId)	Loads the entity with given id.
static <T> Entity<T>	Fluxzero.loadEntity(Object entityId, Class<T> entityType)	Loads an entity by functional ID and expected type.
static <T> Entity<T>	Fluxzero.loadModel(Id<T> modelId)	Loads the independently stored model identified by the given typed ID.
static <T> Entity<T>	Fluxzero.loadModel(Object modelId)	Loads an independently stored model by ID.
static <T> Entity<T>	Fluxzero.loadModel(Object parentId, Class<?> parentType, Object modelId, Class<T> modelType)	Loads a parent-scoped model by functional child ID and explicit parent type.
static <T> Entity<T>	Fluxzero.loadModel(Object modelId, Class<T> modelType)	Loads an independently stored model by ID and expected type.

Methods in io.fluxzero.sdk that return types with arguments of type Entity

Modifier and Type	Method	Description
static <T> List<Entity<T>>	Fluxzero.loadModels(List<?> modelIds, Class<T> modelType)	Loads several independently stored models at one coherent state boundary.

Uses of Entity in io.fluxzero.sdk.modeling

Subinterfaces of Entity in io.fluxzero.sdk.modeling

Modifier and Type	Interface	Description
interface	AggregateRoot<T>	Represents the root of a legacy aggregate in a domain model.
interface	ModelRoot<T>	Root wrapper for an independently persisted Model revision.
interface	PersistedRoot<T>	Shared revision contract for an independently persisted Aggregate or Model root.

Classes in io.fluxzero.sdk.modeling that implement Entity

Modifier and Type	Class	Description
class	DelegatingEntity<T>	A base implementation of Entity that forwards all method calls to a delegated Entity instance.
class	ImmutableAggregateRoot<T>	Immutable representation of an AggregateRoot, extending ImmutableEntity with additional metadata for event sourcing.
class	ImmutableEntity<T>	Immutable implementation of the Entity interface, representing a snapshot of a domain entity.
class	ImmutableModelRoot<T>	Immutable entity wrapper for one independently stored model revision.
class	ImmutableRoot<T>	Shared immutable revision state of persisted Aggregate and Model roots.
class	LazyAggregateRoot<T>	A lazily-loaded implementation of AggregateRoot that defers deserialization and event application until the entity value is explicitly accessed.
class	ModifiableAggregateRoot<T>	A mutable, stateful AggregateRoot implementation that allows in-place updates and applies events with commit support for persisting the state and synchronizing it with the Fluxzero Runtime.
class	ModifiableEntity<T>	A mutable view on a nested entity within a ModifiableAggregateRoot.
class	NoOpEntity<T>	A read-only, inert Entity wrapper used exclusively during the loading phase of aggregate state.
class	SideEffectFreeEntity<T>	A functional, non-persistent Entity wrapper that enables safe state mutation and validation without producing side effects such as event publication or snapshot creation.

Fields in io.fluxzero.sdk.modeling declared as Entity

Modifier and Type	Field	Description
protected Entity<T>	DelegatingEntity.delegate

Methods in io.fluxzero.sdk.modeling that return Entity

Modifier and Type	Method	Description
Entity<?>	AnnotatedEntityHolder.EntityUpdate.after()	Returns the value of the after record component.
Entity<T>	Entity.apply(Message eventMessage)	Applies the given message to the entity.
default Entity<T>	Entity.apply(DeserializingMessage eventMessage)	Applies the given deserializing message to the entity.
default Entity<T>	Entity.apply(Object event)	Processes the given event and applies the corresponding logic based on its type.
default Entity<T>	Entity.apply(Object... events)	Applies the given events to reconstruct or update the entity's state.
default Entity<T>	Entity.apply(Object event, io.fluxzero.common.api.Metadata metadata)	Applies an event and associated metadata to produce a resulting entity.
default Entity<T>	Entity.apply(Collection<?> events)	Applies a collection of events to the current entity, returning an updated entity.
Entity<T>	ImmutableAggregateRoot.apply(DeserializingMessage message)
Entity<T>	ImmutableEntity.apply(Message message)
Entity<T>	ImmutableEntity.apply(DeserializingMessage message)
Entity<T>	LazyAggregateRoot.apply(Message eventMessage)
Entity<T>	ModifiableAggregateRoot.apply(Message message)
protected Entity<T>	ModifiableAggregateRoot.apply(Message message, boolean assertLegal)
Entity<T>	ModifiableEntity.apply(Message eventMessage)
Entity<T>	NoOpEntity.apply(Message eventMessage)
default Entity<T>	Entity.assertAndApply(Object payloadOrMessage)	Verifies that the provided update is legal given the current state of the aggregate and on success applies it to the aggregate.
default Entity<T>	Entity.assertAndApply(Object... updates)	Applies a number of updates to the current entity after performing necessary legality assertions.
default Entity<T>	Entity.assertAndApply(Object payload, io.fluxzero.common.api.Metadata metadata)	Verifies that the provided update is legal given the current state of the aggregate and on success applies it to the aggregate.
default Entity<T>	Entity.assertAndApply(Collection<?> updates)	Applies a collection of updates sequentially to the current entity after asserting each is legal, and returns the resulting entity.
Entity<T>	ModifiableAggregateRoot.assertAndApply(Object payloadOrMessage)
Entity<T>	ModifiableEntity.assertAndApply(Object payloadOrMessage)
<E extends Exception> Entity<T>	Entity.assertLegal(Object update)	Verifies that the provided update is legal given the current state of the aggregate.
<E extends Exception> Entity<T>	ImmutableEntity.assertLegal(Object update)
<E extends Exception> Entity<T>	LazyAggregateRoot.assertLegal(Object update)
<E extends Exception> Entity<T>	ModifiableAggregateRoot.assertLegal(Object update)
<E extends Exception> Entity<T>	ModifiableEntity.assertLegal(Object update)
<E extends Exception> Entity<T>	SideEffectFreeEntity.assertLegal(Object update)
Entity<?>	AnnotatedEntityHolder.EntityUpdate.before()	Returns the value of the before record component.
Entity<T>	Entity.commit()	Commits the current state of the entity, persisting any changes made to it.
Entity<T>	ImmutableEntity.commit()
Entity<T>	LazyAggregateRoot.commit()
Entity<T>	ModifiableAggregateRoot.commit()
Entity<T>	ModifiableEntity.commit()
Entity<T>	NoOpEntity.commit()
Entity<T>	SideEffectFreeEntity.commit()
static Entity<?>	ModelBatchScope.currentValue(String namespace, String modelId)	Returns one pending exact value; aliases are deliberately not resolved.
Entity<?>	CommitAttempt.entity(String modelId)
Entity<?>	HasEntity.getEntity()	Retrieves the associated Entity of the object.
protected Entity<T>	LazyAggregateRoot.getLastCheckpoint()
protected Entity<?>	EntityParameterResolver.getMatchingEntity(Object input, Parameter parameter)	Attempts to retrieve an Entity instance matching the given method parameter.
protected Entity<T>	ModifiableAggregateRoot.handleUpdate(UnaryOperator<Entity<T>> update)
default Entity<T>	Entity.ifPresent(UnaryOperator<Entity<T>> action)	Applies the specified action to this entity if it is present, returning the result of the commit.
static <T> Entity<T>	ModifiableAggregateRoot.load(@NonNull AggregateRepository repository, Object aggregateId, Supplier<Entity<T>> loader, AggregateCommitPolicy commitPolicy, EntityMetadata.RootConfiguration configuration, AggregateEventRouting eventRouting, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)	Loads an aggregate using shared persistence settings and its Aggregate-specific event routing.
static <T> Entity<T>	ModifiableAggregateRoot.load(@NonNull AggregateRepository repository, Object aggregateId, Supplier<Entity<T>> loader, AggregateCommitPolicy commitPolicy, EventPublication eventPublication, EventPublicationStrategy publicationStrategy, AggregateEventRouting eventRouting, boolean eventSourced, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)	Loads an aggregate in a scope owned by the supplied repository.
static <T> Entity<T>	ModifiableAggregateRoot.load(Object aggregateId, Supplier<Entity<T>> loader, AggregateCommitPolicy commitPolicy, EventPublication eventPublication, EventPublicationStrategy publicationStrategy, AggregateEventRouting eventRouting, boolean eventSourced, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)
static <T> Entity<T>	ModelBatchScope.overlayCurrent(String namespace, String requestedId, Class<T> requestedType, Entity<T> durable)	Overlays a durable direct load with the newest pending model or alias visible to the current message.
default Entity<?>	AggregateRoot.parent()
Entity<?>	DelegatingEntity.parent()
Entity<?>	Entity.parent()	Retrieves the parent entity of the current entity.
Entity<?>	ModifiableEntity.parent()
Entity<?>	NoOpEntity.parent()
default Entity<?>	PersistedRoot.parent()
Entity<?>	SideEffectFreeEntity.parent()
Entity<T>	AggregateRoot.previous()
Entity<T>	DelegatingEntity.previous()
default Entity<T>	Entity.previous()	Retrieves the previous version of this entity.
Entity<T>	LazyAggregateRoot.previous()
Entity<T>	ModifiableAggregateRoot.previous()
Entity<T>	ModifiableEntity.previous()
Entity<T>	NoOpEntity.previous()
Entity<T>	PersistedRoot.previous()
static Entity<?>	ImmutableRoot.retainPrevious(Entity<?> previous, EntityMetadata.RootConfiguration configuration)	Applies the shared bounded revision-retention policy used by persisted roots.
default Entity<?>	Entity.root()	Retrieves the root entity in the hierarchy.
Entity<T>	Entity.update(UnaryOperator<T> function)	Updates the current entity's value using the specified unary operator and returns a new entity containing the updated value.
Entity<T>	ImmutableAggregateRoot.update(UnaryOperator<T> function)
Entity<T>	ImmutableEntity.update(UnaryOperator<T> function)
Entity<T>	LazyAggregateRoot.update(UnaryOperator<T> function)
Entity<T>	ModifiableAggregateRoot.update(UnaryOperator<T> function)
Entity<T>	ModifiableEntity.update(UnaryOperator<T> function)
Entity<T>	NoOpEntity.update(UnaryOperator<T> function)
Entity<T>	AggregateRoot.withEventIndex(Long index, String messageId)
Entity<T>	DelegatingEntity.withEventIndex(Long index, String messageId)
default Entity<T>	Entity.withEventIndex(Long index, String messageId)	Updates the event index and message ID of the entity and returns the updated version of the entity.
Entity<T>	ImmutableAggregateRoot.withEventIndex(Long index, String messageId)
Entity<T>	ImmutableModelRoot.withEventIndex(Long index, String messageId)
Entity<T>	LazyAggregateRoot.withEventIndex(Long index, String messageId)
Entity<T>	PersistedRoot.withEventIndex(Long index, String messageId)
Entity<T>	AggregateRoot.withSequenceNumber(long sequenceNumber)
Entity<T>	DelegatingEntity.withSequenceNumber(long sequenceNumber)
default Entity<T>	Entity.withSequenceNumber(long sequenceNumber)	Returns an updated entity based on this with the specified sequence number.
Entity<T>	ImmutableAggregateRoot.withSequenceNumber(long sequenceNumber)
Entity<T>	ImmutableModelRoot.withSequenceNumber(long sequenceNumber)
Entity<T>	LazyAggregateRoot.withSequenceNumber(long sequenceNumber)
Entity<T>	PersistedRoot.withSequenceNumber(long sequenceNumber)
Entity<T>	DelegatingEntity.withType(Class<T> type)
Entity<T>	Entity.withType(Class<T> type)	Sets the type of the entity to the specified class and returns the updated entity.
Entity<T>	ImmutableEntity.withType(Class<T> type)
Entity<T>	LazyAggregateRoot.withType(Class<T> type)
Entity<T>	NoOpEntity.withType(Class<T> type)
Entity<T>	SideEffectFreeEntity.withType(Class<T> type)

Methods in io.fluxzero.sdk.modeling that return types with arguments of type Entity

Modifier and Type	Method	Description
default Stream<Entity<?>>	Entity.allEntities()	Retrieves a stream of all entities, including the current entity and all nested entities.
default List<Entity<?>>	Entity.ancestors()	Retrieves a list of the ancestor entities for the current entity.
static Map<String, Entity<?>>	ModelBatchScope.currentValues(String namespace)	Returns pending exact values visible to the current message, in message order.
UnaryOperator<Entity<?>>	Change.directReplay()	Returns the value of the directReplay record component.
Map<String, Entity<?>>	CommitAttempt.entities()
Collection<? extends Entity<?>>	DelegatingEntity.entities()
Collection<? extends Entity<?>>	Entity.entities()	Retrieves child entities of this entity.
Collection<? extends Entity<?>>	ImmutableEntity.entities()	Returns the lazily discovered direct child entities.
Collection<? extends Entity<?>>	LazyAggregateRoot.entities()
Collection<? extends Entity<?>>	ModifiableAggregateRoot.entities()
Collection<? extends Entity<?>>	ModifiableEntity.entities()
Collection<? extends Entity<?>>	NoOpEntity.entities()
default Optional<Entity<T>>	Entity.filterEntity(Predicate<? super Entity<T>> predicate)	Filters the current entity based on the provided predicate.
default Optional<Entity<T>>	Entity.filterPresent()	Filters the entity based on its presence status.
default Optional<Entity<?>>	Entity.findEntity(Predicate<? super Entity<?>> predicate)	Finds the first entity in this entity hierarchy that matches the given predicate.
default <C> Optional<Entity<C>>	Entity.getEntity(Object entityId)	Retrieves an entity based on the provided entity ID.
default <C> Optional<Entity<C>>	Entity.getEntity(Object entityId, Class<C> entityType)	Retrieves an entity by functional ID and expected type.
default Optional<Entity<T>>	Entity.playBackToCondition(Predicate<Entity<T>> condition)	Plays back through older versions of this entity until a specified condition is met.
default Optional<Entity<T>>	Entity.playBackToEvent(Long eventIndex, String eventId)	Finds a version of this entity matching the given eventIndex or eventId.
default Iterable<Entity<?>>	Entity.possibleTargets(Object update)	Determines the possible target entities for the given update.

Methods in io.fluxzero.sdk.modeling with parameters of type Entity

Modifier and Type	Method	Description
Optional<io.fluxzero.common.handling.HandlerInvoker>	DefaultEntityHelper.applyInvoker(DeserializingMessage event, Entity<?> entity, boolean searchChildren, boolean checkCompatibility)	Finds a handler method annotated with @Apply and wraps it to preserve apply context flags.
default Optional<io.fluxzero.common.handling.HandlerInvoker>	EntityHelper.applyInvoker(DeserializingMessage message, Entity<?> entity)	Returns an invoker that can apply the given event to the provided entity.
default Optional<io.fluxzero.common.handling.HandlerInvoker>	EntityHelper.applyInvoker(DeserializingMessage message, Entity<?> entity, boolean searchChildren)	Returns an invoker for applying the event to the entity, optionally checking nested entities.
Optional<io.fluxzero.common.handling.HandlerInvoker>	EntityHelper.applyInvoker(DeserializingMessage message, Entity<?> entity, boolean searchChildren, boolean checkCompatibility)	Returns an invoker for applying the event to the entity, optionally checking nested entities.
protected <E extends Exception> void	ImmutableEntity.assertApplyCompatibility(DeserializingMessage message, Entity<?> entity)
protected <E extends Exception> void	ImmutableEntity.assertApplyCompatibility(DeserializingMessage message, Entity<?> entity, Set<Class<?>> visitedTypes)
<E extends Exception> void	DefaultEntityHelper.assertLegal(Object value, Entity<?> entity)	Performs a validation check using @AssertLegal handlers for the provided payload.
<E extends Exception> void	EntityHelper.assertLegal(Object value, Entity<?> entity)	Validates whether the given value results in a legal state transition for the specified entity.
default Set<io.fluxzero.common.api.modeling.Relationship>	Entity.associations(Entity<?> previous)	Determines the set of new associations (relationships) that are present in the current entity but not in the provided previous entity.
<E extends Exception> Optional<E>	DefaultEntityHelper.checkLegality(Object value, Entity<?> entity)	Returns an exception if the value is illegal for the current entity, or Optional.empty() if legal.
<E extends Exception> Optional<E>	EntityHelper.checkLegality(Object value, Entity<?> entity)	Checks if the given value would be considered legal for the specified entity.
static CommitAttempt	CommitAttempt.createSingle(long readStateIndex, String modelId, Class<?> modelType, MutationPlan.Access access, List<String> sourceProperties, Entity<?> entity)	Creates the allocation-minimal begin-state used by a direct single-model strategy.
default Set<io.fluxzero.common.api.modeling.Relationship>	Entity.dissociations(Entity<?> previous)	Identifies and returns the set of relationships that are dissociated when compared to the relationships of the given previous entity.
static <T> ImmutableAggregateRoot<T>	ImmutableAggregateRoot.from(Entity<T> a, EntityHelper entityHelper, Serializer serializer, EventStore eventStore)
static <T> LazyAggregateRoot<T>	LazyAggregateRoot.from(ImmutableAggregateRoot<T> delegate, Entity<T> lastCheckpoint)
List<? extends ImmutableEntity<?>>	AnnotatedEntityHolder.getEntities(Entity<?> parent)	Returns the set of ImmutableEntity instances that are defined at the member location within the specified parent entity.
ImmutableEntity<?>	AnnotatedEntityHolder.getEntityByRoute(Entity<?> parent, String routeValue)
CompletableFuture<Void>	ModifiableAggregateRoot.CommitHandler.handle(Entity<?> model, List<AppliedEvent> unpublished, Entity<?> beforeUpdate)	Commits the aggregate state and any unpublished events.
Stream<?>	DefaultEntityHelper.intercept(Object value, Entity<?> entity)	Intercepts the given value using @InterceptApply methods defined on the entity.
Stream<?>	EntityHelper.intercept(Object value, Entity<?> entity)	Intercepts the given value before it is applied to an entity.
boolean	DefaultEntityHelper.isLegal(Object value, Entity<?> entity)	Convenience method that returns true if DefaultEntityHelper.checkLegality(Object, Entity) yields no error.
boolean	EntityHelper.isLegal(Object value, Entity<?> entity)	Returns whether the given value is considered legal for the specified entity.
static <T> Graph<T>	Graphs.lazy(Entity<T> entity, long stateIndex, ModelRepository repository)	Creates a lazy one-model graph without loading relationships.
protected boolean	EntityParameterResolver.matches(Parameter parameter, Entity<?> entity)	Returns true if the entity or any of its parents match the expected parameter type, respecting nullable flags on parameters.
static <T> Entity<T>	ModelBatchScope.overlayCurrent(String namespace, String requestedId, Class<T> requestedType, Entity<T> durable)	Overlays a durable direct load with the newest pending model or alias visible to the current message.
B	ImmutableAggregateRoot.ImmutableAggregateRootBuilder.previous(Entity<T> value)
protected Supplier<?>	EntityParameterResolver.resolve(Parameter parameter, Entity<?> entity)	Returns a Supplier that returns the entity if the entity or any of its parents match the expected parameter type.
static Entity<?>	ImmutableRoot.retainPrevious(Entity<?> previous, EntityMetadata.RootConfiguration configuration)	Applies the shared bounded revision-retention policy used by persisted roots.
static <T> ImmutableModelRoot<T>	ImmutableModelRoot.revision(Object id, Class<T> type, String idProperty, T value, EntityHelper entityHelper, Serializer serializer, String lastEventId, Long lastEventIndex, Instant timestamp, long sequenceNumber, long stateIndex, Entity<T> previous)	Creates a model root from one authoritative stored revision.
Object	AnnotatedEntityHolder.updateOwner(Object owner, Entity<?> before, Entity<?> after)	Updates the parent object with the new state of a child entity.
DefaultEntityHelper.MessageWithEntity	DefaultEntityHelper.MessageWithEntity.withEntity(Entity<?> entity)
ImmutableAggregateRoot<T>	ImmutableAggregateRoot.withPrevious(Entity<T> previous)
ImmutableModelRoot<T>	ImmutableModelRoot.withPrevious(Entity<T> previous)	Returns this revision with the supplied in-memory predecessor.
abstract ImmutableRoot<T>	ImmutableRoot.withPrevious(Entity<T> previous)	Returns this root revision with a different in-memory predecessor.

Method parameters in io.fluxzero.sdk.modeling with type arguments of type Entity

Modifier and Type	Method	Description
static <T> Graph<T>	Graphs.compose(String rootId, long stateIndex, Map<String, Entity<?>> models, List<io.fluxzero.common.api.modeling.ModelGraphEdge> edges, ModelRepository repository, boolean historical)	Creates a complete graph from one coherent repository reconstruction.
static <T> Graph<T>	Graphs.compose(String rootId, long stateIndex, Map<String, Entity<?>> models, List<io.fluxzero.common.api.modeling.ModelGraphEdge> edges, ModelRepository repository, boolean historical, io.fluxzero.common.api.modeling.ModelReadBoundary boundary)	Creates a complete graph while retaining its exact repository boundary for lazy relationship loads.
static <T> Graph<T>	Graphs.compose(String rootId, long stateIndex, Map<String, Entity<?>> durableModels, List<io.fluxzero.common.api.modeling.ModelGraphEdge> durableEdges, ModelRepository repository, boolean historical, io.fluxzero.common.api.modeling.ModelReadBoundary boundary, String namespace, Class<T> rootType, Graph.Options options, Map<String, Entity<?>> staged, Function<Entity<?>, Graph<?>> supplementalLoader)	Builds one indexed state with visible message-batch values applied before graph selection.
static <T> Graph<T>	Graphs.compose(String rootId, long stateIndex, Map<String, Entity<?>> durableModels, List<io.fluxzero.common.api.modeling.ModelGraphEdge> durableEdges, ModelRepository repository, boolean historical, io.fluxzero.common.api.modeling.ModelReadBoundary boundary, String namespace, Class<T> rootType, Graph.Options options, Map<String, Entity<?>> staged, Function<Entity<?>, Graph<?>> supplementalLoader)	Builds one indexed state with visible message-batch values applied before graph selection.
static CommitAttempt	CommitAttempt.create(long readStateIndex, MutationPlan.Resolution resolution, Map<String, ? extends Entity<?>> loadedModels)	Creates a loaded begin-state for one resolved target set.
default Optional<Entity<T>>	Entity.filterEntity(Predicate<? super Entity<T>> predicate)	Filters the current entity based on the provided predicate.
default Optional<Entity<?>>	Entity.findEntity(Predicate<? super Entity<?>> predicate)	Finds the first entity in this entity hierarchy that matches the given predicate.
protected Entity<T>	ModifiableAggregateRoot.handleUpdate(UnaryOperator<Entity<T>> update)
default Entity<T>	Entity.ifPresent(UnaryOperator<Entity<T>> action)	Applies the specified action to this entity if it is present, returning the result of the commit.
static <T> Entity<T>	ModifiableAggregateRoot.load(@NonNull AggregateRepository repository, Object aggregateId, Supplier<Entity<T>> loader, AggregateCommitPolicy commitPolicy, EntityMetadata.RootConfiguration configuration, AggregateEventRouting eventRouting, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)	Loads an aggregate using shared persistence settings and its Aggregate-specific event routing.
static <T> Entity<T>	ModifiableAggregateRoot.load(@NonNull AggregateRepository repository, Object aggregateId, Supplier<Entity<T>> loader, AggregateCommitPolicy commitPolicy, EventPublication eventPublication, EventPublicationStrategy publicationStrategy, AggregateEventRouting eventRouting, boolean eventSourced, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)	Loads an aggregate in a scope owned by the supplied repository.
static <T> Entity<T>	ModifiableAggregateRoot.load(Object aggregateId, Supplier<Entity<T>> loader, AggregateCommitPolicy commitPolicy, EventPublication eventPublication, EventPublicationStrategy publicationStrategy, AggregateEventRouting eventRouting, boolean eventSourced, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)
default <U> Optional<U>	Entity.mapEntity(Function<Entity<T>, U> action)	Applies the provided mapping function to the entity and returns an Optional describing the result.
default <U> Optional<U>	Entity.mapIfPresent(Function<Entity<T>, U> action)	Maps the entity to a new value if the entity is present.
default Optional<Entity<T>>	Entity.playBackToCondition(Predicate<Entity<T>> condition)	Plays back through older versions of this entity until a specified condition is met.

Constructors in io.fluxzero.sdk.modeling with parameters of type Entity

Modifier	Constructor	Description
	DelegatingEntity(@NonNull Entity<T> delegate)
	DeserializingMessageWithEntity(DeserializingMessage message, Entity<?> entity)
	EntityUpdate(Entity<?> before, Entity<?> after)	Creates an instance of a EntityUpdate record class.
protected	ImmutableEntity(Object id, Class<T> type, T value, String idProperty, Entity<?> parent, AnnotatedEntityHolder holder, EntityHelper entityHelper, Serializer serializer)
protected	ImmutableRoot(ImmutableRoot<T> source, String lastEventId, Long lastEventIndex, long sequenceNumber, Entity<T> previous)
protected	ImmutableRoot(Object id, Class<T> type, String idProperty, T value, EntityHelper entityHelper, Serializer serializer, String lastEventId, Long lastEventIndex, Instant timestamp, long sequenceNumber, Entity<T> previous)
protected	LazyAggregateRoot(ImmutableAggregateRoot<T> delegate, Entity<T> lastCheckpoint)
	MessageWithEntity(Object payload, Entity<?> entity)
	MessageWithEntity(Object payload, Entity<?> entity, boolean afterHandler)
protected	ModifiableAggregateRoot(Entity<T> delegate, AggregateCommitPolicy commitPolicy, EventPublication eventPublication, EventPublicationStrategy publicationStrategy, AggregateEventRouting eventRouting, boolean eventSourced, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)
	ModifiableEntity(Entity<T> delegate, ModifiableAggregateRoot<?> root)
	SideEffectFreeEntity(Entity<T> delegate)

Constructor parameters in io.fluxzero.sdk.modeling with type arguments of type Entity

Modifier	Constructor	Description
	Change(String modelId, Class<?> modelType, long beforeSequenceNumber, Long beforeLastEventIndex, Object before, Object after, Executable handler, UnaryOperator<Entity<?>> directReplay, boolean cascadedDeletion, EntityMetadata metadata, io.fluxzero.common.api.modeling.ModelConflictPolicy conflictPolicy, GraphProjectionCompletion graphProjectionCompletion, boolean active, boolean storeEvent, boolean publishEvent, boolean updateState)	Creates an instance of a Change record class.

Uses of Entity in io.fluxzero.sdk.persisting.eventsourcing

Methods in io.fluxzero.sdk.persisting.eventsourcing that return types with arguments of type Entity

Modifier and Type	Method	Description
protected <T> Optional<Entity<T>>	DefaultSnapshotStore.deserializeSnapshot(DefaultSnapshotStore.SnapshotDocument document)
protected <T> Optional<Entity<T>>	DefaultSnapshotStore.findSnapshot(Object aggregateId, Long sequenceNumberExclusive)
<T> Optional<Entity<T>>	DefaultSnapshotStore.getSnapshot(Object aggregateId)
<T> Optional<Entity<T>>	NoOpSnapshotStore.getSnapshot(Object aggregateId)
<T> Optional<Entity<T>>	SnapshotStore.getSnapshot(Object aggregateId)	Retrieves the most recent snapshot for a given aggregate ID, if available.
<T> Optional<Entity<T>>	DefaultSnapshotStore.getSnapshotBefore(Object aggregateId, long sequenceNumberExclusive)
<T> Optional<Entity<T>>	NoOpSnapshotStore.getSnapshotBefore(Object aggregateId, long sequenceNumberExclusive)
<T> Optional<Entity<T>>	SnapshotStore.getSnapshotBefore(Object aggregateId, long sequenceNumberExclusive)	Retrieves the most recent snapshot with a sequence number strictly lower than the given value.

Methods in io.fluxzero.sdk.persisting.eventsourcing with parameters of type Entity

Modifier and Type	Method	Description
boolean	NoSnapshotTrigger.shouldCreateSnapshot(Entity<?> model, List<AppliedEvent> newEvents)	Always returns false, indicating that a snapshot should never be created.
boolean	PeriodicSnapshotTrigger.shouldCreateSnapshot(Entity<?> model, List<AppliedEvent> newEvents)	Determines whether a new snapshot should be created.
boolean	SnapshotTrigger.shouldCreateSnapshot(Entity<?> model, List<AppliedEvent> newEvents)	Determines whether a snapshot should be created for the given aggregate state and recent events.
<T> CompletableFuture<Void>	DefaultSnapshotStore.storeSnapshot(Entity<T> snapshot)
<T> CompletableFuture<Void>	NoOpSnapshotStore.storeSnapshot(Entity<T> snapshot)
<T> CompletableFuture<Void>	SnapshotStore.storeSnapshot(Entity<T> snapshot)	Stores a new snapshot for the given aggregate entity.
protected CompletableFuture<Void>	DefaultSnapshotStore.trimSnapshots(Entity<?> snapshot)

Uses of Entity in io.fluxzero.sdk.persisting.repository

Methods in io.fluxzero.sdk.persisting.repository that return Entity

Modifier and Type	Method	Description
<T> Entity<T>	AggregateRepository.asEntity(T entity)	Wrap an existing aggregate instance into an Entity, initializing tracking and identity information.
<T> Entity<T>	CachingAggregateRepository.asEntity(T entityId)
<T> Entity<T>	DefaultAggregateRepository.asEntity(T entityValue)
protected Entity<T>	DefaultAggregateRepository.AnnotatedAggregateRepository.eventSourceModel(Entity<T> model)
Entity<T>	DefaultAggregateRepository.AnnotatedAggregateRepository.fromValue(T value)
default <T> Entity<T>	AggregateRepository.load(Id<T> aggregateId)	Load an aggregate by a typed identifier.
default <T> Entity<T>	AggregateRepository.load(@NotNull Object aggregateId)	Load an aggregate by its identifier.
<T> Entity<T>	AggregateRepository.load(@NonNull Object aggregateId, Class<T> aggregateType)	Load an aggregate by its identifier and type.
<T> Entity<T>	CachingAggregateRepository.load(@NonNull Object aggregateId, Class<T> type)
Entity<T>	DefaultAggregateRepository.AnnotatedAggregateRepository.load(Object id)
<T> Entity<T>	DefaultAggregateRepository.load(@NonNull Object aggregateId, Class<T> type)
<T> Entity<T>	DefaultModelRepository.load(@NonNull String modelId, @NonNull Class<T> modelType)
default <T> Entity<T>	ModelRepository.load(@NonNull Id<T> modelId)	Loads a model using the type carried by a typed identifier.
default <T> Entity<T>	ModelRepository.load(@NotNull Object modelId)	Loads a model by ID, inferring its requested type when the ID is typed.
default <T> Entity<T>	ModelRepository.load(@NonNull Object parentId, @NonNull Class<?> parentType, @NonNull Object modelId, @NonNull Class<T> modelType)	Loads a parent-scoped model by its functional child ID and explicit parent type.
default <T> Entity<T>	ModelRepository.load(@NonNull Object modelId, @NonNull Class<T> modelType)	Loads a model using the string representation of the supplied ID, resolving a current model alias when no primary model has that identity.
<T> Entity<T>	ModelRepository.load(@NonNull String modelId, @NonNull Class<T> modelType)	Loads a model by primary ID or current alias and expected type.
<T> Entity<T>	DefaultModelRepository.loadCurrent(@NonNull String modelId, @NonNull Class<T> modelType)
default <T> Entity<T>	ModelRepository.loadCurrent(@NonNull Object modelId, @NonNull Class<T> modelType)	Loads the latest model state without inheriting an event or notification handler's historical read boundary.
default <T> Entity<T>	ModelRepository.loadCurrent(@NonNull String modelId, @NonNull Class<T> modelType)	Loads the latest model state by exact persisted identity.
<T> Entity<T>	AggregateRepository.loadFor(@NonNull Object entityId, Class<?> defaultType)	Load the aggregate that owns the specified entity.
<T> Entity<T>	CachingAggregateRepository.loadFor(@NonNull Object entityId, Class<?> defaultType)
<T> Entity<T>	DefaultAggregateRepository.loadFor(@NonNull Object entityId, Class<?> defaultType)
protected Entity<T>	DefaultAggregateRepository.AnnotatedAggregateRepository.loadSnapshot(Object id)
protected Entity<T>	DefaultAggregateRepository.AnnotatedAggregateRepository.withHistoricalSnapshots(ImmutableAggregateRoot<T> snapshot, Object aggregateId)

Methods in io.fluxzero.sdk.persisting.repository that return types with arguments of type Entity

Modifier and Type	Method	Description
<T> List<Entity<T>>	DefaultModelRepository.loadAll(@NonNull List<?> modelIds, @NonNull Class<T> modelType)
default <T> List<Entity<T>>	ModelRepository.loadAll(@NonNull List<?> modelIds, @NonNull Class<T> modelType)	Loads several models at one coherent state boundary, preserving input order.

Methods in io.fluxzero.sdk.persisting.repository with parameters of type Entity

Modifier and Type	Method	Description
void	DefaultModelRepository.CurrentModelSink.accept(Entity<?> entity, long validThrough, long modelStateIndex)
CompletableFuture<Void>	DefaultAggregateRepository.AnnotatedAggregateRepository.commit(Entity<?> after, List<AppliedEvent> unpublishedEvents, Entity<?> before)
protected Entity<T>	DefaultAggregateRepository.AnnotatedAggregateRepository.eventSourceModel(Entity<T> model)
CompletableFuture<Void>	AggregateRepository.repairRelationships(Entity<?> aggregate)	Repairs the internal relationship model for a loaded aggregate.
CompletableFuture<Void>	CachingAggregateRepository.repairRelationships(Entity<?> aggregate)
CompletableFuture<Void>	DefaultAggregateRepository.repairRelationships(Entity<?> aggregate)
protected ImmutableAggregateRoot<T>	DefaultAggregateRepository.AnnotatedAggregateRepository.restoreSnapshotId(Object id, Entity<T> snapshot)
protected void	CachingAggregateRepository.updateRelationships(Entity<?> before, Entity<?> after)

Uses of Entity in io.fluxzero.sdk.tracking.handling

Methods in io.fluxzero.sdk.tracking.handling that return Entity

Modifier and Type	Method	Description
Entity<?>	StatefulHandler.StatefulMemberMutation.after()	Returns the value of the after record component.
Entity<?>	StatefulHandler.StatefulMemberMutation.before()	Returns the value of the before record component.
Entity<?>	StatefulHandler.StatefulMemberMessage.getEntity()
Entity<?>	StatefulHandler.StatefulMemberMutation.target()	Returns the value of the target record component.

Constructors in io.fluxzero.sdk.tracking.handling with parameters of type Entity

Modifier	Constructor	Description
protected	StatefulMemberMutation(StatefulHandler.StatefulMember member, Entity<?> target, Entity<?> before, Entity<?> after)	Creates an instance of a StatefulMemberMutation record class.