org.eclipse.persistence.indirection.IndirectList Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of eclipselink Show documentation
Show all versions of eclipselink Show documentation
EclipseLink build based upon Git transaction 346465e
/*******************************************************************************
* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
******************************************************************************/
package org.eclipse.persistence.indirection;
import java.util.*;
import java.beans.PropertyChangeListener;
import org.eclipse.persistence.internal.descriptors.changetracking.AttributeChangeListener;
import org.eclipse.persistence.internal.indirection.*;
import org.eclipse.persistence.mappings.CollectionMapping;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.descriptors.changetracking.*;
/**
* IndirectList allows a domain class to take advantage of TopLink indirection
* without having to declare its instance variable as a ValueHolderInterface.
* To use an IndirectList:
* - Declare the appropriate instance variable with type Collection/List/Vector (jdk1.2).
*
- Send the message #useTransparentCollection() to the appropriate
* CollectionMapping.
*
* EclipseLink will place an
* IndirectList in the instance variable when the containing domain object is read from
* the datatabase. With the first message sent to the IndirectList, the contents
* are fetched from the database and normal Collection/List/Vector behavior is resumed.
*
* @see org.eclipse.persistence.mappings.CollectionMapping
* @see org.eclipse.persistence.indirection.IndirectMap
* @author Big Country
* @since TOPLink/Java 2.5
*/
public class IndirectList extends Vector implements CollectionChangeTracker, IndirectCollection {
/** Reduce type casting. */
protected volatile Vector delegate;
/** Delegate indirection behavior to a value holder. */
protected ValueHolderInterface valueHolder;
/** Change tracking listener. */
private transient PropertyChangeListener changeListener;
/** The mapping attribute name, used to raise change events. */
private transient String attributeName;
/** Store added elements to avoid instantiation on add. */
private transient List addedElements;
/** Store removed elements to avoid instantiation on remove. */
private transient List removedElements;
/** Store initial size for lazy init. */
protected int initialCapacity;
/** PERF: Quick check flag if has been registered in a unit of work. */
protected boolean isRegistered;
/**
* If the mapping using IndirectList has listOrderfield != null then this flag indicates
* whether the list in the db has invalid order:
* either row(s) with null order value(s) or/and "holes" in order.
* The flag may be set to true when the objects are read from the db.
* When collection is updated the flag set to true causes updating of listOrderField of all rows in the db.
* After update is complete the flag is set back to false.
**/
private boolean isListOrderBrokenInDb;
/**
* This value is used to determine if we should attempt to do adds and removes from the list without
* actually instantiating the list from the database. By default this is set to true.
*/
private boolean useLazyInstantiation = true;
/**
* PUBLIC:
* Construct an empty IndirectList so that its internal data array
* has size 10 and its standard capacity increment is zero.
*/
public IndirectList() {
super(0, 0);
this.initialCapacity = 10;
}
/**
* PUBLIC:
* Construct an empty IndirectList with the specified initial capacity and
* with its capacity increment equal to zero.
*
* @param initialCapacity the initial capacity of the vector
* @exception IllegalArgumentException if the specified initial capacity
* is negative
*/
public IndirectList(int initialCapacity) {
super(0, 0);
this.initialCapacity = initialCapacity;
}
/**
* PUBLIC:
* Construct an empty IndirectList with the specified initial capacity and
* capacity increment.
*
* @param initialCapacity the initial capacity of the vector
* @param capacityIncrement the amount by which the capacity is
* increased when the vector overflows
* @exception IllegalArgumentException if the specified initial capacity
* is negative
*/
public IndirectList(int initialCapacity, int capacityIncrement) {
super(0, capacityIncrement);
this.initialCapacity = initialCapacity;
}
/**
* PUBLIC:
* Construct an IndirectList containing the elements of the specified
* collection, in the order they are returned by the collection's
* iterator.
* @param collection a collection containing the elements to construct this IndirectList with.
*/
public IndirectList(Collection collection) {
super(0);
this.valueHolder = new ValueHolder(new Vector(collection));
}
/**
* @see java.util.Vector#add(int, java.lang.Object)
*/
public void add(int index, Object element) {
getDelegate().add(index, element);
raiseAddChangeEvent(element, index);
}
/**
* Raise the add change event and relationship maintenance.
*/
protected void raiseAddChangeEvent(Object element, Integer index) {
raiseAddChangeEvent(element, index, false);
}
protected void raiseAddChangeEvent(Object element, Integer index, boolean isSet) {
if (hasTrackedPropertyChangeListener()) {
_persistence_getPropertyChangeListener().propertyChange(new CollectionChangeEvent(this, getTrackedAttributeName(), this, element, CollectionChangeEvent.ADD, index, isSet, true));
}
if (isRelationshipMaintenanceRequired()) {
((UnitOfWorkQueryValueHolder)getValueHolder()).updateForeignReferenceSet(element, null);
}
}
protected boolean isRelationshipMaintenanceRequired() {
if (this.valueHolder instanceof UnitOfWorkQueryValueHolder) {
DatabaseMapping mapping = ((UnitOfWorkQueryValueHolder)this.valueHolder).getMapping();
return (mapping != null) && (mapping.getRelationshipPartner() != null);
}
return false;
}
/**
* Raise the remove change event.
*/
protected void raiseRemoveChangeEvent(Object element, Integer index) {
raiseRemoveChangeEvent(element, index, false);
}
protected void raiseRemoveChangeEvent(Object element, Integer index, boolean isSet) {
if (hasTrackedPropertyChangeListener()) {
_persistence_getPropertyChangeListener().propertyChange(new CollectionChangeEvent(this, getTrackedAttributeName(), this, element, CollectionChangeEvent.REMOVE, index, isSet, true));
}
if (isRelationshipMaintenanceRequired()) {
((UnitOfWorkQueryValueHolder)getValueHolder()).updateForeignReferenceRemove(element);
}
}
/**
* @see java.util.Vector#add(java.lang.Object)
*/
public boolean add(Object element) {
if (!this.isRegistered) {
return getDelegate().add(element);
}
boolean added = true;
// PERF: If not instantiated just record the add to avoid the instantiation.
if (shouldAvoidInstantiation()) {
if (hasRemovedElements() && getRemovedElements().contains(element)) {
getRemovedElements().remove(element);
} else if (isRelationshipMaintenanceRequired() && getAddedElements().contains(element)) {
// Must avoid recursion for relationship maintenance.
return false;
} else {
getAddedElements().add(element);
}
} else {
added = getDelegate().add(element);
}
raiseAddChangeEvent(element, null);
return added;
}
/**
* @see java.util.Vector#addAll(int, java.util.Collection)
*/
public boolean addAll(int index, Collection c) {
Iterator objects = c.iterator();
// Must trigger add events if tracked or uow.
if (hasBeenRegistered() || hasTrackedPropertyChangeListener()) {
while (objects.hasNext()) {
this.add(index, objects.next());
index++;
}
return true;
}
return getDelegate().addAll(index, c);
}
/**
* @see java.util.Vector#addAll(java.util.Collection)
*/
public boolean addAll(Collection c) {
// Must trigger add events if tracked or uow.
if (hasBeenRegistered() || hasTrackedPropertyChangeListener()) {
Iterator objects = c.iterator();
while (objects.hasNext()) {
this.add(objects.next());
}
return true;
}
return getDelegate().addAll(c);
}
/**
* @see java.util.Vector#addElement(java.lang.Object)
*/
public void addElement(Object obj) {
add(obj);
}
/**
* INTERNAL:
* Return the freshly-built delegate.
*/
protected Vector buildDelegate() {
Vector delegate = (Vector)getValueHolder().getValue();
if (delegate == null) {
delegate = new Vector(this.initialCapacity, this.capacityIncrement);
}
// This can either be another indirect list or a Vector.
// It can be another indirect list because the mapping's query uses the same container policy.
// Unwrap any redundant indirection layers, which can cause issues and impact performance.
while (delegate instanceof IndirectList) {
if(((IndirectList) delegate).isListOrderBrokenInDb()) {
this.isListOrderBrokenInDb = true;
}
delegate = ((IndirectList) delegate).getDelegate();
}
// First add/remove any cached changes.
if (hasAddedElements()) {
int size = getAddedElements().size();
for (int index = 0; index < size; index++) {
Object element = ((List)getAddedElements()).get(index);
// On a flush or resume the element may already be in the database.
if (!delegate.contains(element)) {
delegate.add(element);
}
}
this.addedElements = null;
}
if (hasRemovedElements()) {
int size = getRemovedElements().size();
for (int index = 0; index < size; index++) {
delegate.remove(((List)getRemovedElements()).get(index));
}
this.removedElements = null;
}
return delegate;
}
/**
* @see java.util.Vector#capacity()
*/
public int capacity() {
return getDelegate().capacity();
}
/**
* @see java.util.Vector#clear()
*/
public void clear() {
removeAllElements();
}
/**
* INTERNAL:
* clear any changes that have been deferred to instantiation.
* Indirect collections with change tracking avoid instantiation on add/remove.
*/
public void clearDeferredChanges(){
addedElements = null;
removedElements = null;
}
/**
* PUBLIC:
* @see java.util.Vector#clone()
* This will result in a database query if necessary.
*/
/*
There are 3 situations when clone() is called:
1. The developer actually wants to clone the collection (typically to modify one
of the 2 resulting collections). In which case the contents must be read from
the database.
2. A UnitOfWork needs a clone (or backup clone) of the collection. But the
UnitOfWork checks "instantiation" before cloning collections ("un-instantiated"
collections are not cloned).
3. A MergeManager needs an extra copy of the collection (because the "backup"
and "target" are the same object?). But the MergeManager checks "instantiation"
before merging collections (again, "un-instantiated" collections are not merged).
*/
public synchronized Object clone() {
IndirectList result = (IndirectList)super.clone();
result.delegate = (Vector)this.getDelegate().clone();
result.valueHolder = new ValueHolder(result.delegate);
result.attributeName = null;
result.changeListener = null;
return result;
}
/**
* PUBLIC:
* @see java.util.Vector#contains(java.lang.Object)
*/
public boolean contains(Object element) {
// PERF: Avoid instantiation if not required.
if (hasAddedElements()) {
if (getAddedElements().contains(element)) {
return true;
}
}
if (hasRemovedElements()) {
if (getRemovedElements().contains(element)) {
return false;
}
}
return getDelegate().contains(element);
}
/**
* @see java.util.Vector#containsAll(java.util.Collection)
*/
public boolean containsAll(Collection c) {
return getDelegate().containsAll(c);
}
/**
* @see java.util.Vector#copyInto(java.lang.Object[])
*/
public synchronized void copyInto(Object[] anArray) {
getDelegate().copyInto(anArray);
}
/**
* @see java.util.Vector#elementAt(int)
*/
public Object elementAt(int index) {
return getDelegate().elementAt(index);
}
/**
* @see java.util.Vector#elements()
*/
public Enumeration elements() {
return getDelegate().elements();
}
/**
* @see java.util.Vector#ensureCapacity(int)
*/
public void ensureCapacity(int minCapacity) {
getDelegate().ensureCapacity(minCapacity);
}
/**
* @see java.util.Vector#equals(java.lang.Object)
*/
public boolean equals(Object o) {
return getDelegate().equals(o);
}
/**
* @see java.util.Vector#firstElement()
*/
public Object firstElement() {
return getDelegate().firstElement();
}
/**
* @see java.util.Vector#get(int)
*/
public Object get(int index) {
return getDelegate().get(index);
}
/**
* INTERNAL:
* Check whether the contents have been read from the database.
* If they have not, read them and set the delegate.
* This method used to be synchronized, which caused deadlock.
*/
protected Vector getDelegate() {
if (delegate == null) {
synchronized(this){
if (delegate == null) {
delegate = this.buildDelegate();
}
}
}
return delegate;
}
/**
* INTERNAL:
* Return the real collection object.
* This will force instantiation.
*/
public Object getDelegateObject() {
return getDelegate();
}
/**
* INTERNAL:
* Return the valueHolder.
* This method used to be synchronized, which caused deadlock.
*/
public ValueHolderInterface getValueHolder() {
// PERF: lazy initialize value holder and vector as are normally set after creation.
if (valueHolder == null) {
synchronized(this) {
if (valueHolder == null) {
valueHolder = new ValueHolder(new Vector(this.initialCapacity, this.capacityIncrement));
}
}
}
return valueHolder;
}
/**
* INTERNAL:
* return whether this IndirectList has been registered with the UnitOfWork
*/
public boolean hasBeenRegistered() {
return getValueHolder() instanceof UnitOfWorkQueryValueHolder;
}
/**
* INTERNAL:
* @see java.util.Vector#hashCode()
*/
public int hashCode() {
return this.getDelegate().hashCode();
}
/**
* @see java.util.Vector#indexOf(java.lang.Object)
*/
public int indexOf(Object elem) {
return this.getDelegate().indexOf(elem);
}
/**
* @see java.util.Vector#indexOf(java.lang.Object, int)
*/
public int indexOf(Object elem, int index) {
return this.getDelegate().indexOf(elem, index);
}
/**
* @see java.util.Vector#insertElementAt(java.lang.Object, int)
*/
public void insertElementAt(Object obj, int index) {
this.getDelegate().insertElementAt(obj, index);
this.raiseAddChangeEvent(obj, Integer.valueOf(index));
}
/**
* @see java.util.Vector#isEmpty()
*/
public boolean isEmpty() {
return this.getDelegate().isEmpty();
}
/**
* PUBLIC:
* Return whether the contents have been read from the database.
*/
public boolean isInstantiated() {
return getValueHolder().isInstantiated();
}
/**
* @see java.util.AbstractList#iterator()
*/
public Iterator iterator() {
// Must wrap the interator to raise the remove event.
return listIterator(0);
}
/**
* @see java.util.Vector#lastElement()
*/
public Object lastElement() {
return getDelegate().lastElement();
}
/**
* @see java.util.Vector#lastIndexOf(java.lang.Object)
*/
public int lastIndexOf(Object elem) {
return getDelegate().lastIndexOf(elem);
}
/**
* @see java.util.Vector#lastIndexOf(java.lang.Object, int)
*/
public int lastIndexOf(Object elem, int index) {
return getDelegate().lastIndexOf(elem, index);
}
/**
* @see java.util.AbstractList#listIterator()
*/
public ListIterator listIterator() {
return listIterator(0);
}
/**
* @see java.util.AbstractList#listIterator(int)
*/
public ListIterator listIterator(final int index) {
// Must wrap the interator to raise the remove event.
return new ListIterator() {
ListIterator delegateIterator = IndirectList.this.getDelegate().listIterator(index);
Object currentObject;
public boolean hasNext() {
return this.delegateIterator.hasNext();
}
public boolean hasPrevious() {
return this.delegateIterator.hasPrevious();
}
public int previousIndex() {
return this.delegateIterator.previousIndex();
}
public int nextIndex() {
return this.delegateIterator.nextIndex();
}
public Object next() {
this.currentObject = this.delegateIterator.next();
return this.currentObject;
}
public Object previous() {
this.currentObject = this.delegateIterator.previous();
return this.currentObject;
}
public void remove() {
this.delegateIterator.remove();
IndirectList.this.raiseRemoveChangeEvent(this.currentObject, Integer.valueOf(this.delegateIterator.nextIndex()));
}
public void set(Object object) {
this.delegateIterator.set(object);
Integer index = Integer.valueOf(this.delegateIterator.previousIndex());
IndirectList.this.raiseRemoveChangeEvent(this.currentObject, index, true);
IndirectList.this.raiseAddChangeEvent(object, index, true);
}
public void add(Object object) {
this.delegateIterator.add(object);
IndirectList.this.raiseAddChangeEvent(object, Integer.valueOf(this.delegateIterator.previousIndex()));
}
};
}
/**
* @see java.util.Vector#remove(int)
*/
public Object remove(int index) {
Object value = getDelegate().remove(index);
this.raiseRemoveChangeEvent(value, Integer.valueOf(index));
return value;
}
/**
* @see java.util.Vector#remove(java.lang.Object)
*/
public boolean remove(Object element) {
if (!this.isRegistered) {
return getDelegate().remove(element);
}
// PERF: If not instantiated just record the removal to avoid the instantiation.
if (shouldAvoidInstantiation()) {
if (hasAddedElements() && getAddedElements().contains(element)) {
getAddedElements().remove(element);
} else if (getRemovedElements().contains(element)) {
// Must avoid recursion for relationship maintenance.
return false;
} else {
getRemovedElements().add(element);
}
this.raiseRemoveChangeEvent(element, null);
return true;
} else {
int index = this.getDelegate().indexOf(element);
if(index > -1) {
this.getDelegate().remove(index);
this.raiseRemoveChangeEvent(element, index);
return true;
}
}
return false;
}
/**
* @see java.util.Vector#removeAll(java.util.Collection)
*/
public boolean removeAll(Collection c) {
// Must trigger remove events if tracked or uow.
if (hasBeenRegistered() || hasTrackedPropertyChangeListener()) {
boolean hasChanged = false;
Iterator objects = c.iterator();
while (objects.hasNext()) {
hasChanged |= remove(objects.next());
}
return hasChanged;
}
return getDelegate().removeAll(c);
}
/**
* @see java.util.Vector#removeAllElements()
*/
public void removeAllElements() {
// Must trigger remove events if tracked or uow.
if (hasBeenRegistered() || hasTrackedPropertyChangeListener()) {
Iterator objects = iterator();
while (objects.hasNext()) {
objects.next();
objects.remove();
}
return;
}
getDelegate().removeAllElements();
}
/**
* @see java.util.Vector#removeElement(java.lang.Object)
*/
public boolean removeElement(Object obj) {
return remove(obj);
}
/**
* @see java.util.Vector#removeElementAt(int)
*/
public void removeElementAt(int index) {
remove(index);
}
/**
* @see java.util.Vector#retainAll(java.util.Collection)
*/
public boolean retainAll(Collection c) {
// Must trigger remove events if tracked or uow.
if (hasBeenRegistered() || hasTrackedPropertyChangeListener()) {
Iterator objects = getDelegate().iterator();
while (objects.hasNext()) {
Object object = objects.next();
if (!c.contains(object)) {
objects.remove();
raiseRemoveChangeEvent(object, null);
}
}
return true;
}
return getDelegate().retainAll(c);
}
/**
* @see java.util.Vector#set(int, java.lang.Object)
*/
public Object set(int index, Object element) {
Object oldValue = getDelegate().set(index, element);
Integer bigIntIndex = Integer.valueOf(index);
raiseRemoveChangeEvent(oldValue, bigIntIndex, true);
raiseAddChangeEvent(element, bigIntIndex, true);
return oldValue;
}
/**
* @see java.util.Vector#setElementAt(java.lang.Object, int)
*/
public void setElementAt(Object obj, int index) {
set(index, obj);
}
/**
* @see java.util.Vector#setSize(int)
*/
public void setSize(int newSize) {
// Must trigger remove events if tracked or uow.
if (hasBeenRegistered() || hasTrackedPropertyChangeListener()) {
if (newSize > size()) {
for (int index = size(); index > newSize; index--) {
this.remove(index - 1);
}
}
}
getDelegate().setSize(newSize);
}
/**
* INTERNAL
* Set whether this collection should attempt do deal with adds and removes without retrieving the
* collection from the dB
*/
public void setUseLazyInstantiation(boolean useLazyInstantiation){
this.useLazyInstantiation = useLazyInstantiation;
}
/**
* INTERNAL:
* Set the value holder.
*/
public void setValueHolder(ValueHolderInterface valueHolder) {
this.delegate = null;
this.valueHolder = valueHolder;
if (valueHolder instanceof UnitOfWorkQueryValueHolder) {
this.isRegistered = true;
}
}
/**
* @see java.util.Vector#size()
*/
public int size() {
return getDelegate().size();
}
/**
* Return whether this collection should attempt do deal with adds and removes without retrieving the
* collection from the dB
* @return
*/
protected boolean shouldUseLazyInstantiation(){
return useLazyInstantiation;
}
/**
* @see java.util.Vector#subList(int, int)
*/
public List subList(int fromIndex, int toIndex) {
return getDelegate().subList(fromIndex, toIndex);
}
/**
* @see java.util.Vector#toArray()
*/
public Object[] toArray() {
return getDelegate().toArray();
}
/**
* @see java.util.Vector#toArray(java.lang.Object[])
*/
public Object[] toArray(Object[] a) {
return getDelegate().toArray(a);
}
/**
* PUBLIC:
* Use the java.util.Vector#toString(); but wrap it with braces to indicate
* there is a bit of indirection.
* Don't allow this method to trigger a database read.
* @see java.util.Vector#toString()
*/
public String toString() {
if (ValueHolderInterface.shouldToStringInstantiate) {
return getDelegate().toString();
}
if (this.isInstantiated()) {
return "{" + getDelegate().toString() + "}";
} else {
return "{" + org.eclipse.persistence.internal.helper.Helper.getShortClassName(this.getClass()) + ": not instantiated}";
}
}
/**
* @see java.util.Vector#trimToSize()
*/
public void trimToSize() {
getDelegate().trimToSize();
}
/**
* INTERNAL:
* Return the property change listener for change tracking.
*/
public PropertyChangeListener _persistence_getPropertyChangeListener() {
return changeListener;
}
/**
* INTERNAL:
* Return if the collection has a property change listener for change tracking.
*/
public boolean hasTrackedPropertyChangeListener() {
return this.changeListener != null;
}
/**
* INTERNAL:
* Set the property change listener for change tracking.
*/
public void _persistence_setPropertyChangeListener(PropertyChangeListener changeListener) {
this.changeListener = changeListener;
if (changeListener != null) {
this.isRegistered = true;
}
}
/**
* INTERNAL:
* Return the mapping attribute name, used to raise change events.
*/
public String getTrackedAttributeName() {
return attributeName;
}
/**
* INTERNAL:
* Set the mapping attribute name, used to raise change events.
* This is required if the change listener is set.
*/
public void setTrackedAttributeName(String attributeName) {
this.attributeName = attributeName;
}
/**
* INTERNAL:
* Return the elements that have been removed before instantiation.
*/
public Collection getRemovedElements() {
if (removedElements == null) {
removedElements = new ArrayList();
}
return removedElements;
}
/**
* INTERNAL:
* Return the elements that have been added before instantiation.
*/
public Collection getAddedElements() {
if (addedElements == null) {
addedElements = new ArrayList();
}
return addedElements;
}
/**
* INTERNAL:
* Return if any elements that have been added before instantiation.
*/
public boolean hasAddedElements() {
return (addedElements != null) && (!addedElements.isEmpty());
}
/**
* INTERNAL:
* Return if any elements that have been removed before instantiation.
*/
public boolean hasRemovedElements() {
return (removedElements != null) && (!removedElements.isEmpty());
}
/**
* INTERNAL:
* Return if any elements that have been added or removed before instantiation.
*/
public boolean hasDeferredChanges() {
return hasRemovedElements() || hasAddedElements();
}
/**
* INTERNAL:
* Return if add/remove should trigger instantiation or avoid.
* Current instantiation is avoided is using change tracking.
*/
protected boolean shouldAvoidInstantiation() {
return (!isInstantiated()) && (shouldUseLazyInstantiation()) && (_persistence_getPropertyChangeListener() instanceof AttributeChangeListener) && !usesListOrderField() && ((WeavedAttributeValueHolderInterface)getValueHolder()).shouldAllowInstantiationDeferral();
}
/**
* INTERNAL:
* Returns whether the mapping has listOrderField.
*/
protected boolean usesListOrderField() {
if(this.valueHolder instanceof UnitOfWorkValueHolder) {
return ((CollectionMapping)((UnitOfWorkValueHolder)this.valueHolder).getMapping()).getListOrderField() != null;
} else {
return false;
}
}
public boolean isListOrderBrokenInDb() {
return this.isListOrderBrokenInDb;
}
public void setIsListOrderBrokenInDb(boolean isBroken) {
this.isListOrderBrokenInDb = isBroken;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy