How to use

IndirectList

in

org.eclipse.persistence.indirection

/**
 * INTERNAL:
 * Return a new Vector.
 */
public Object containerInstance() {
  return new IndirectList();
}
 

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);
  }
}

/**
 * @see java.util.Vector#addElement(java.lang.Object)
 */
@Override
public void addElement(E obj) {
  add(obj);
}

/**
 * INTERNAL:
 * Return if any elements that have been added or removed before instantiation.
 */
public boolean hasDeferredChanges() {
  return hasRemovedElements() || hasAddedElements();
}
 

/**
 * @see java.util.Vector#add(int, java.lang.Object)
 */
@Override
public void add(int index, E element) {
  getDelegate().add(index, element);
  raiseAddChangeEvent(element, index);
}

/**
 * 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();
}

Vector<E> newDelegate = (Vector<E>) getValueHolder().getValue();
if (newDelegate == null) {
  newDelegate = new Vector<>(this.initialCapacity, this.capacityIncrement);
  if(((IndirectList) newDelegate).isListOrderBrokenInDb()) {
    this.isListOrderBrokenInDb = true;
  newDelegate = ((IndirectList<E>) newDelegate).getDelegate();
if (hasAddedElements()) {
  for (E element: getAddedElements()) {
if (hasRemovedElements()) {
  for (E element: getRemovedElements()) {
    newDelegate.remove(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 (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#remove(java.lang.Object)
 */
@Override
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((E) 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#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);
}

/**
 * PUBLIC:
 * @see java.util.Vector#contains(java.lang.Object)
 */
@Override
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);
}

protected void raiseRemoveChangeEvent(Object element, Integer index, boolean isSet) {
  if (hasTrackedPropertyChangeListener()) {
    _persistence_getPropertyChangeListener().propertyChange(new CollectionChangeEvent(this, getTrackedAttributeName(), this, element, CollectionChangeEvent.REMOVE, index, isSet));
  }
  if (hasBeenRegistered()) {
    ((UnitOfWorkQueryValueHolder)getValueHolder()).updateForeignReferenceRemove(element);
  }
}

/**
 * INTERNAL:
 * Return the real collection object.
 * This will force instantiation.
 */
public Object getDelegateObject() {
  return getDelegate();
}

@Override
public synchronized void replaceAll(UnaryOperator<E> operator) {
  // Must trigger remove/add events if tracked or uow.
  if (hasBeenRegistered() || hasTrackedPropertyChangeListener()) {
    List<E> del = getDelegate();
    for (int i = 0; i < del.size(); i++) {
      set(i, operator.apply(del.get(i)));
    }
  } else {
    getDelegate().replaceAll(operator);
  }
}

/**
 * @see java.util.Vector#set(int, java.lang.Object)
 */
public Object set(int index, Object element) {
  Object oldValue = getDelegate().set(index, element);
  Integer bigIntIndex = new Integer(index);
  raiseRemoveChangeEvent(oldValue, bigIntIndex, true);
  raiseAddChangeEvent(element, bigIntIndex, true);
  return oldValue;
}

/**
 * @see java.util.Vector#remove(int)
 */
@Override
public E remove(int index) {
  E value = getDelegate().remove(index);
  this.raiseRemoveChangeEvent(value, index);
  return value;
}

/**
 * INTERNAL:
 * return whether this IndirectList has been registered with the UnitOfWork
 */
public boolean hasBeenRegistered() {
  return getValueHolder() instanceof UnitOfWorkQueryValueHolder;
}

/**
 * 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;
}    
 

Vector delegate = (Vector<E>)getValueHolder().getValue();
if (delegate == null) {
  delegate = new Vector<>(this.initialCapacity, this.capacityIncrement);
  if(((IndirectList) delegate).isListOrderBrokenInDb()) {
    this.isListOrderBrokenInDb = true;
  delegate = ((IndirectList) delegate).getDelegate();
if (hasAddedElements()) {
  int size = getAddedElements().size();
  for (int index = 0; index < size; index++) {
    Object element = ((List)getAddedElements()).get(index);
if (hasRemovedElements()) {
  int size = getRemovedElements().size();
  for (int index = 0; index < size; index++) {
    delegate.remove(((List)getRemovedElements()).get(index));

/**
 * @see java.util.Vector#add(java.lang.Object)
 */
@Override
public boolean add(E 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;
}