Package one.microstream.persistence.binary.types

Class BinaryStorer.Default

java.lang.Object

one.microstream.persistence.binary.types.BinaryStorer.Default

All Implemented Interfaces:

BinaryStorer, PersistenceFunction, PersistenceLocalObjectIdRegistry<Binary>, PersistenceObjectIdRequestor<Binary>, PersistenceStoreHandler<Binary>, PersistenceStorer, PersistenceStoring, Storer

Direct Known Subclasses:

BinaryStorer.Eager

Enclosing interface:

BinaryStorer

public static class BinaryStorer.Default
extends Object
implements BinaryStorer, PersistenceStoreHandler<Binary>, PersistenceLocalObjectIdRegistry<Binary>

Default implementation that stores referenced instances only if required (i.e. if they have no OID assigned yet, therefore have not been stored yet, therefore require to be stored). It can be seen as a "lazy" or "on demand" storer as opposed to BinaryStorer.Eager.
For a more differentiated solution between the two simple, but extreme strategies, see PersistenceEagerStoringFieldEvaluator.

Nested Class Summary

Nested classes/interfaces inherited from interface one.microstream.persistence.binary.types.BinaryStorer

BinaryStorer.Creator, BinaryStorer.Default, BinaryStorer.Eager, BinaryStorer.Item

Nested classes/interfaces inherited from interface one.microstream.persistence.types.PersistenceObjectIdRequestor

PersistenceObjectIdRequestor.NoOp<D>

Constructor Summary

Constructors

Constructor	Description
Default()

Method Summary

Modifier and Type	Method	Description
<T> long	apply(T instance)	The "natural" way of handling an instance as defined by the implementation.
<T> long	apply(T instance, PersistenceTypeHandler<Binary,T> localTypeHandler)
<T> long	applyEager(T instance)	A way to signal to the implementation that the passed instance is supposed to be handled eagerly, meaning it shall be handled even if the handling implementation does not deem it necessary. This is needed, for example, to store composition pattern instances without breaking OOP encapsulation concepts.
<T> long	applyEager(T instance, PersistenceTypeHandler<Binary,T> localTypeHandler)
void	clear()	Clears all internal state regarding collected data and/or registered skips.
Object	commit()	Ends the data collection process and causes all collected data to be persisted.
long	currentCapacity()	Returns the internal state's value significant for its capacity of unique instances.
PersistenceStorer	ensureCapacity(long desiredCapacity)	Ensures that the instance's internal state is prepared for handling an amount of unique instance equal to the passed value.
ObjectSwizzling	getObjectRetriever()
void	iterateMergeableEntries(PersistenceAcceptor iterator)
<T> long	lookupObjectId(T object, PersistenceObjectIdRequestor<Binary> objectIdRequestor, PersistenceTypeHandler<Binary,T> optionalHandler)
long	lookupOid(Object object)
long	maximumCapacity()	The maximum value that Storer.currentCapacity() can reach.
PersistenceObjectManager<Binary>	parentObjectManager()
<T> void	registerEagerOptional(long objectId, T instance, PersistenceTypeHandler<Binary,T> optionalHandler)
<T> void	registerGuaranteed(long objectId, T instance, PersistenceTypeHandler<Binary,T> optionalHandler)
<T> void	registerLazyOptional(long objectId, T instance, PersistenceTypeHandler<Binary,T> optionalHandler)
PersistenceStorer	reinitialize()	Enforces the instance to be initialized, discarding any previous state (clearing it) if necessary.
PersistenceStorer	reinitialize(long initialCapacity)	Enforces the instance to be initialized, discarding any previous state (clearing it) if necessary.
long	size()
boolean	skip(Object instance)	Registers the passed instance to be skipped from the data persisting process.
boolean	skipMapped(Object instance, long objectId)	Registers the passed instance under the passed objectId without persisting its data.
boolean	skipNulled(Object instance)	Registers the passed instance to be skipped from the data persisting process.
long	store(Object root)	Stores the passed instance in any case and all referenced instances of persistable references recursively, but stores referenced instances only if they are newly encountered (e.g.
void	storeAll(Iterable<?> instances)	Convenience method to PersistenceStoring.store(Object) all instances of an Iterable type, usually a collection. The passed instance itself is NOT stored. Note that this method does not return an array of objectIds, since the amount of instances supplied by the passed Iterable cannot be known until after all instances have been stored and the memory and performance overhead to collect them dynamically would not be worth it in most cases since the returned array is hardly ever needed.
long[]	storeAll(Object... instances)	Convenience method to PersistenceStoring.store(Object) multiple instances.
void	synchRebuildStoreItems()
void	synchRebuildStoreItems(int newLength)
<T> BinaryStorer.Item	synchRegisterObjectId(T instance, PersistenceTypeHandler<Binary,? super T> typeHandler, long objectId)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface one.microstream.persistence.types.Storer

isEmpty

Constructor Details

Default

public Default()

Method Details

parentObjectManager

public final PersistenceObjectManager<Binary> parentObjectManager()

Specified by:

parentObjectManager in interface PersistenceLocalObjectIdRegistry<Binary>

getObjectRetriever

public final ObjectSwizzling getObjectRetriever()

Specified by:

getObjectRetriever in interface PersistenceStoreHandler<Binary>

maximumCapacity

public final long maximumCapacity()

Description copied from interface: Storer

The maximum value that Storer.currentCapacity() can reach. For more explanation on the exact meaning of the capacity, see there.

Specified by:

maximumCapacity in interface BinaryStorer

Specified by:

maximumCapacity in interface Storer

Returns:

the maximum of the implementation-specific "capacity" value.

currentCapacity

public final long currentCapacity()

Description copied from interface: Storer

Returns the internal state's value significant for its capacity of unique instances. Note that the exact meaning of this value is implementation dependant, e.g. it might just be a hash table's length, while the actual amount of unique instances that can be handled by that hash table might be much higher (infinite).

Specified by:

currentCapacity in interface BinaryStorer

Specified by:

currentCapacity in interface Storer

Returns:

the current implementation-specific "capacity" value.

size

public final long size()

Specified by:

size in interface Storer

Returns:

the amount of unique instances / references that have already been registered by thisStorer instance. This includes both instances encountered during the data collection process and instances that have explicitely been registered to be skipped.

See Also:

Storer.skip(Object), Storer.skipMapped(Object,long)

reinitialize

public PersistenceStorer reinitialize()

Description copied from interface: PersistenceStorer

Enforces the instance to be initialized, discarding any previous state (clearing it) if necessary.

Specified by:

reinitialize in interface BinaryStorer

Specified by:

reinitialize in interface PersistenceStorer

Specified by:

reinitialize in interface Storer

Returns:

this.

reinitialize

public PersistenceStorer reinitialize(long initialCapacity)

Description copied from interface: PersistenceStorer

Enforces the instance to be initialized, discarding any previous state (clearing it) if necessary.

Specified by:

reinitialize in interface BinaryStorer

Specified by:

reinitialize in interface PersistenceStorer

Specified by:

reinitialize in interface Storer

Returns:

this.

clear

public void clear()

Description copied from interface: Storer

Clears all internal state regarding collected data and/or registered skips.

Specified by:

clear in interface Storer

ensureCapacity

public PersistenceStorer ensureCapacity(long desiredCapacity)

Description copied from interface: PersistenceStorer

Ensures that the instance's internal state is prepared for handling an amount of unique instance equal to the passed value. Note that is explicitly does not have to mean that the instance's internal state actually reserves as much space, only makes a best effort to prepare for that amount. Example: an internal hash table's hash length might still remain at 2^30, despite the passed value being much higher.

Specified by:

ensureCapacity in interface BinaryStorer

Specified by:

ensureCapacity in interface PersistenceStorer

Specified by:

ensureCapacity in interface Storer

Parameters:

desiredCapacity - the amount of unique instances that this instance shall prepare to handle.

Returns:

this

apply

public <T> long apply(T instance)

Description copied from interface: PersistenceStoreHandler

The "natural" way of handling an instance as defined by the implementation.

Specified by:

apply in interface PersistenceFunction

Specified by:

apply in interface PersistenceStoreHandler<Binary>

Parameters:

instance - the instance to which the function shall be applied.

Returns:

the object ID (OID) that is associated with the passed instance.

apply

public <T> long apply(T instance, PersistenceTypeHandler<Binary,T> localTypeHandler)

Specified by:

apply in interface PersistenceStoreHandler<Binary>

applyEager

public final <T> long applyEager(T instance)

Description copied from interface: PersistenceStoreHandler

A way to signal to the implementation that the passed instance is supposed to be handled eagerly, meaning it shall be handled even if the handling implementation does not deem it necessary.
This is needed, for example, to store composition pattern instances without breaking OOP encapsulation concepts.

Specified by:

applyEager in interface PersistenceStoreHandler<Binary>

applyEager

public <T> long applyEager(T instance, PersistenceTypeHandler<Binary,T> localTypeHandler)

Specified by:

applyEager in interface PersistenceStoreHandler<Binary>

store

public final long store(Object root)

Description copied from interface: PersistenceStoring

Stores the passed instance in any case and all referenced instances of persistable references recursively, but stores referenced instances only if they are newly encountered (e.g. don't have an id associated with them in the object registry, yet and are therefore required to be handled). This is useful for the common case of just storing an updated instance and potentially newly created instances along with it while skipping all existing (and normally unchanged) referenced instances.

Specified by:

store in interface PersistenceStoring

Parameters:

root - the root instance of the subgraph of required instances to be stored.

Returns:

the object id representing the passed instance.

storeAll

public final long[] storeAll(Object... instances)

Description copied from interface: PersistenceStoring

Convenience method to PersistenceStoring.store(Object) multiple instances. The passed array (maybe implicitely created by the compiler) itself is NOT stored.

Specified by:

storeAll in interface PersistenceStoring

Parameters:

instances - multiple root instances of the subgraphs of required instances to be stored.

Returns:

an array containing the object ids representing the passed instances.

storeAll

public void storeAll(Iterable<?> instances)

Description copied from interface: PersistenceStoring

Convenience method to PersistenceStoring.store(Object) all instances of an Iterable type, usually a collection.
The passed instance itself is NOT stored.
Note that this method does not return an array of objectIds, since the amount of instances supplied by the passed Iterable cannot be known until after all instances have been stored and the memory and performance overhead to collect them dynamically would not be worth it in most cases since the returned array is hardly ever needed. If it should be needed, the desired behavior can be easily achieved with a tiny custom-made utility method.

Specified by:

storeAll in interface PersistenceStoring

Parameters:

instances - multiple root instances of the subgraphs of required instances to be stored.

iterateMergeableEntries

public void iterateMergeableEntries(PersistenceAcceptor iterator)

Specified by:

iterateMergeableEntries in interface PersistenceLocalObjectIdRegistry<Binary>

commit

public final Object commit()

Description copied from interface: Storer

Ends the data collection process and causes all collected data to be persisted.

This is an atomatic all-or-nothing operation: either all collected data will be persisted successfully, or non of it will be persisted. Partially persisted data will be reverted / rolled back in case of a failure.

Specified by:

commit in interface Storer

Returns:

some kind of status information, potentially null.

lookupOid

public final long lookupOid(Object object)

lookupObjectId

public final <T> long lookupObjectId(T object, PersistenceObjectIdRequestor<Binary> objectIdRequestor, PersistenceTypeHandler<Binary,T> optionalHandler)

Specified by:

lookupObjectId in interface PersistenceLocalObjectIdRegistry<Binary>

registerGuaranteed

public final <T> void registerGuaranteed(long objectId, T instance, PersistenceTypeHandler<Binary,T> optionalHandler)

Specified by:

registerGuaranteed in interface PersistenceObjectIdRequestor<Binary>

registerLazyOptional

public <T> void registerLazyOptional(long objectId, T instance, PersistenceTypeHandler<Binary,T> optionalHandler)

Specified by:

registerLazyOptional in interface PersistenceObjectIdRequestor<Binary>

registerEagerOptional

public <T> void registerEagerOptional(long objectId, T instance, PersistenceTypeHandler<Binary,T> optionalHandler)

Specified by:

registerEagerOptional in interface PersistenceObjectIdRequestor<Binary>

skipMapped

public final boolean skipMapped(Object instance, long objectId)

Description copied from interface: Storer

Registers the passed instance under the passed objectId without persisting its data.

This skip means that if the passed instance is encountered while collecting data to be persisted, its data will NOT be collected. References to the passed instance will be persisted as the passed objectId.

Warning:
This method can be very useful to rearrange object graphs on the persistence level, but it can also cause inconsistencies if not used perfectly correctly.
It is strongly advised to use one of the following alternatives instead: Storer.skip(Object)Storer.skipNulled(Object)

Specified by:

skipMapped in interface Storer

Parameters:

instance - the instance / reference to be skipped.

objectId - the objectId to be used as a reference to the skipped instance.

Returns:

true if the instance has been newly registered, false if it already was.

See Also:

Storer.skip(Object), Storer.skipNulled(Object)

skip

public final boolean skip(Object instance)

Description copied from interface: Storer

Registers the passed instance to be skipped from the data persisting process.

This skip means that if the passed instance is encountered while collecting data to be persisted, its data will NOT be collected. If the instance is already registered under a certain object id at the used PersistenceObjectRegistry, then is associated object id will be used. Otherwise, the null-Id will be used, effectively "nulling out" all references to this instance on the persistent level.
The latter behavior is exactly the same as Storer.skipNulled(Object).

Specified by:

skip in interface Storer

Parameters:

instance - the instance / reference to be skipped.

Returns:

true if the instance has been newly registered, false if it already was.

See Also:

Storer.skipNulled(Object), Storer.skipMapped(Object,long)

skipNulled

public final boolean skipNulled(Object instance)

Description copied from interface: Storer

Registers the passed instance to be skipped from the data persisting process.

This skip means that if the passed instance is encountered while collecting data to be persisted, its data will NOT be collected. References to this instance will always be persisted as null, no matter if the instance is already registered for a certain object id at the used PersistenceObjectRegistryor not.
To make the skipping consider existing object id registrations, use Storer.skip(Object).

Specified by:

skipNulled in interface Storer

Parameters:

instance - the instance / reference to be skipped by using .

Returns:

true if the instance has been newly registered, false if it already was.

See Also:

Storer.skip(Object), Storer.skipMapped(Object,long)

synchRegisterObjectId

public final <T> BinaryStorer.Item synchRegisterObjectId(T instance, PersistenceTypeHandler<Binary,? super T> typeHandler, long objectId)

synchRebuildStoreItems

public final void synchRebuildStoreItems()

synchRebuildStoreItems

public final void synchRebuildStoreItems(int newLength)