Module org.eclipse.persistence.core
Package org.eclipse.persistence.internal.queries

Class ContainerPolicy

java.lang.Object
org.eclipse.persistence.internal.queries.ContainerPolicy
All Implemented Interfaces:
Serializable, Cloneable, CoreContainerPolicy<AbstractSession>
Direct Known Subclasses:
CursorPolicy, InterfaceContainerPolicy
public abstract class ContainerPolicy extends Object implements CoreContainerPolicy<AbstractSession>, Cloneable, Serializable

Purpose: Used to support collections in read queries.

Responsibilities: Map the results into the appropriate collection instance. Generically support special collections like cursored stream and virtual collection.

Since:
TOPLink/Java 1.2
See Also:

  • Field Details

    • defaultContainerClass

      protected static Class<? extends Collection> defaultContainerClass
      Allow the default collection class to be set.

    • elementDescriptor

      protected transient ClassDescriptor elementDescriptor
      The descriptor is used to wrap and unwrap objects using the wrapper policy.

    • constructor

      protected transient Constructor constructor

  • Constructor Details

    • ContainerPolicy

      protected ContainerPolicy()
      Default constructor.

  • Method Details

    • getDefaultContainerClass

      public static Class<?> getDefaultContainerClass()
      ADVANCED: Return the default collection class.

    • setDefaultContainerClass

      public static void setDefaultContainerClass(Class<? extends Collection> collectionClass)
      ADVANCED: Allow the default collection class to be set.

    • addAdditionalFieldsToQuery

      public void addAdditionalFieldsToQuery(ReadQuery selectionQuery, Expression baseExpression)
      INTERNAL: Called when the selection query is being initialized to add any required additional fields to the query. By default, there are not additional fields required but this method is overridden by subclasses.
      See Also:

    • addFieldsForMapKey

      public void addFieldsForMapKey(AbstractRecord joinRow)
      INTERNAL: Called when the insert query is being initialized to ensure the fields for the key are in the insert query
      See Also:

    • addInto

      public boolean addInto(Object element, Object container, AbstractSession session)
      INTERNAL: Add element to container. This is used to add to a collection independent of JDK 1.1 and 1.2. The session may be required to wrap for the wrapper policy. Return whether the container changed
      Specified by:
      addInto in interface CoreContainerPolicy<AbstractSession>

    • addInto

      public boolean addInto(Object element, Object container, AbstractSession session, AbstractRecord dbRow, ObjectBuildingQuery query, CacheKey parentCacheKey, boolean isTargetProtected)
      INTERNAL: Add element to container. This is used to add to a collection independent of type. The session may be required to wrap for the wrapper policy. The row may be required by subclasses, such as MappedKeyMap. Return whether the container changed.

    • addAll

      public boolean addAll(List elements, Object container, AbstractSession session, List<AbstractRecord> dbRows, ObjectBuildingQuery query, CacheKey parentCacheKey, boolean isTargetProtected)
      INTERNAL: This is used for ordered List containers to add all of the elements to the collection in the order of the index field in the row. This is currently only used by OrderListContainerPolicy, so this is just a stub. The passing of the query is to allow future compatibility with Maps (ordered Map).

    • addInto

      public boolean addInto(Object element, Object container, AbstractSession session, AbstractRecord row, DataReadQuery query, CacheKey parentCacheKey, boolean isTargetProtected)
      INTERNAL: This is used for adding to a direct map or direct collection from the database. The row data may also be requires, as in the case of indexed ordered lists, or direct maps.

    • addAll

      public boolean addAll(List elements, Object container, AbstractSession session, List<AbstractRecord> rows, DataReadQuery query, CacheKey parentCacheKey, boolean isTargetProtected)
      INTERNAL: This is used for ordered List containers to add all of the elements to the collection in the order of the index field in the row. This is currently only used by OrderListContainerPolicy, so this is just a stub. The passing of the query is to allow future compatibility with Maps (ordered Map).

    • addInto

      public boolean addInto(Object key, Object element, Object container, AbstractSession session)
      INTERNAL: Add element to container. This is used to add to a collection independent of type. The session may be required to wrap for the wrapper policy. Return whether the container changed.
      Specified by:
      addInto in interface CoreContainerPolicy<AbstractSession>

    • addNestedJoinsQueriesForMapKey

      public void addNestedJoinsQueriesForMapKey(JoinedAttributeManager joinManager, ObjectLevelReadQuery query, AbstractSession session)
      INTERNAL: Used for joining. Add any queries necessary for joining to the join manager This method will be overridden by subclasses that handle map keys

    • addNextValueFromIteratorInto

      public void addNextValueFromIteratorInto(Object valuesIterator, Object parent, CacheKey parentCacheKey, Object toCollection, CollectionMapping mapping, Integer refreshCascade, AbstractSession cloningSession, boolean isExisting, boolean isFromSharedCache)
      INTERNAL: This method is used to add the next value from an iterator built using ContainerPolicy's iteratorFor() method into the toCollection. This method is overridden by subclasses to provide extended functionality for map keys
      See Also:

    • buildCloneForKey

      public Object buildCloneForKey(Object key, Object parent, CacheKey parentCacheKey, Integer refreshCascade, AbstractSession cloningSession, boolean isExisting, boolean isCacheCheckComplete)
      Build a clone for the key of a Map represented by this container policy if necessary. By default, the key is not cloned since in standard EclipseLink Mappings it will not be an Entity

    • buildCollectionEntry

      public Object buildCollectionEntry(Object objectAdded, ObjectChangeSet changeSet)
      INTERNAL: Return an object representing an entry in the collection represented by this container policy This method will be overridden to allow MapContainerPolicy to return a construct that contains the key and the value
      See Also:

    • buildContainerFromVector

      public Object buildContainerFromVector(Vector vector, AbstractSession session)
      INTERNAL: Return a container populated with the contents of the specified Vector.

    • buildKey

      public Object buildKey(AbstractRecord row, ObjectBuildingQuery query, CacheKey parentCacheKey, AbstractSession session, boolean isTargetProtected)
      Extract the key for the map from the provided row overridden by subclasses that deal with map keys

    • buildReferencesPKList

      public Object[] buildReferencesPKList(Object container, AbstractSession session)
      INTERNAL: This method will access the target relationship and create a list of information to rebuild the collection. This method is used in combination with the CachedValueHolder to store references to PK's to be loaded from a cache instead of a query.
      See Also:

    • buildKeyFromJoinedRow

      public Object buildKeyFromJoinedRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery query, CacheKey parentCacheKey, AbstractSession session, boolean isTargetProtected)
      Extract the key for the map from the provided row overridden by subclasses that deal with map keys

    • buildDefaultPolicy

      public static ContainerPolicy buildDefaultPolicy()
      INTERNAL: Return the appropriate container policy for the default container class.

    • buildPolicyFor

      public static ContainerPolicy buildPolicyFor(Class<?> concreteContainerClass)
      INTERNAL: Return the appropriate container policy for the specified concrete container class.

    • buildPolicyFor

      public static ContainerPolicy buildPolicyFor(Class<?> concreteContainerClass, boolean hasOrdering)
      INTERNAL: Return the appropriate container policy for the specified concrete container class.

    • buildSelectionQueryForDirectCollectionMapping

      public ReadQuery buildSelectionQueryForDirectCollectionMapping()
      INTERNAL: This Certain key mappings favor different types of selection query. Return the appropriate type of selectionQuery

    • clear

      public void clear(Object container)
      INTERNAL: Remove all the elements from the specified container. Valid only for certain subclasses.
      Specified by:
      clear in interface CoreContainerPolicy<AbstractSession>

    • createChangeEvent

      public abstract CollectionChangeEvent createChangeEvent(Object collectionOwner, String propertyName, Object collectionChanged, Object elementChanged, int changeType, Integer index, boolean isChangeApplied)
      INTERNAL: Creates a CollectionChangeEvent for the container

    • equals

      public boolean equals(Object object)
      INTERNAL: Return if the policy is equal to the other. By default if they are the same class, they are considered equal. This is used for query parse caching.
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • cascadeDiscoverAndPersistUnregisteredNewObjects

      public void cascadeDiscoverAndPersistUnregisteredNewObjects(Object object, Map newObjects, Map unregisteredExistingObjects, Map visitedObjects, UnitOfWorkImpl uow, Set cascadeErrors)
      INTERNAL: Cascade DiscoverAndPersistUnregisteredNewObjects to any mappings managed by the container policy. Be default, this is a no-op, but will be overridden by subclasses

    • cascadePerformRemoveIfRequired

      public void cascadePerformRemoveIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects)
      INTERNAL: Cascade performRemove to any mappings managed by the container policy. Be default, this is a no-op, but will be overridden by subclasses

    • cascadeRegisterNewIfRequired

      public void cascadeRegisterNewIfRequired(Object object, UnitOfWorkImpl uow, Map visitedObjects)
      INTERNAL: Cascade registerNew to any mappings managed by the container policy. Be default, this is a no-op, but will be overridden by subclasses

    • clone

      public Object clone()
      Overrides:
      clone in class Object

    • clone

      public ContainerPolicy clone(ReadQuery query)

    • cloneFor

      public Object cloneFor(Object container)
      INTERNAL: Return a clone of the specified container. Can only be called for select subclasses.

    • createChangeSetForKeys

      protected void createChangeSetForKeys(Map originalKeyValues, CollectionChangeRecord changeRecord, AbstractSession session, ClassDescriptor referenceDescriptor)
      INTERNAL: Create change sets that contain map keys. This method will be overridden by subclasses that handle map keys

    • collectObjectForNewCollection

      protected void collectObjectForNewCollection(Map originalKeyValues, Map cloneKeyValues, Object newCollection, CollectionChangeRecord changeRecord, AbstractSession session, ClassDescriptor referenceDescriptor)
      INTERNAL: Iterate over the list of new objects and create change sets for them This method is overridden by subclasses to handle map keys

    • compareCollectionsForChange

      public void compareCollectionsForChange(Object oldCollection, Object newCollection, CollectionChangeRecord changeRecord, AbstractSession session, ClassDescriptor referenceDescriptor)
      INTERNAL: This method is used to calculate the differences between two collections.

    • buildChangeSetForNewObjectInCollection

      public void buildChangeSetForNewObjectInCollection(Object object, ClassDescriptor referenceDescriptor, UnitOfWorkChangeSet uowChangeSet, AbstractSession session)

    • compareKeys

      public boolean compareKeys(Object sourceKey, AbstractSession session)
      INTERNAL: Return true if keys are the same in the source as the backup. False otherwise in the case of readonly compare against the original For non map container policies return true always, because these policies have no concepts of Keys

    • concatenateContainers

      public Object concatenateContainers(Object firstContainer, Object secondContainer, AbstractSession session)
      INTERNAL: Build a new container, add the contents of each of the specified containers to it, and return it. Both of the containers must use the same container policy (namely, this one).

    • containerInstance

      public Object containerInstance()
      INTERNAL: Return an instance of the container class. Null should never be returned. A ValidationException is thrown on error.
      Specified by:
      containerInstance in interface CoreContainerPolicy<AbstractSession>

    • containerInstance

      public Object containerInstance(int initialCapacity)
      INTERNAL: Return an instance of the container class with the specified initial capacity. Null should never be returned. A ValidationException is thrown on error.
      Specified by:
      containerInstance in interface CoreContainerPolicy<AbstractSession>

    • contains

      protected boolean contains(Object element, Object container)
      INTERNAL: Return whether element exists in container.

    • contains

      public boolean contains(Object element, Object container, AbstractSession session)
      INTERNAL: Check if the object is contained in the collection. This is used to check contains in a collection independent of JDK 1.1 and 1.2. The session may be required to unwrap for the wrapper policy.
      Specified by:
      contains in interface CoreContainerPolicy<AbstractSession>

    • convertClassNamesToClasses

      public void convertClassNamesToClasses(ClassLoader classLoader)
      INTERNAL: Convert all the class-name-based settings in this ContainerPolicy to actual class-based settings This method is implemented by subclasses as necessary.

    • createWrappedObjectFromExistingWrappedObject

      public Object createWrappedObjectFromExistingWrappedObject(Object wrappedObject, Object parent, ClassDescriptor referenceDescriptor, MergeManager mergeManager, AbstractSession targetSession)
      INTERNAL: This method will actually potentially wrap an object in two ways. It will first wrap the object based on the referenceDescriptor's wrapper policy. It will also potentially do some wrapping based on what is required by the container policy.
      Parameters:
      parent - if this is an aggregate, the owner of the aggregate
      See Also:

    • deleteWrappedObject

      public void deleteWrappedObject(Object objectDeleted, AbstractSession session)
      INTERNAL: Delete the passed object This may be overridden by subclasses to deal with composite objects
      See Also:

    • execute

      public Object execute()
      INTERNAL: This can be used by collection such as cursored stream to gain control over execution.

    • getAdditionalTablesForJoinQuery

      public List<DatabaseTable> getAdditionalTablesForJoinQuery()
      INTERNAL: Return any tables that will be required when this mapping is used as part of a join query.

    • getAdditionalFieldsForJoin

      public List<DatabaseField> getAdditionalFieldsForJoin(CollectionMapping baseMapping)
      INTERNAL: Return any additional fields required by the policy for a fetch join. This method will be overridden by ContainerPolicies that handle map keys.

    • getChangeValuesFrom

      public Iterator getChangeValuesFrom(Map map)
      INTERNAL: Used to create an iterator on a the Map object passed to CollectionChangeRecord.addRemoveChange() to access the values to be removed. In the case of some container policies the values will actually be the keys.

    • getCloneDataFromChangeSet

      public Object getCloneDataFromChangeSet(ObjectChangeSet changeSet)
      INTERNAL: Used when objects are added or removed during an update. This method returns either the clone from the ChangeSet or a packaged version of it that contains things like map keys.

    • getConstructor

      protected Constructor getConstructor()
      INTERNAL: Return the size constructor if available.

    • getContainerClass

      public Class<?> getContainerClass()
      INTERNAL: Return the class used for the container.

    • getContainerClassName

      public String getContainerClassName()
      INTERNAL: Used by the MW

    • getDescriptorForMapKey

      public ClassDescriptor getDescriptorForMapKey()
      INTERNAL: Return the reference descriptor for the map key if it exists

    • getElementDescriptor

      public ClassDescriptor getElementDescriptor()
      INTERNAL: Used for wrapping and unwrapping with the wrapper policy.

    • getIdentityFieldsForMapKey

      public List<DatabaseField> getIdentityFieldsForMapKey()
      INTERNAL: Return the fields that make up the identity of the key if this mapping is a list This method will be overridden by subclasses.

    • getKeyMappingDataForWriteQuery

      public Map getKeyMappingDataForWriteQuery(Object object, AbstractSession session)
      INTERNAL: Add any non-Foreign-key data from an Object describe by a MapKeyMapping to a database row This is typically used in write queries to ensure all the data stored in the collection table is included in the query.

    • getKeySelectionCriteria

      public Expression getKeySelectionCriteria()
      INTERNAL: Get the selection criteria for the map key This will be overridden by container policies that allow maps

    • getKeyType

      public Object getKeyType()
      INTERNAL: Return the type of the map key, this will be overridden by container policies that allow maps.

    • hasElementDescriptor

      public boolean hasElementDescriptor()
      INTERNAL: Used for wrapping and unwrapping with the wrapper policy.

    • hasNext

      public abstract boolean hasNext(Object iterator)
      INTERNAL: Return whether the iterator has more objects. The iterator is the one returned from #iteratorFor(). Valid for some subclasses only.
      Specified by:
      hasNext in interface CoreContainerPolicy<AbstractSession>
      See Also:

    • hasOrder

      public boolean hasOrder()
      INTERNAL: Returns true if the collection has order

    • initialize

      public void initialize(AbstractSession session, DatabaseTable keyTable)
      INTERNAL: Provide a hook to allow initialization of Container Policy parts

    • initializeConstructor

      public void initializeConstructor()
      INTERNAL: Find the size constructor. Providing a size is important for performance.

    • isCollectionPolicy

      public boolean isCollectionPolicy()

    • isCursoredStreamPolicy

      public boolean isCursoredStreamPolicy()

    • isScrollableCursorPolicy

      public boolean isScrollableCursorPolicy()

    • isCursorPolicy

      public boolean isCursorPolicy()

    • isDirectMapPolicy

      public boolean isDirectMapPolicy()

    • isEmpty

      public boolean isEmpty(Object container)
      INTERNAL: Return whether the container is empty.
      Specified by:
      isEmpty in interface CoreContainerPolicy<AbstractSession>

    • isListPolicy

      public boolean isListPolicy()
      Specified by:
      isListPolicy in interface CoreContainerPolicy<AbstractSession>

    • isOrderedListPolicy

      public boolean isOrderedListPolicy()

    • isMapPolicy

      public boolean isMapPolicy()

    • isMappedKeyMapPolicy

      public boolean isMappedKeyMapPolicy()

    • isMapKeyObject

      public boolean isMapKeyObject()
      INTERNAL: Return if the map key this container policy represents is a OneToOne.

    • isValidContainer

      public boolean isValidContainer(Object container)
      INTERNAL: Return whether the specified object is of a valid container type.
      See Also:

    • isValidContainerType

      public boolean isValidContainerType(Class<?> containerType)
      INTERNAL: Return whether the specified type is a valid container type.

    • iterateOnMapKey

      public void iterateOnMapKey(DescriptorIterator iterator, Object element)
      INTERNAL: Used in Descriptor Iteration to iterate on map keys. This method is a no-op here, but will be overridden by subclasses

    • iteratorFor

      public abstract Object iteratorFor(Object container)
      INTERNAL: Return an iterator for the given container. This iterator can then be used as a parameter to #hasNext() and #next().
      Specified by:
      iteratorFor in interface CoreContainerPolicy<AbstractSession>
      See Also:

    • keyFrom

      public Object keyFrom(Object element, AbstractSession session)
      INTERNAL: Return the key for the specified element..

    • keyFromEntry

      public Object keyFromEntry(Object entry)
      Get the key from the passed in Map.Entry This method will be overridden by ContainerPolicies that allows maps.

    • keyFromIterator

      public Object keyFromIterator(Object iterator)

    • mergeCascadeParts

      public Object mergeCascadeParts(ObjectChangeSet objectChanges, MergeManager mergeManager, AbstractSession targetSession)
      INTERNAL: Merge changes from the source to the target object. Because this is a collection mapping, values are added to or removed from the collection based on the change set.

    • mergeChanges

      public void mergeChanges(CollectionChangeRecord changeRecord, Object valueOfTarget, boolean shouldMergeCascadeParts, MergeManager mergeManager, AbstractSession targetSession, boolean isSynchronizeOnMerge)
      INTERNAL: Merge changes from the source to the target object. Because this is a collection mapping, values are added to or removed from the collection based on the change set. Synchronize if system property is specified. If not, default to clone the target collection. No need to synchronize if the collection is new.

    • mergeChanges

      protected void mergeChanges(CollectionChangeRecord changeRecord, Object valueOfTarget, boolean shouldMergeCascadeParts, MergeManager mergeManager, AbstractSession targetSession)
      INTERNAL: Merge changes from the source to the target object. Because this is a collection mapping, values are added to or removed from the collection based on the change set.

    • next

      protected abstract Object next(Object iterator)
      INTERNAL: Return the next object on the queue. The iterator is the one returned from #iteratorFor(). Valid for some subclasses only.
      See Also:

    • next

      public Object next(Object iterator, AbstractSession session)
      INTERNAL: Return the next object from the iterator. This is used to stream over a collection independent of JDK 1.1 and 1.2. The session may be required to unwrap for the wrapper policy.
      Specified by:
      next in interface CoreContainerPolicy<AbstractSession>

    • nextEntry

      public Object nextEntry(Object iterator)
      INTERNAL: Return the next object on the queue. The iterator is the one returned from #iteratorFor(). In the case of a Map, this will return a MapEntry to allow use of the key
      Specified by:
      nextEntry in interface CoreContainerPolicy<AbstractSession>
      See Also:

    • nextEntry

      public Object nextEntry(Object iterator, AbstractSession session)
      INTERNAL: Return the next object on the queue. The iterator is the one returned from #iteratorFor(). In the case of a Map, this will return a MapEntry to allow use of the key
      Specified by:
      nextEntry in interface CoreContainerPolicy<AbstractSession>
      See Also:

    • overridesRead

      public boolean overridesRead()
      This can be used by collection such as cursored stream to gain control over execution.

    • postInitialize

      public void postInitialize(AbstractSession session)
      INTERNAL: Some subclasses need to post initialize mappings associated with them

    • postCalculateChanges

      public void postCalculateChanges(ObjectChangeSet ocs, ClassDescriptor referenceDescriptor, DatabaseMapping mapping, UnitOfWorkImpl uow)
      INTERNAL: Add the provided object to the deleted objects list on the commit manager. This may be overridden by subclasses to process a composite object
      See Also:

    • postCalculateChanges

      public void postCalculateChanges(Object key, Object value, ClassDescriptor referenceDescriptor, DatabaseMapping mapping, UnitOfWorkImpl uow)
      INTERNAL: Add the provided object to the deleted objects list on the commit manager. This may be overridden by subclasses to process a composite object.

    • recordPrivateOwnedRemovals

      public void recordPrivateOwnedRemovals(Object object, ClassDescriptor referenceDescriptor, UnitOfWorkImpl uow)
      INTERNAL: Add the provided object to the deleted objects list on the commit manager. This may be overridden by subclasses to process a composite object.

    • prepare

      public void prepare(DatabaseQuery query, AbstractSession session) throws QueryException
      Prepare and validate. Allow subclasses to override.
      Throws:
      QueryException

    • prepareForExecution

      public void prepareForExecution() throws QueryException
      Prepare and validate. Allow subclasses to override.
      Throws:
      QueryException

    • processAdditionalWritableMapKeyFields

      public void processAdditionalWritableMapKeyFields(AbstractSession session)
      INTERNAL: This method is used to check the key mapping to ensure that it does not write to a field that is written by another mapping. This method will be overridden by subclasses that deal MapKeys

    • propogatePostDelete

      public void propogatePostDelete(DeleteObjectQuery query, Object object)
      INTERNAL: Propagate the postDeleteEvent to any additional objects the query is aware of This method will be overridden by subclasses that deal MapKeys

    • propogatePostInsert

      public void propogatePostInsert(WriteObjectQuery query, Object object)
      INTERNAL: Propagate the postDeleteEvent to any additional objects the query is aware of This method will be overridden by subclasses that deal MapKeys

    • propogatePostUpdate

      public void propogatePostUpdate(WriteObjectQuery query, Object object)
      INTERNAL: Propagate the postDeleteEvent to any additional objects the query is aware of This method will be overridden by subclasses that deal MapKeys

    • propogatePreDelete

      public void propogatePreDelete(DeleteObjectQuery query, Object object)
      INTERNAL: Propagate the postDeleteEvent to any additional objects the query is aware of This method will be overridden by subclasses that deal MapKeys

    • propogatePreInsert

      public void propogatePreInsert(WriteObjectQuery query, Object object)
      INTERNAL: Propagate the postDeleteEvent to any additional objects the query is aware of This method will be overridden by subclasses that deal MapKeys

    • propogatePreUpdate

      public void propogatePreUpdate(WriteObjectQuery query, Object object)
      INTERNAL: Propagate the postDeleteEvent to any additional objects the query is aware of This method will be overridden by subclasses that deal MapKeys

    • propagatesEventsToCollection

      public boolean propagatesEventsToCollection()
      INTERNAL: Returns false. Most container policies do not need to propagate events within the collections This will be overridden by subclasses

    • recordAddToCollectionInChangeRecord

      public void recordAddToCollectionInChangeRecord(ObjectChangeSet changeSetToAdd, CollectionChangeRecord collectionChangeRecord)
      This method is used to bridge the behavior between Attribute Change Tracking and deferred change tracking with respect to adding the same instance multiple times. Each ContainerPolicy type will implement specific behavior for the collection type it is wrapping. These methods are only valid for collections containing object references

    • recordRemoveFromCollectionInChangeRecord

      public void recordRemoveFromCollectionInChangeRecord(ObjectChangeSet changeSetToRemove, CollectionChangeRecord collectionChangeRecord)
      This method is used to bridge the behavior between Attribute Change Tracking and deferred change tracking with respect to adding the same instance multiple times. Each ContainerPolicy type will implement specific behavior for the collection type it is wrapping. These methods are only valid for collections containing object references

    • recordUpdateToCollectionInChangeRecord

      public void recordUpdateToCollectionInChangeRecord(CollectionChangeEvent event, ObjectChangeSet changeSet, CollectionChangeRecord collectionChangeRecord)
      This method is used to bridge the behavior between Attribute Change Tracking and deferred change tracking with respect to adding the same instance multiple times. Each ContainerPolicy type will implement specific behavior for the collection type it is wrapping. These methods are only valid for collections containing object references

    • remoteExecute

      public Object remoteExecute()
      This can be used by collection such as cursored stream to gain control over execution.

    • removeFrom

      protected boolean removeFrom(Object key, Object element, Object container)
      INTERNAL: Remove element from container. Valid for some subclasses only.

    • removeFrom

      public boolean removeFrom(Object key, Object element, Object container, AbstractSession session)
      INTERNAL: Remove the object from the collection. This is used to remove from a collection independent of JDK 1.1 and 1.2. The session may be required to unwrap for the wrapper policy.

    • removeFrom

      public boolean removeFrom(Object element, Object container, AbstractSession session)
      INTERNAL: Remove the object from the collection. This is used to remove from a collection independent of JDK 1.1 and 1.2. The session may be required to unwrap for the wrapper policy.
      Specified by:
      removeFrom in interface CoreContainerPolicy<AbstractSession>

    • requiresDataModificationEvents

      public boolean requiresDataModificationEvents()
      INTERNAL: Returns whether this ContainerPolicy should requires data modification events when objects are added or deleted during update

    • setConstructor

      protected void setConstructor(Constructor constructor)
      INTERNAL: Set the size constructor if available.

    • setContainerClass

      public void setContainerClass(Class<?> containerClass)
      INTERNAL: Set the class used for the container.
      Specified by:
      setContainerClass in interface CoreContainerPolicy<AbstractSession>

    • setContainerClassName

      public void setContainerClassName(String containerClassName)
      INTERNAL: Used by the MW

    • setElementDescriptor

      public void setElementDescriptor(ClassDescriptor elementDescriptor)
      INTERNAL: Used for wrapping and unwrapping with the wrapper policy.

    • setKeyName

      public void setKeyName(String instanceVariableName, String elementClassName)
      INTERNAL: It is illegal to send this message to this receiver. Try one of my subclasses. Throws an exception.
      See Also:

    • setKeyName

      public void setKeyName(String instanceVariableName, Class<?> elementClass)
      INTERNAL: Sets the key name to be used to generate the key in a Map type container class. The key name, may be the name of a field or method. An instance of the class is provided in the case when the descriptor is being built in code.

    • shouldAddAll

      public boolean shouldAddAll()
      INTERNAL: Indicates whether addAll method should be called to add entire collection, or it's possible to call addInto multiple times instead.

    • shouldIncludeKeyInDeleteEvent

      public boolean shouldIncludeKeyInDeleteEvent()
      INTERNAL: Return whether data for a map key must be included on a Delete data modification event This will be overridden by subclasses that handle maps.

    • shouldUpdateForeignKeysPostInsert

      public boolean shouldUpdateForeignKeysPostInsert()
      INTERNAL: Certain types of container policies require an extra update statement after a relationship is inserted. Return whether this update statement is required.

    • sizeFor

      public int sizeFor(Object container)
      INTERNAL: Return the size of container.
      Specified by:
      sizeFor in interface CoreContainerPolicy<AbstractSession>

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toStringInfo

      protected Object toStringInfo()

    • updateJoinedMappingIndexesForMapKey

      public int updateJoinedMappingIndexesForMapKey(Map<DatabaseMapping,Object> indexList, int index)
      INTERNAL: Update the joined mapping indices This method is a no-op, but will be overridden by subclasses

    • updateChangeRecordForSelfMerge

      public void updateChangeRecordForSelfMerge(ChangeRecord changeRecord, Object source, Object target, ForeignReferenceMapping mapping, UnitOfWorkChangeSet parentUOWChangeSet, UnitOfWorkImpl unitOfWork)
      INTERNAL: Update a ChangeRecord to replace the ChangeSet for the old entity with the changeSet for the new Entity. This is used when an Entity is merged into itself and the Entity reference new or detached entities.

    • unwrapElement

      public Object unwrapElement(Object object)
      INTERNAL: MapContainerPolicy's iterator iterates on the Entries of a Map. This method returns the object from the iterator
      See Also:

    • unwrapIteratorResult

      public Object unwrapIteratorResult(Object object)
      INTERNAL: Depending on the container, the entries returned of iteration using the ContainerPolicy.iteratorFor() method may be wrapped. This method unwraps the values.
      See Also:

    • valueFromPKList

      public Object valueFromPKList(Object[] pks, AbstractRecord foreignKeys, ForeignReferenceMapping mapping, AbstractSession session)
      INTERNAL: This method is used to load a relationship from a list of PKs. This list may be available if the relationship has been cached.

    • vectorFor

      public Vector vectorFor(Object container, AbstractSession session)
      INTERNAL: Return a Vector populated with the contents of container. Added for bug 2766379, must implement a version of vectorFor that handles wrapped objects.
      Specified by:
      vectorFor in interface CoreContainerPolicy<AbstractSession>

    • copyMapDataToRow

      public static void copyMapDataToRow(Map mappingData, AbstractRecord databaseRow)
      INTERNAL: convenience method to copy the keys and values from a Map into an AbstractRecord
      Parameters:
      mappingData - a Map containing a database field as the key and the value of that field as the value