PersistenceObjectRegistry (MicroStream API)

All Superinterfaces:

one.microstream.util.Cloneable<PersistenceObjectRegistry>, PersistenceObjectIdLookup, PersistenceObjectLookup, PersistenceSwizzlingLookup

All Known Implementing Classes:

DefaultObjectRegistry
```
public interface PersistenceObjectRegistry
extends PersistenceSwizzlingLookup, one.microstream.util.Cloneable<PersistenceObjectRegistry>
```
A registry type for biunique associations of arbitrary objects with ids.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`long`	`capacity()`
`void`	`clear()` Clears all entries except those that are essential for a correctly executed program (e.g.
`void`	`clearAll()` Clears all entries, including those that are essential for a correctly executed program (e.g.
`PersistenceObjectRegistry`	`Clone()` Useful for `PersistenceContextDispatcher`.
`boolean`	`consolidate()` Consolidate internal data structures, e.g.
`boolean`	`containsObjectId(long objectId)`
`one.microstream.collections.types.XGettingTable<String,? extends one.microstream.hashing.HashStatistics>`	`createHashStatistics()`
`boolean`	`ensureCapacity(long capacity)` Makes sure the internal storage structure is prepared to provide a `capacity()` of at least the passed capacity value.
`float`	`hashDensity()`
`int`	`hashRange()`
`boolean`	`isEmpty()`
`boolean`	`isValid(long objectId, Object object)`
`<A extends PersistenceAcceptor> A`	`iterateEntries(A acceptor)`
`Object`	`lookupObject(long objectId)`
`long`	`lookupObjectId(Object object)`
`long`	`minimumCapacity()`
`static DefaultObjectRegistry`	`New()`
`Object`	`optionalRegisterObject(long objectId, Object object)`
`boolean`	`registerConstant(long objectId, Object constant)`
`boolean`	`registerObject(long objectId, Object object)`
`boolean`	`setConfiguration(float hashDensity, long minimumCapacity)`
`boolean`	`setHashDensity(float hashDensity)`
`boolean`	`setMinimumCapacity(long minimumCapacity)`
`long`	`size()`
`void`	`truncate()` Truncates all entries except those that are essential for a correctly executed program (e.g.
`void`	`truncateAll()` Truncates all entries, including those that are essential for a correctly executed program (e.g.
`void`	`validate(long objectId, Object object)`

- Method Detail
  - Clone
```
PersistenceObjectRegistry Clone()
```
    Useful for PersistenceContextDispatcher.
    
    Specified by:
    
    Clone in interface one.microstream.util.Cloneable<PersistenceObjectRegistry>
    
    Returns:
    
    A Clone of this instance as described in Cloneable.
  - lookupObjectId
```
long lookupObjectId(Object object)
```
    Specified by:
    
    lookupObjectId in interface PersistenceObjectIdLookup
  - lookupObject
```
Object lookupObject(long objectId)
```
    Specified by:
    
    lookupObject in interface PersistenceObjectLookup
  - isValid
```
boolean isValid(long objectId,
                Object object)
```
  - validate
```
void validate(long objectId,
              Object object)
```
  - containsObjectId
```
boolean containsObjectId(long objectId)
```
  - iterateEntries
```
<A extends PersistenceAcceptor> A iterateEntries(A acceptor)
```
  - size
```
long size()
```
  - isEmpty
```
boolean isEmpty()
```
  - hashRange
```
int hashRange()
```
  - hashDensity
```
float hashDensity()
```
  - minimumCapacity
```
long minimumCapacity()
```
  - capacity
```
long capacity()
```
    Returns:
    
    the current size potential before a (maybe costly) rebuild becomes necessary.
  - setHashDensity
```
boolean setHashDensity(float hashDensity)
```
  - setMinimumCapacity
```
boolean setMinimumCapacity(long minimumCapacity)
```
  - setConfiguration
```
boolean setConfiguration(float hashDensity,
                         long minimumCapacity)
```
  - ensureCapacity
```
boolean ensureCapacity(long capacity)
```
    Makes sure the internal storage structure is prepared to provide a capacity() of at least the passed capacity value.
    
    Parameters:
    
    capacity - the new minimum capacity
    
    Returns:
    
    whether a rebuild of internal storage structures was necessary.
  - registerObject
```
boolean registerObject(long objectId,
                       Object object)
```
  - optionalRegisterObject
```
Object optionalRegisterObject(long objectId,
                              Object object)
```
  - registerConstant
```
boolean registerConstant(long objectId,
                         Object constant)
```
  - consolidate
```
boolean consolidate()
```
    Consolidate internal data structures, e.g. by removing orphan entries and empty hash chains. Depending on the implementation and the size of the registry, this can take a considerable amount of time.
    
    Returns:
    
    whether a rebuild was required.
  - clear
```
void clear()
```
    Clears all entries except those that are essential for a correctly executed program (e.g. constants).
    Clearing means to leave the current capacity as it is and just to actually clear its entries.
    NOTE:
    This method is currently only intended to be used for testing since calling it can cause inconsistencies if there still exist uncleared lazy references.
  - clearAll
```
void clearAll()
```
    Clears all entries, including those that are essential for a correctly executed program (e.g. constants), effectively leaving a completely empty registry.
    Clearing means to leave the current capacity as it is and just to actually clear its entries.
    NOTE:
    This method is currently only intended to be used for testing since calling it can cause inconsistencies if there still exist uncleared lazy references.
  - truncate
```
void truncate()
```
    Truncates all entries except those that are essential for a correctly executed program (e.g. constants). Truncating means to quickly empty the registry by reinitializing the internal storage structures with a new and minimal capacity.
    NOTE:
    This method is currently only intended to be used for testing since calling it can cause inconsistencies if there still exist uncleared lazy references.
  - truncateAll
```
void truncateAll()
```
    Truncates all entries, including those that are essential for a correctly executed program (e.g. constants), effectively leaving a completely empty registry.
    Truncating means to quickly empty the registry by reinitializing the internal storage structures with a new and minimal capacity.
    NOTE:
    This method is currently only intended to be used for testing since calling it can cause inconsistencies if there still exist uncleared lazy references.
  - createHashStatistics
```
one.microstream.collections.types.XGettingTable<String,? extends one.microstream.hashing.HashStatistics> createHashStatistics()
```
  - New
```
static DefaultObjectRegistry New()
```

Interface PersistenceObjectRegistry

Method Summary

Method Detail

Clone

lookupObjectId

lookupObject

isValid

validate

containsObjectId

iterateEntries

size

isEmpty

hashRange

hashDensity

minimumCapacity

capacity

setHashDensity

setMinimumCapacity

setConfiguration

ensureCapacity

registerObject

optionalRegisterObject

registerConstant

consolidate

clear

clearAll

truncate

truncateAll

createHashStatistics

New