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