예제 #1
0
 /**
  * {@inheritDoc}
  *
  * <p>This implementation iterates over the elements of this list, checking each element in turn
  * to see if it's contained in <code>coll</code>. If it's not contained, it's removed from this
  * list. As a consequence, it is advised to use a collection type for <code>coll</code> that
  * provides a fast (e.g. O(1)) implementation of {@link Collection#contains(Object)}.
  */
 @Override
 public boolean retainAll(final Collection<?> coll) {
   boolean result = set.retainAll(coll);
   if (result == false) {
     return false;
   }
   if (set.size() == 0) {
     super.clear();
   } else {
     // use the set as parameter for the call to retainAll to improve performance
     super.retainAll(set);
   }
   return result;
 }
예제 #2
0
 /**
  * Adds an element to a specific index in the list if it is not already present.
  *
  * <p><i>(Violation)</i> The <code>List</code> interface makes the assumption that the element is
  * always inserted. This may not happen with this implementation.
  *
  * @param index the index to insert at
  * @param object the object to add
  */
 public void add(int index, Object object) {
   // adds element if it is not contained already
   if (set.contains(object) == false) {
     super.add(index, object);
     set.add(object);
   }
 }
예제 #3
0
 @Override
 public boolean remove(final Object object) {
   final boolean result = set.remove(object);
   if (result) {
     super.remove(object);
   }
   return result;
 }
예제 #4
0
 /**
  * Adds an element to a specific index in the list if it is not already present.
  *
  * <p><i>(Violation)</i> The <code>List</code> interface makes the assumption that the element is
  * always inserted. This may not happen with this implementation.
  *
  * @param index the index to insert at
  * @param object the object to add
  */
 @Override
 public void add(final int index, final E object) {
   // adds element if it is not contained already
   if (set.contains(object) == false) {
     super.add(index, object);
     set.add(object);
   }
 }
예제 #5
0
  /**
   * Sets the value at the specified index avoiding duplicates.
   *
   * <p>The object is set into the specified index. Afterwards, any previous duplicate is removed If
   * the object is not already in the list then a normal set occurs. If it is present, then the old
   * version is removed.
   *
   * @param index the index to insert at
   * @param object the object to set
   * @return the previous object
   */
  public Object set(int index, Object object) {
    int pos = indexOf(object);
    Object removed = super.set(index, object);
    if (pos == -1 || pos == index) {
      return removed;
    }

    // the object is already in the uniq list
    // (and it hasn't been swapped with itself)
    super.remove(pos); // remove the duplicate by index
    set.remove(removed); // remove the item deleted by the set
    return removed; // return the item deleted by the set
  }
예제 #6
0
  /**
   * Sets the value at the specified index avoiding duplicates.
   *
   * <p>The object is set into the specified index. Afterwards, any previous duplicate is removed.
   * If the object is not already in the list then a normal set occurs. If it is present, then the
   * old version is removed.
   *
   * @param index the index to insert at
   * @param object the object to set
   * @return the previous object
   */
  @Override
  public E set(final int index, final E object) {
    final int pos = indexOf(object);
    final E removed = super.set(index, object);

    if (pos != -1 && pos != index) {
      // the object is already in the unique list
      // (and it hasn't been swapped with itself)
      super.remove(pos); // remove the duplicate by index
    }

    set.remove(removed); // remove the item deleted by the set
    set.add(object); // add the new item to the unique set

    return removed; // return the item deleted by the set
  }
예제 #7
0
 public void clear() {
   super.clear();
   set.clear();
 }
예제 #8
0
 @Override
 public void clear() {
   super.clear();
   set.clear();
 }