RecordBasedRepository (server 1.8.2 API)

java.lang.Object
- io.spine.server.entity.Repository<I,E>
- - io.spine.server.entity.RecordBasedRepository<I,E,S>

Type Parameters:

I - the type of entity identifiers

E - the type of stored entities

S - the type of entity state messages

All Implemented Interfaces:

io.spine.logging.Logging, Closeable, java.lang.AutoCloseable

Direct Known Subclasses:

DefaultRecordBasedRepository
```
public abstract class RecordBasedRepository<I,E extends Entity<I,S>,S extends io.spine.base.EntityState>
extends Repository<I,E>
```
The base class for repositories that store entities as records.
Such a repository is backed by RecordStorage. Entity states are stored as EntityRecords.

Constructor Summary

Constructors
Modifier Constructor and Description

protected RecordBasedRepository()
Creates a new instance.

Constructors
Modifier	Constructor and Description
`protected`	`RecordBasedRepository()` Creates a new instance.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`<T extends TransactionalEntity<I,S,?>> void`	`applyMigration(I id, Migration<I,T,S> migration)` Applies a given `Migration` to an entity with the given ID.
`<T extends TransactionalEntity<I,S,?>> void`	`applyMigration(java.util.Set<I> ids, Migration<I,T,S> migration)` Applies a `Migration` to several entities in batch.
`E`	`create(I id)` Create a new entity instance with its default state.
`protected RecordStorage<I>`	`createStorage()` Creates the storage for this repository.
`protected abstract EntityFactory<E>`	`entityFactory()` Obtains `EntityFactory` associated with this repository.
`java.util.Optional<E>`	`find(I id)` Finds an entity with the passed ID.
`java.util.Iterator<E>`	`find(io.spine.client.TargetFilters filters, io.spine.client.ResponseFormat format)` Finds the entities passing the given filters and applies the given `FieldMask` to the results.
`java.util.Optional<E>`	`findActive(I id)` Finds an entity with the passed ID even if the entity is active.
`protected E`	`findOrCreate(I id)` Loads an entity by the passed ID or creates a new one, if the entity was not found.
`java.util.Iterator<E>`	`iterator(java.util.function.Predicate<E> filter)` Returns an iterator over the entities managed by the repository that match the passed filter.
`java.util.Iterator<E>`	`loadAll(java.lang.Iterable<I> ids, com.google.protobuf.FieldMask fieldMask)` Loads all the entities in this repository with IDs, contained within the passed `ids` values.
`java.util.Iterator<E>`	`loadAll(io.spine.client.ResponseFormat format)`
`protected RecordStorage<I>`	`recordStorage()` Ensures that the repository has the storage.
`protected abstract StorageConverter<I,E,S>`	`storageConverter()` Obtains `StorageConverter` associated with this repository.
`void`	`store(java.util.Collection<E> entities)` Stores Entities in bulk.
`void`	`store(E entity)` Stores the passed object.
`protected E`	`toEntity(io.spine.server.entity.EntityRecord record)` Converts the passed record into an entity.

Methods inherited from class io.spine.server.entity.Repository
checkStorage, close, context, entityClass, entityStateType, eventFilter, hasContext, idClass, index, isOpen, isRegistered, onRegistered, open, storage, storageAssigned

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.spine.server.Closeable
checkOpen

Methods inherited from interface io.spine.logging.Logging
_config, _debug, _error, _fine, _finer, _finest, _info, _severe, _trace, _warn, debugLevel, errorLevel, logger, loggerFor

- Constructor Detail
  - RecordBasedRepository
```
protected RecordBasedRepository()
```
    Creates a new instance.
- Method Detail
  - entityFactory
```
protected abstract EntityFactory<E> entityFactory()
```
    Obtains EntityFactory associated with this repository.
  - storageConverter
```
protected abstract StorageConverter<I,E,S> storageConverter()
```
    Obtains StorageConverter associated with this repository.
  - recordStorage
```
protected RecordStorage<I> recordStorage()
```
    Ensures that the repository has the storage.
    
    Returns:
    
    storage instance
    
    Throws:
    
    java.lang.IllegalStateException - if the storage is null
  - create
```
@OverridingMethodsMustInvokeSuper
public E create(I id)
```
    Description copied from class: Repository
    
    Create a new entity instance with its default state.
    
    Specified by:
    
    create in class Repository<I,E extends Entity<I,S>>
    
    Parameters:
    
    id - the id of the entity
    
    Returns:
    
    new entity instance
  - store
```
public void store(E entity)
```
    Description copied from class: Repository
    
    Stores the passed object.
    Note: The storage must be assigned before calling this method.
    
    Specified by:
    
    store in class Repository<I,E extends Entity<I,S>>
    
    Parameters:
    
    entity - an instance to store
  - iterator
```
public java.util.Iterator<E> iterator(java.util.function.Predicate<E> filter)
```
    Description copied from class: Repository
    
    Returns an iterator over the entities managed by the repository that match the passed filter.
    The returned iterator does not support removal.
    Iteration through entities is performed by loading them one by one.
    
    Overrides:
    
    iterator in class Repository<I,E extends Entity<I,S>>
  - applyMigration
```
@Experimental
public final <T extends TransactionalEntity<I,S,?>> void applyMigration(I id,
                                                                                      Migration<I,T,S> migration)
```
    Applies a given Migration to an entity with the given ID.
    The operation is performed in three steps:
    1. Load an entity by the given ID.
    2. Transform it through the migration operation.
    3. Store the entity back to the repository or delete it depending on the migration configuration.
    This operation is only supported for entities that are transactional.
    Throws:
    
    java.lang.IllegalArgumentException - if the entity with the given ID is not found in the repository
    
    java.lang.IllegalStateException - if the repository manages a non-transactional entity type
    
    See Also:
    
    Migration, the batch version of the method
  - applyMigration
```
@Experimental
public final <T extends TransactionalEntity<I,S,?>> void applyMigration(java.util.Set<I> ids,
                                                                                      Migration<I,T,S> migration)
```
    Applies a Migration to several entities in batch.
    The operation is performed in three steps:
    1. Load entities by the given IDs.
    2. Transform each entity through the migration operation.
    3. Store the entities which are not configured to be deleted by the Migration back to the repository.
    This operation is only supported for entities that are transactional.
    Throws:
    
    java.lang.IllegalStateException - if the repository manages a non-transactional entity type
    
    See Also:
    
    Migration
  - createStorage
```
protected RecordStorage<I> createStorage()
```
    Description copied from class: Repository
    
    Creates the storage for this repository.
    Default implementations use Repository.defaultStorageFactory() invoking its method which creates a storage compatible with the repository.
    Overwrite this method for creating a custom implementation of Storage.
    
    Specified by:
    
    createStorage in class Repository<I,E extends Entity<I,S>>
    
    Returns:
    
    the created storage instance
  - store
```
public void store(java.util.Collection<E> entities)
```
    Stores Entities in bulk.
    Note: The storage must be assigned before calling this method.
    
    Parameters:
    
    entities - the Entities to store
  - find
```
public java.util.Optional<E> find(I id)
```
    Finds an entity with the passed ID.
    
    Specified by:
    
    find in class Repository<I,E extends Entity<I,S>>
    
    Parameters:
    
    id - the ID of the entity to find
    
    Returns:
    
    the entity or Optional.empty() if there is no entity with such ID
  - findActive
```
public java.util.Optional<E> findActive(I id)
```
    Finds an entity with the passed ID even if the entity is active.
    
    Parameters:
    
    id - the ID of the entity to find
    
    Returns:
    
    the entity or Optional.empty() if there is no entity with such ID, or the entity is not active
  - findOrCreate
```
protected E findOrCreate(I id)
```
    Loads an entity by the passed ID or creates a new one, if the entity was not found.
    An entity will be loaded whether its active or not.
    The new entity is created if and only if there is no record with the corresponding ID.
    
    Parameters:
    
    id - the ID of the entity to load
    
    Returns:
    
    the entity with the specified ID
  - loadAll
```
public java.util.Iterator<E> loadAll(io.spine.client.ResponseFormat format)
```
  - loadAll
```
public java.util.Iterator<E> loadAll(java.lang.Iterable<I> ids,
                                     com.google.protobuf.FieldMask fieldMask)
```
    Loads all the entities in this repository with IDs, contained within the passed ids values.
    Provides a convenience wrapper around multiple invocations of RecordBasedRepository.find(Object). Descendants may optimize the execution of this method, choosing the most suitable way for the particular storage engine used.
    The result only contains those entities which IDs are contained inside the passed ids. The resulting collection is always returned with no null values.
    The order of objects in the result is not guaranteed to be the same as the order of IDs passed as argument.
    If the IDs contain duplicates, the result may also contain duplicates depending on a particular implementation.
    The resulting entity state must be valid in terms of (required), (required_fields), and (goes).with options after the mask is applied. Otherwise, an InvalidEntityStateException is thrown.
    Note: The storage must be assigned before calling this method.
    
    Parameters:
    
    ids - entity IDs to search for
    
    fieldMask - the entity state fields to load
    
    Returns:
    
    all the entities in this repository with the IDs matching the given Iterable
  - find
```
public java.util.Iterator<E> find(io.spine.client.TargetFilters filters,
                                  io.spine.client.ResponseFormat format)
```
    Finds the entities passing the given filters and applies the given FieldMask to the results.
    A number of elements to retrieve can be limited to a certain number. The order of the resulting entities is specified by the OrderBy.
    Field mask is applied according to FieldMask specs.
    The field paths in the entity column field filters are specified to contain a single path member - the name of the entity column.
    The filtering process is delegated to the underlying RecordStorage.
    Note: The storage must be assigned before calling this method.
    
    Parameters:
    
    filters - the entity filters
    
    format - the expected format of the query response
    
    Returns:
    
    all the entities in this repository passed through the filters
    
    See Also:
    
    EntityQuery
  - toEntity
```
@OverridingMethodsMustInvokeSuper
protected E toEntity(io.spine.server.entity.EntityRecord record)
```
    Converts the passed record into an entity.

Class RecordBasedRepository<I,E extends Entity<I,S>,S extends io.spine.base.EntityState>

Constructor Summary

Method Summary

Methods inherited from class io.spine.server.entity.Repository

Methods inherited from class java.lang.Object

Methods inherited from interface io.spine.server.Closeable

Methods inherited from interface io.spine.logging.Logging

Constructor Detail

RecordBasedRepository

Method Detail

entityFactory

storageConverter

recordStorage

create

store

iterator

applyMigration

applyMigration

createStorage

store

find

findActive

findOrCreate

loadAll

loadAll

find

toEntity