Class KeyCollectionImpl<E>

java.lang.Object
org.magicwerk.brownies.collections.KeyCollectionImpl<E>
Type Parameters:
E - type of elements stored in the list
All Implemented Interfaces:
Serializable, Cloneable, Iterable<E>, Collection<E>, ICollection<E>
Direct Known Subclasses:
Key1Collection, Key2Collection, KeyCollection
public class KeyCollectionImpl<E> extends Object implements ICollection<E>, Serializable, Cloneable
Add: - validation fails: null / constraint - duplicate not allowed (mode replace) Triggers: - triggers are called after the add/remove operation has finished - if an exception is thrown in the trigger, the change already made to the collection is not undone
Author:
Thomas Mauch
See Also:

  • Method Details

    • isSorted

      public boolean isSorted()
      Determines whether this list is sorted or not.
      Returns:
      true if this a sorted list, false if not

    • add

      public boolean add(E elem)
      Specified by:
      add in interface Collection<E>

    • doAdd

      protected boolean doAdd(E elem)
      Helper method for adding an element to the collection. This is the only method which really adds an element. Override if you need to validity checks before adding. This method is called by both add() and addAll().

    • remove

      public boolean remove(Object elem)
      Specified by:
      remove in interface Collection<E>

    • put

      protected E put(E elem)
      Adds or replaces element. If there is no such element, the element is added. If there is such an element, the element is replaced. So said simply, it is a shortcut for the following code: 
      remove(elem);
add(elem);
      However the method is atomic in the sense that all or none operations are executed. So if there is already such an element, but adding the new one fails due to a constraint violation, the old element remains in the list.
      Parameters:
      elem - element
      Returns:
      element which has been replaced or null otherwise

    • size

      public int size()
      Specified by:
      size in interface Collection<E>

    • isEmpty

      public boolean isEmpty()
      Specified by:
      isEmpty in interface Collection<E>

    • contains

      public boolean contains(Object o)
      Specified by:
      contains in interface Collection<E>

    • iterator

      public Iterator<E> iterator()
      Specified by:
      iterator in interface Collection<E>
      Specified by:
      iterator in interface Iterable<E>

    • addAll

      public boolean addAll(Collection<? extends E> c)
      Specified by:
      addAll in interface Collection<E>

    • toList

      public GapList<E> toList()
      Returns all elements contained in this collection as list.
      Returns:
      all elements contained in this collection as list

    • toArray

      public Object[] toArray()
      Specified by:
      toArray in interface Collection<E>

    • toArray

      public <T> T[] toArray(T[] a)
      Specified by:
      toArray in interface Collection<E>

    • containsAll

      public boolean containsAll(Collection<?> c)
      Specified by:
      containsAll in interface Collection<E>

    • removeAll

      public boolean removeAll(Collection<?> c)
      Specified by:
      removeAll in interface Collection<E>

    • retainAll

      public boolean retainAll(Collection<?> c)
      Specified by:
      retainAll in interface Collection<E>

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • copy

      public KeyCollectionImpl copy()
      Returns a copy of this collection with all its elements. The new collection will use the same comparator, ordering, etc.
      Specified by:
      copy in interface ICollection<E>
      Returns:
      a copy of this collection

    • crop

      public KeyCollectionImpl crop()
      Returns a copy of this collection but without elements. The new collection will use the same comparator, ordering, etc.
      Specified by:
      crop in interface ICollection<E>
      Returns:
      an empty copy of this collection

    • clone

      protected Object clone()
      Overrides:
      clone in class Object

    • initClone

      protected void initClone(Object that)
      Initialize this object after the bitwise copy has been made by Object.clone().
      Parameters:
      that - source object

    • asSet

      public Set<E> asSet()
      Returns a Set view of the element set.
      Returns:
      set view
      Throws:
      IllegalArgumentException - if the element set cannot be viewed as Set

    • clear

      public void clear()
      Specified by:
      clear in interface Collection<E>

    • containsKey

      protected <K> boolean containsKey(int keyIndex, K key)
      Checks whether the specified key exists in this list.
      Parameters:
      keyIndex - key index
      key - key to look for
      Returns:
      true if the key exists, otherwise false

    • getDistinctKeys

      protected Set<?> getDistinctKeys(int keyIndex)
      Returns set containing all distinct keys.
      Parameters:
      keyIndex - key index
      Returns:
      list containing all distinct keys

    • getAllKeys

      protected IList<?> getAllKeys(int keyIndex)
      Returns list containing all keys in element order.
      Parameters:
      keyIndex - key index
      Returns:
      list containing all keys

    • getKeyMapper

      protected Function<E,Object> getKeyMapper(int keyIndex)
      Returns mapper for specified key map.
      Parameters:
      keyIndex - key index
      Returns:
      mapper for specified key map

    • getByKey

      protected E getByKey(int keyIndex, Object key)
      Returns value for specified key. If there are several values for this key, the first is returned. If the key is not found, null is returned.
      Parameters:
      keyIndex - key index
      key - key to find
      Returns:
      value of specified key or null

    • getAllByKey

      protected Collection<E> getAllByKey(int keyIndex, Object key)
      Returns a collection with all elements with the specified key.
      Parameters:
      keyIndex - key index
      key - key which elements must have
      Returns:
      list with all elements

    • getAllByKey

      protected void getAllByKey(int keyIndex, Object key, Collection<E> coll)
      Fill the collection with all elements with the specified key.
      Parameters:
      keyIndex - key index
      key - key which elements must have
      coll - collection with all elements

    • getCountByKey

      protected int getCountByKey(int keyIndex, Object key)
      Returns number of elements with specified key.
      Parameters:
      keyIndex - key index
      key - key which elements must have
      Returns:
      number of elements with key

    • invalidate

      protected void invalidate(E elem)
      Invalidate element, i.e. all keys of the element are extracted again and stored in the key maps. Old key values are removed if needed. You must call an invalidate method if an element's key value has changed after adding it to the collection.
      Parameters:
      elem - element to invalidate

    • invalidateKey

      protected void invalidateKey(int keyIndex, Object oldKey, Object newKey, E elem)
      Invalidate key value of element. You must call an invalidate method if an element's key value has changed after adding it to the collection.
      Parameters:
      keyIndex - key index
      oldKey - old key value
      newKey - new key value
      elem - element to invalidate (can be null if there are no duplicates with this key)

    • removeByKey

      protected E removeByKey(int keyIndex, Object key)

    • doRemoveByKey

      protected Option<E> doRemoveByKey(int keyIndex, Object key)
      Removes element by key. It adjusts the size, but does not call triggers. If there are duplicates, only one element is removed.
      Parameters:
      keyIndex - index of key map
      key - key of element to remove
      Returns:
      option with removed element as value or option without value if no element has been removed

    • removeAllByKey

      protected Collection<E> removeAllByKey(int keyIndex, Object key)
      Removes element by key. If there are duplicates, all elements are removed.
      Parameters:
      keyIndex - key index
      key - key of element to remove
      Returns:
      true if elements have been removed, false otherwise

    • removeAllByKey

      protected void removeAllByKey(int keyIndex, Object key, Collection<E> removeds)

    • putByKey

      protected E putByKey(int keyIndex, E elem, boolean replace)

    • equals

      public boolean equals(Object o)
      Specified by:
      equals in interface Collection<E>
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface Collection<E>
      Overrides:
      hashCode in class Object

    • getAll

      public Collection<E> getAll(E elem)
      Returns all equal elements.
      Parameters:
      elem - element
      Returns:
      all equal elements (never null)

    • getCount

      public int getCount(E elem)
      Returns the number of equal elements.
      Parameters:
      elem - element
      Returns:
      number of equal elements

    • removeAll

      public Collection<E> removeAll(E elem)
      Removes all equal elements.
      Parameters:
      elem - element
      Returns:
      removed equal elements (never null)

    • getDistinct

      public Set<E> getDistinct()
      Returns all distinct elements in the same order as in the collection.
      Returns:
      set with distinct elements

    • filter

      public KeyCollectionImpl filter(Predicate<? super E> predicate)
      Description copied from interface: ICollection
      Create a new collection by applying the specified filter to all elements. The returned collection has the same type as the original one.
      Specified by:
      filter in interface ICollection<E>
      Parameters:
      predicate - filter predicate
      Returns:
      created list

    • map

      public <R> IList<R> map(Function<E,R> func)
      Description copied from interface: ICollection
      Create a new list by applying the specified mapping function to all elements. The returned list is of type IList, typically GapList unless the original type is BigList.
      Specified by:
      map in interface ICollection<E>
      Parameters:
      func - mapping function
      Returns:
      created list

    • flatMap

      public <R, C extends Collection<R>> IList<R> flatMap(Function<E,C> func)
      Description copied from interface: ICollection
      Create a new list by applying the specified mapping function to all elements. The returned list is of type IList, typically GapList unless the original type is BigList.
      Specified by:
      flatMap in interface ICollection<E>
      Parameters:
      func - mapping function
      Returns:
      created list

    • mapFilter

      public <R> IList<R> mapFilter(Function<E,R> func, Predicate<R> filter)
      Description copied from interface: ICollection
      Create a new list by applying the specified mapping function to all elements and then filtering it. The returned list is of type IList, typically GapList unless the original type is BigList.
      Specified by:
      mapFilter in interface ICollection<E>
      Parameters:
      func - mapping function
      filter - filter predicate
      Returns:
      created list

    • filterMap

      public <R> IList<R> filterMap(Predicate<E> filter, Function<E,R> func)
      Description copied from interface: ICollection
      Create a new list by applying the specified filter first and then the mapping function to all elements selected. The returned list is of type IList, typically GapList unless the original type is BigList.
      Specified by:
      filterMap in interface ICollection<E>
      Parameters:
      filter - filter predicate
      func - mapping function
      Returns:
      created list