AbstractPersistentCollection (Hibernate JavaDocs)

java.lang.Object
- org.hibernate.collection.internal.AbstractPersistentCollection

All Implemented Interfaces:

Serializable, PersistentCollection

Direct Known Subclasses:

PersistentArrayHolder, PersistentBag, PersistentElementHolder, PersistentIdentifierBag, PersistentIndexedElementHolder, PersistentList, PersistentMap, PersistentSet
```
public abstract class AbstractPersistentCollection
extends Object
implements Serializable, PersistentCollection
```
Base class implementing PersistentCollection

See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static interface`	`AbstractPersistentCollection.DelayedOperation` Contract for operations which are part of a collection's operation queue.
`protected class`	`AbstractPersistentCollection.IteratorProxy`
`static interface`	`AbstractPersistentCollection.LazyInitializationWork<T>` TBH not sure why this is public
`protected class`	`AbstractPersistentCollection.ListIteratorProxy`
`protected class`	`AbstractPersistentCollection.ListProxy`
`protected class`	`AbstractPersistentCollection.SetProxy`

Field Summary

Fields
Modifier and Type Field and Description

protected static Object UNKNOWN

Fields
Modifier and Type	Field and Description
`protected static Object`	`UNKNOWN`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`AbstractPersistentCollection()` Not called by Hibernate, but used by non-JDK serialization, eg.
`protected`	`AbstractPersistentCollection(SessionImplementor session)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`afterInitialize()` Called after initializing from cache
`void`	`afterRowInsert(CollectionPersister persister, Object entry, int i)` Called after inserting a row, to fetch the natively generated id
`void`	`beginRead()` Called just before reading any rows from the JDBC result set
`void`	`clearDirty()` Clear the dirty flag, after flushing changes to the database.
`void`	`dirty()` Mark the collection as dirty
`abstract boolean`	`empty()` Is the collection empty? (don't try to initialize the collection)
`boolean`	`endRead()` Called after reading all rows from the JDBC result set
`void`	`forceInitialization()` To be called internally by the session, forcing immediate initialization.
`protected int`	`getCachedSize()`
`Object`	`getIdentifier(Object entry, int i)` Get the identifier of the given collection entry.
`Serializable`	`getKey()` Get the current collection key value
`protected static Collection`	`getOrphans(Collection oldElements, Collection currentElements, String entityName, SessionImplementor session)` Given a collection of entity instances that used to belong to the collection, and a collection of instances that currently belong, return a collection of orphans
`abstract Collection`	`getOrphans(Serializable snapshot, String entityName)` get all "orphaned" elements
`Object`	`getOwner()` Get the owning entity.
`Collection`	`getQueuedOrphans(String entityName)` Get the "queued" orphans
`String`	`getRole()` Get the current role name
`SessionImplementor`	`getSession()` Get the session currently associated with this collection.
`protected Serializable`	`getSnapshot()` Get the current snapshot from the session
`Serializable`	`getStoredSnapshot()` Get the snapshot cached by the collection instance
`Object`	`getValue()` Return the user-visible collection (or array) instance
`boolean`	`hasQueuedOperations()` Does this instance have any "queued" operations?
`static void`	`identityRemove(Collection list, Object entityInstance, String entityName, SessionImplementor session)` Removes entity entries that have an equal identifier with the incoming entity instance
`protected void`	`initialize(boolean writing)` Initialize the collection, if possible, wrapping any exceptions in a runtime exception
`protected boolean`	`isClearQueueEnabled()` Is this collection in a state that would allow us to "queue" clear? This is a special case, because of orphan delete.
`boolean`	`isDirectlyAccessible()` Could the application possibly have a direct reference to the underlying collection implementation?
`boolean`	`isDirty()` Is the collection dirty? Note that this is only reliable during the flush cycle, after the collection elements are dirty checked against the snapshot.
`protected boolean`	`isOperationQueueEnabled()` Is this collection in a state that would allow us to "queue" operations?
`protected boolean`	`isPutQueueEnabled()` Is this collection in a state that would allow us to "queue" puts? This is a special case, because of orphan delete.
`boolean`	`isRowUpdatePossible()` Can each element in the collection be mapped unequivocally to a single row in the database? Generally bags and sets are the only collections that cannot be.
`boolean`	`isUnreferenced()` Is the collection unreferenced?
`boolean`	`needsRecreate(CollectionPersister persister)` Do we need to completely recreate this collection when it changes?
`protected void`	`performQueuedOperations()` After reading all existing elements from the database, add the queued elements to the underlying collection.
`void`	`postAction()` After flushing, clear any "queued" additions, since the database state is now synchronized with the memory state.
`void`	`preInsert(CollectionPersister persister)` Called before inserting rows, to ensure that any surrogate keys are fully generated
`protected void`	`prepareForPossibleLoadingOutsideTransaction()`
`Iterator`	`queuedAdditionIterator()` Iterator over the "queued" additions
`protected void`	`queueOperation(AbstractPersistentCollection.DelayedOperation operation)` Queue an addition
`protected void`	`read()` Called by any read-only method of the collection interface
`protected Object`	`readElementByIndex(Object index)`
`protected Boolean`	`readElementExistence(Object element)`
`protected Boolean`	`readIndexExistence(Object index)`
`protected boolean`	`readSize()` Called by the `Collection.size()` method
`boolean`	`setCurrentSession(SessionImplementor session)` Associate the collection with the given session.
`protected void`	`setDirectlyAccessible(boolean directlyAccessible)`
`protected void`	`setInitialized()`
`void`	`setOwner(Object owner)` Set the reference to the owning entity
`void`	`setSnapshot(Serializable key, String role, Serializable snapshot)` After flushing, re-init snapshot state.
`boolean`	`unsetSession(SessionImplementor currentSession)` Disassociate this collection from the given session.
`boolean`	`wasInitialized()` Is this instance initialized?
`protected void`	`write()` Called by any writer method of the collection interface

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

Methods inherited from interface org.hibernate.collection.spi.PersistentCollection
beforeInitialize, disassemble, entries, entryExists, equalsSnapshot, getDeletes, getElement, getIndex, getSnapshot, getSnapshotElement, initializeFromCache, isSnapshotEmpty, isWrapper, needsInserting, needsUpdating, readFrom

- Field Detail
  - UNKNOWN
```
protected static final Object UNKNOWN
```
- Constructor Detail
  - AbstractPersistentCollection
```
public AbstractPersistentCollection()
```
    Not called by Hibernate, but used by non-JDK serialization, eg. SOAP libraries.
  - AbstractPersistentCollection
```
protected AbstractPersistentCollection(SessionImplementor session)
```
- Method Detail
  - getRole
```
public final String getRole()
```
    Description copied from interface: PersistentCollection
    
    Get the current role name
    
    Specified by:
    
    getRole in interface PersistentCollection
    
    Returns:
    the collection role name
  - getKey
```
public final Serializable getKey()
```
    Description copied from interface: PersistentCollection
    
    Get the current collection key value
    
    Specified by:
    
    getKey in interface PersistentCollection
    
    Returns:
    the current collection key value
  - isUnreferenced
```
public final boolean isUnreferenced()
```
    Description copied from interface: PersistentCollection
    
    Is the collection unreferenced?
    
    Specified by:
    
    isUnreferenced in interface PersistentCollection
    
    Returns:
    true if the collection is no longer referenced by an owner
  - isDirty
```
public final boolean isDirty()
```
    Description copied from interface: PersistentCollection
    
    Is the collection dirty? Note that this is only reliable during the flush cycle, after the collection elements are dirty checked against the snapshot.
    
    Specified by:
    
    isDirty in interface PersistentCollection
    
    Returns:
    true if the collection is dirty
  - clearDirty
```
public final void clearDirty()
```
    Description copied from interface: PersistentCollection
    
    Clear the dirty flag, after flushing changes to the database.
    
    Specified by:
    
    clearDirty in interface PersistentCollection
  - dirty
```
public final void dirty()
```
    Description copied from interface: PersistentCollection
    
    Mark the collection as dirty
    
    Specified by:
    
    dirty in interface PersistentCollection
  - getStoredSnapshot
```
public final Serializable getStoredSnapshot()
```
    Description copied from interface: PersistentCollection
    
    Get the snapshot cached by the collection instance
    
    Specified by:
    
    getStoredSnapshot in interface PersistentCollection
    
    Returns:
    The internally stored snapshot state
  - empty
```
public abstract boolean empty()
```
    Description copied from interface: PersistentCollection
    
    Is the collection empty? (don't try to initialize the collection)
    
    Specified by:
    
    empty in interface PersistentCollection
    
    Returns:
    false if the collection is non-empty; true otherwise.
  - read
```
protected final void read()
```
    Called by any read-only method of the collection interface
  - readSize
```
protected boolean readSize()
```
    Called by the Collection.size() method
  - readIndexExistence
```
protected Boolean readIndexExistence(Object index)
```
  - readElementExistence
```
protected Boolean readElementExistence(Object element)
```
  - readElementByIndex
```
protected Object readElementByIndex(Object index)
```
  - getCachedSize
```
protected int getCachedSize()
```
  - write
```
protected final void write()
```
    Called by any writer method of the collection interface
  - isOperationQueueEnabled
```
protected boolean isOperationQueueEnabled()
```
    Is this collection in a state that would allow us to "queue" operations?
  - isPutQueueEnabled
```
protected boolean isPutQueueEnabled()
```
    Is this collection in a state that would allow us to "queue" puts? This is a special case, because of orphan delete.
  - isClearQueueEnabled
```
protected boolean isClearQueueEnabled()
```
    Is this collection in a state that would allow us to "queue" clear? This is a special case, because of orphan delete.
  - queueOperation
```
protected final void queueOperation(AbstractPersistentCollection.DelayedOperation operation)
```
    Queue an addition
  - performQueuedOperations
```
protected final void performQueuedOperations()
```
    After reading all existing elements from the database, add the queued elements to the underlying collection.
  - setSnapshot
```
public void setSnapshot(Serializable key,
               String role,
               Serializable snapshot)
```
    Description copied from interface: PersistentCollection
    
    After flushing, re-init snapshot state.
    
    Specified by:
    
    setSnapshot in interface PersistentCollection
    
    Parameters:
    key - The collection instance key (fk value).
    role - The collection role
    snapshot - The snapshot state
  - postAction
```
public void postAction()
```
    Description copied from interface: PersistentCollection
    
    After flushing, clear any "queued" additions, since the database state is now synchronized with the memory state.
    
    Specified by:
    
    postAction in interface PersistentCollection
  - getValue
```
public Object getValue()
```
    Description copied from interface: PersistentCollection
    
    Return the user-visible collection (or array) instance
    
    Specified by:
    
    getValue in interface PersistentCollection
    
    Returns:
    The underlying collection/array
  - beginRead
```
public void beginRead()
```
    Description copied from interface: PersistentCollection
    
    Called just before reading any rows from the JDBC result set
    
    Specified by:
    
    beginRead in interface PersistentCollection
  - endRead
```
public boolean endRead()
```
    Description copied from interface: PersistentCollection
    
    Called after reading all rows from the JDBC result set
    
    Specified by:
    
    endRead in interface PersistentCollection
    
    Returns:
    Whether to end the read.
  - afterInitialize
```
public boolean afterInitialize()
```
    Description copied from interface: PersistentCollection
    
    Called after initializing from cache
    
    Specified by:
    
    afterInitialize in interface PersistentCollection
    
    Returns:
    ??
  - initialize
```
protected final void initialize(boolean writing)
```
    Initialize the collection, if possible, wrapping any exceptions in a runtime exception
    
    Parameters:
    writing - currently obsolete
    
    Throws:
    
    LazyInitializationException - if we cannot initialize
  - setInitialized
```
protected final void setInitialized()
```
  - setDirectlyAccessible
```
protected final void setDirectlyAccessible(boolean directlyAccessible)
```
  - isDirectlyAccessible
```
public boolean isDirectlyAccessible()
```
    Description copied from interface: PersistentCollection
    
    Could the application possibly have a direct reference to the underlying collection implementation?
    
    Specified by:
    
    isDirectlyAccessible in interface PersistentCollection
    
    Returns:
    true indicates that the application might have access to the underlying collection/array.
  - unsetSession
```
public final boolean unsetSession(SessionImplementor currentSession)
```
    Description copied from interface: PersistentCollection
    
    Disassociate this collection from the given session.
    
    Specified by:
    
    unsetSession in interface PersistentCollection
    
    Parameters:
    currentSession - The session we are disassociating from. Used for validations.
    
    Returns:
    true if this was currently associated with the given session
  - prepareForPossibleLoadingOutsideTransaction
```
protected void prepareForPossibleLoadingOutsideTransaction()
```
  - setCurrentSession
```
public final boolean setCurrentSession(SessionImplementor session)
                                throws HibernateException
```
    Description copied from interface: PersistentCollection
    
    Associate the collection with the given session.
    
    Specified by:
    
    setCurrentSession in interface PersistentCollection
    
    Parameters:
    session - The session to associate with
    
    Returns:
    false if the collection was already associated with the session
    
    Throws:
    
    HibernateException - if the collection was already associated with another open session
  - needsRecreate
```
public boolean needsRecreate(CollectionPersister persister)
```
    Description copied from interface: PersistentCollection
    
    Do we need to completely recreate this collection when it changes?
    
    Specified by:
    
    needsRecreate in interface PersistentCollection
    
    Parameters:
    persister - The collection persister
    
    Returns:
    true if a change requires a recreate.
  - forceInitialization
```
public final void forceInitialization()
                               throws HibernateException
```
    Description copied from interface: PersistentCollection
    
    To be called internally by the session, forcing immediate initialization.
    
    Specified by:
    
    forceInitialization in interface PersistentCollection
    
    Throws:
    
    HibernateException
  - getSnapshot
```
protected final Serializable getSnapshot()
```
    Get the current snapshot from the session
  - wasInitialized
```
public final boolean wasInitialized()
```
    Description copied from interface: PersistentCollection
    
    Is this instance initialized?
    
    Specified by:
    
    wasInitialized in interface PersistentCollection
    
    Returns:
    Was this collection initialized? Or is its data still not (fully) loaded?
  - isRowUpdatePossible
```
public boolean isRowUpdatePossible()
```
    Description copied from interface: PersistentCollection
    
    Can each element in the collection be mapped unequivocally to a single row in the database? Generally bags and sets are the only collections that cannot be.
    
    Specified by:
    
    isRowUpdatePossible in interface PersistentCollection
    
    Returns:
    true if the row for each element is known
  - hasQueuedOperations
```
public final boolean hasQueuedOperations()
```
    Description copied from interface: PersistentCollection
    
    Does this instance have any "queued" operations?
    
    Specified by:
    
    hasQueuedOperations in interface PersistentCollection
    
    Returns:
    true indicates there are pending, queued, delayed operations
  - queuedAdditionIterator
```
public final Iterator queuedAdditionIterator()
```
    Description copied from interface: PersistentCollection
    
    Iterator over the "queued" additions
    
    Specified by:
    
    queuedAdditionIterator in interface PersistentCollection
    
    Returns:
    The iterator
  - getQueuedOrphans
```
public final Collection getQueuedOrphans(String entityName)
```
    Description copied from interface: PersistentCollection
    
    Get the "queued" orphans
    
    Specified by:
    
    getQueuedOrphans in interface PersistentCollection
    
    Parameters:
    entityName - The name of the entity that makes up the elements
    
    Returns:
    The orphaned elements
  - preInsert
```
public void preInsert(CollectionPersister persister)
               throws HibernateException
```
    Description copied from interface: PersistentCollection
    
    Called before inserting rows, to ensure that any surrogate keys are fully generated
    
    Specified by:
    
    preInsert in interface PersistentCollection
    
    Parameters:
    persister - The collection persister
    
    Throws:
    
    HibernateException
  - afterRowInsert
```
public void afterRowInsert(CollectionPersister persister,
                  Object entry,
                  int i)
                    throws HibernateException
```
    Description copied from interface: PersistentCollection
    
    Called after inserting a row, to fetch the natively generated id
    
    Specified by:
    
    afterRowInsert in interface PersistentCollection
    
    Parameters:
    persister - The collection persister
    entry - The collection element just inserted
    i - The element position/index
    
    Throws:
    
    HibernateException
  - getOrphans
```
public abstract Collection getOrphans(Serializable snapshot,
                    String entityName)
                               throws HibernateException
```
    Description copied from interface: PersistentCollection
    
    get all "orphaned" elements
    
    Specified by:
    
    getOrphans in interface PersistentCollection
    
    Parameters:
    snapshot - The snapshot state
    entityName - The name of the entity that are the elements of the collection
    
    Returns:
    The orphans
    
    Throws:
    
    HibernateException
  - getSession
```
public final SessionImplementor getSession()
```
    Get the session currently associated with this collection.
    
    Returns:
    The session
  - getOrphans
```
protected static Collection getOrphans(Collection oldElements,
                    Collection currentElements,
                    String entityName,
                    SessionImplementor session)
                                throws HibernateException
```
    Given a collection of entity instances that used to belong to the collection, and a collection of instances that currently belong, return a collection of orphans
    
    Throws:
    
    HibernateException
  - identityRemove
```
public static void identityRemove(Collection list,
                  Object entityInstance,
                  String entityName,
                  SessionImplementor session)
```
    Removes entity entries that have an equal identifier with the incoming entity instance
    
    Parameters:
    list - The list containing the entity instances
    entityInstance - The entity instance to match elements.
    entityName - The entity name
    session - The session
  - getIdentifier
```
public Object getIdentifier(Object entry,
                   int i)
```
    Description copied from interface: PersistentCollection
    
    Get the identifier of the given collection entry. This refers to the collection identifier, not the identifier of the (possibly) entity elements. This is only valid for invocation on the idbag collection.
    
    Specified by:
    
    getIdentifier in interface PersistentCollection
    
    Parameters:
    entry - The collection entry/element
    i - The assumed identifier (?)
    
    Returns:
    The identifier value
  - getOwner
```
public Object getOwner()
```
    Description copied from interface: PersistentCollection
    
    Get the owning entity. Note that the owner is only set during the flush cycle, and when a new collection wrapper is created while loading an entity.
    
    Specified by:
    
    getOwner in interface PersistentCollection
    
    Returns:
    The owner
  - setOwner
```
public void setOwner(Object owner)
```
    Description copied from interface: PersistentCollection
    
    Set the reference to the owning entity
    
    Specified by:
    
    setOwner in interface PersistentCollection
    
    Parameters:
    owner - The owner

Class AbstractPersistentCollection

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.hibernate.collection.spi.PersistentCollection

Field Detail

UNKNOWN

Constructor Detail

AbstractPersistentCollection

AbstractPersistentCollection

Method Detail

getRole

getKey

isUnreferenced

isDirty

clearDirty

dirty

getStoredSnapshot

empty

read

readSize

readIndexExistence

readElementExistence

readElementByIndex

getCachedSize

write

isOperationQueueEnabled

isPutQueueEnabled

isClearQueueEnabled

queueOperation

performQueuedOperations

setSnapshot

postAction

getValue

beginRead

endRead

afterInitialize

initialize

setInitialized

setDirectlyAccessible

isDirectlyAccessible

unsetSession

prepareForPossibleLoadingOutsideTransaction

setCurrentSession

needsRecreate

forceInitialization

getSnapshot

wasInitialized

isRowUpdatePossible

hasQueuedOperations

queuedAdditionIterator

getQueuedOrphans

preInsert

afterRowInsert

getOrphans

getSession

getOrphans

identityRemove

getIdentifier

getOwner

setOwner