Package one.microstream.persistence.types

Class PersistenceStorerDeactivatable

java.lang.Object
one.microstream.persistence.types.PersistenceStorerDeactivatable
All Implemented Interfaces:
PersistenceStorer, PersistenceStoring, Storer
public class PersistenceStorerDeactivatable
extends Object
implements PersistenceStorer
A PersistenceStorer implementation that allows switching between the supplied PersistenceStorer instance and a PersistenceStorerDeactivated instance.

  • Constructor Details

  • Method Details

    • setWriteEnabled

      public void setWriteEnabled​(boolean enableWrites)
      Enable or disable writing support.
      Parameters:
      enableWrites - true to enable writing, false to disable.

    • isWriteEnabled

      public boolean isWriteEnabled()
      Check if writing support is enabled.
      Returns:
      true if writes are enabled

    • enableWrites

      public void enableWrites()
      Enable writing support.

    • disableWrites

      public void disableWrites()
      Disable writing support

    • 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 PersistenceStorer
      Specified by:
      reinitialize in interface Storer
      Returns:
      this.

    • store

      public long store​(Object instance)
      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:
      instance - the root instance of the subgraph of required instances to be stored.
      Returns:
      the object id representing the passed instance.

    • 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 PersistenceStorer
      Specified by:
      reinitialize in interface Storer
      Parameters:
      initialCapacity - the amount of unique instances that this instance shall prepare to handle.
      Returns:
      this.

    • commit

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

    • 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 PersistenceStorer
      Specified by:
      ensureCapacity in interface Storer
      Parameters:
      desiredCapacity - the amount of unique instances that this instance shall prepare to handle.
      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

    • storeAll

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

    • skipMapped

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

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

    • skip

      public 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 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 PersistenceObjectRegistry or 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)

    • size

      public long size()
      Specified by:
      size in interface Storer
      Returns:
      the amount of unique instances / references that have already been registered by this Storer 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)

    • isEmpty

      public boolean isEmpty()
      Description copied from interface: Storer
      Queries, whether this Storer instance has no instances / references registered.

      Calling this method is simply an alias for this.size() == 0L.

      Specified by:
      isEmpty in interface Storer
      Returns:
      whether this Storer instance is empty.

    • currentCapacity

      public 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 Storer
      Returns:
      the current implementation-specific "capacity" value.

    • maximumCapacity

      public 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 Storer
      Returns:
      the maximum of the implementation-specific "capacity" value.