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

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.

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 an aggregate in a domain model.

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	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<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, 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, 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<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()
protected Entity<T>	ModifiableAggregateRoot.commit(boolean async)
Entity<T>	ModifiableEntity.commit()
Entity<T>	NoOpEntity.commit()
Entity<T>	SideEffectFreeEntity.commit()
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 action.
static <T> Entity<T>	ModifiableAggregateRoot.load(Object aggregateId, Supplier<Entity<T>> loader, boolean commitInBatch, EventPublication eventPublication, EventPublicationStrategy publicationStrategy, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)
default Entity<?>	AggregateRoot.parent()
Entity<?>	DelegatingEntity.parent()
Entity<?>	Entity.parent()	Retrieves the parent entity of the current entity.
Entity<?>	ModifiableEntity.parent()
Entity<?>	NoOpEntity.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()
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>	LazyAggregateRoot.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>	LazyAggregateRoot.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.
Collection<? extends Entity<?>>	DelegatingEntity.entities()
Collection<? extends Entity<?>>	Entity.entities()	Retrieves child entities of this entity.
Collection<? extends Entity<?>>	LazyAggregateRoot.entities()
Collection<? extends Entity<?>>	ModifiableAggregateRoot.entities()
Collection<? extends Entity<?>>	ModifiableEntity.entities()
Collection<? extends Entity<?>>	NoOpEntity.entities()
default <C> Optional<Entity<C>>	Entity.getEntity(Object entityId)	Retrieves an entity based on the provided entity ID.
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<HandlerInvoker>	DefaultEntityHelper.applyInvoker(DeserializingMessage event, Entity<?> entity, boolean searchChildren)	Finds a handler method annotated with @Apply and wraps it to preserve apply context flags.
default Optional<HandlerInvoker>	EntityHelper.applyInvoker(DeserializingMessage message, Entity<?> entity)	Returns an invoker that can apply the given event to the provided entity.
Optional<HandlerInvoker>	EntityHelper.applyInvoker(DeserializingMessage message, Entity<?> entity, boolean searchChildren)	Returns an invoker for applying the event to the entity, optionally checking nested entities.
<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<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.
default Set<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)
Stream<? extends ImmutableEntity<?>>	AnnotatedEntityHolder.getEntities(Entity<?> parent)	Returns the set of ImmutableEntity instances that are defined at the member location within the specified parent entity.
CompletableFuture<?>	ModifiableAggregateRoot.CommitHandler.handle(Entity<?> model, List<AppliedEvent> unpublished, Entity<?> beforeUpdate)
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.
protected boolean	EntityParameterResolver.isAssignable(Parameter parameter, Entity<?> entity)	Returns true if the entity or any of its parents match the expected parameter type.
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.
protected boolean	EntityParameterResolver.matches(Parameter parameter, Entity<?> entity)	Returns true if the entity or any of its parents match the expected parameter type.
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.
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)

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

Modifier and Type	Method	Description
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 action.
static <T> Entity<T>	ModifiableAggregateRoot.load(Object aggregateId, Supplier<Entity<T>> loader, boolean commitInBatch, EventPublication eventPublication, EventPublicationStrategy publicationStrategy, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)
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)
	MessageWithEntity(Object payload, Entity<?> entity)
protected	ModifiableAggregateRoot(Entity<T> delegate, boolean commitInBatch, EventPublication eventPublication, EventPublicationStrategy publicationStrategy, EntityHelper entityHelper, Serializer serializer, DispatchInterceptor dispatchInterceptor, ModifiableAggregateRoot.CommitHandler commitHandler)
	ModifiableEntity(Entity<T> delegate, ModifiableAggregateRoot<?> root)
	SideEffectFreeEntity(Entity<T> delegate)

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
<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.

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.

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>	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)

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

Modifier and Type	Method	Description
protected CompletableFuture<?>	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 void	CachingAggregateRepository.updateRelationships(Entity<?> before, Entity<?> after)