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
See Also:
  • Field Details

    • SYMBOL_ADDED

      static final Object SYMBOL_ADDED
    • SYMBOL_NOT_ADDED

      static final Object SYMBOL_NOT_ADDED
    • SYMBOL_ERROR_NULL_KEY

      static final Object SYMBOL_ERROR_NULL_KEY
    • DEBUG_CHECK

      private static final boolean DEBUG_CHECK
      If true the invariants are checked for debugging
      See Also:
    • size

      int size
      Size of collection. The size is cached, as the key maps do not know the size if duplicates are allowed.
    • maxSize

      int maxSize
      Maximum absolute or windows size, 0 if this list has no size restriction
    • movingWindow

      boolean movingWindow
      If maxSize is greater than 0, this boolean indicates whether the size is for window (true) or absolute (false)
    • keyMaps

      Maps for element and all defined keys. keyMaps may be null for a KeyListImpl without keys. Index 0 is reserved for the elem key using an IdentMapper. If there is no elem key, keyMaps[0] contains null.
    • orderByKey

      int orderByKey
      Index of key map which defines order (-1 for no order, only possible for KeyList). If an order key is defined for a KeyList, it must be implemented as KeyMap.keysList.
    • allowNullElem

      boolean allowNullElem
      True to allow null elements, false to reject them.
    • setBehavior

      boolean setBehavior
      true if collections implements Set, false for @{link Collection} (behavior of add(E) changes)
    • constraint

      Predicate<E> constraint
      All elements in the list must fulfill this predicate, if null, all elements are allowed
    • beforeInsertTrigger

      Consumer<E> beforeInsertTrigger
    • afterInsertTrigger

      Consumer<E> afterInsertTrigger
    • beforeDeleteTrigger

      Consumer<E> beforeDeleteTrigger
    • afterDeleteTrigger

      Consumer<E> afterDeleteTrigger
    • keyList

      KeyListImpl<E> keyList
      Back pointer to KeyListImpl if this object is used to implement a KeyList, Key1List, Key2List. Otherwise null if it is part of a KeyCollection, Key1Collection, Key2Collection.
  • Constructor Details

    • KeyCollectionImpl

      KeyCollectionImpl()
      Private constructor.
  • Method Details

    • initCopy

      void initCopy(KeyCollectionImpl<E> that)
      Initialize object for copy() operation.
      Parameters:
      that - source object
    • initCrop

      void initCrop(KeyCollectionImpl<E> that)
      Initialize object for crop() operation.
      Parameters:
      that - source object
    • debugCheck

      void debugCheck()
      Private method to check invariant of KeyCollectionImpl. It is only used for debugging.
    • doDebugCheck

      private void doDebugCheck(KeyCollectionImpl.KeyMap keyMap)
    • getKey

      Object getKey(int keyIndex, E elem)
    • isSorted

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

      boolean isSortedByElem()
    • getElemSortComparator

      Comparator<Object> getElemSortComparator()
    • hasElemSet

      boolean hasElemSet()
    • checkIndex

      void checkIndex(int loIndex, int hiIndex, E elem)
      Check whether index is valid for the sorted list.
    • addSorted

      void addSorted(int index, E elem)
      Called from KeyListImpl.doAdd() to add element to sorted list. It calls beforeInsert() and afterInsert() as needed.
      Parameters:
      index - index where element will be added
      elem - element to add
    • addUnsorted

      void addUnsorted(E elem)
      Called from KeyListImpl.doAdd() to add element to sorted list. It calls beforeInsert() and afterInsert() as needed.
      Parameters:
      elem - element to add
    • setSorted

      void setSorted(int index, E elem, E oldElem)
    • binarySearchSorted

      int binarySearchSorted(E elem)
    • indexOfSorted

      int indexOfSorted(E elem)
    • checkElemAllowed

      void checkElemAllowed(E elem)
      Checks whether element is allowed in collection (null/constraint). The constraint is also checked if the element is null.
      Parameters:
      elem - element to check
      Throws:
      IllegalArgumentException - if the element is not allowed
    • errorNullElement

      static void errorNullElement()
    • errorConstraintElement

      static void errorConstraintElement()
    • errorNullKey

      static void errorNullKey()
    • errorMaxSize

      static void errorMaxSize()
    • errorDuplicateKey

      static void errorDuplicateKey(Object key)
    • errorInvalidData

      static void errorInvalidData()
    • errorInvalidIndex

      static void errorInvalidIndex()
    • errorInvalidateNotSupported

      static void errorInvalidateNotSupported()
    • errorInvalidSetBehavior

      static void errorInvalidSetBehavior()
    • errorInvaliDuplicates

      static void errorInvaliDuplicates()
    • beforeInsert

      private void beforeInsert(E elem)
      This method is called before a new element is added. If the addition should not happen, an exception can be thrown.
      Parameters:
      elem - element to insert
    • afterInsert

      private void afterInsert(E elem)
      This method is called after a new element has been added.
      Parameters:
      elem - element which has been inserted
    • beforeDelete

      private void beforeDelete(E elem)
      This method is called before an existing element is removed. If the deletion should not happen, an exception can be thrown.
      Parameters:
      elem - element to delete
    • afterDelete

      private void afterDelete(E elem)
      This method is called after an existing element has been removed.
      Parameters:
      elem - element which has been deleted
    • 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>
    • checkAddElem

      void checkAddElem(E elem)
    • remove

      boolean remove(Object elem, KeyCollectionImpl.KeyMap ignore)
      Remove element.
      Parameters:
      elem - element to remove
      ignore - KeyMap to ignore (null to remove element from all key maps)
      Returns:
      true if element has been removed
    • 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>
    • isContainsFast

      boolean isContainsFast()
      Determines whether calling contains() will be fast, i.e. it can use some sort of key lookup instead of traversing through all elements.
      Returns:
      true if calling contains() will be fast, otherwise false
    • 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
    • doRemove

      Option<E> doRemove(Object elem, KeyCollectionImpl.KeyMap ignore)
      Remove element. It does not adjust the size and does not call triggers.
      Parameters:
      elem - element to remove
      ignore - KeyMap to ignore (null to remove element from all key maps)
      Returns:
      optional with element which has been removed
    • 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>
    • doClear

      private void doClear(KeyCollectionImpl.KeyMap<E,?> keyMap)
    • doAddThrow

      boolean doAddThrow(E elem, KeyCollectionImpl.KeyMap<?,?> ignore)
    • doAdd

      Object doAdd(E elem, KeyCollectionImpl.KeyMap<?,?> ignore)
      Add element. This method does not change size, check whether the element may be added or calls any triggers, so this must be done by the calling method.
      Parameters:
      elem - element to add
      ignore - KeyMap to ignore (null to add element to all key maps)
      Returns:
      SYMBOL_ADDED if element has successfully been added, SYMBOL_NOT_ADDED if element has not been added, SYMBOL_ERROR_NULL_KEY if a null key is not allowed, otherwise the key which is rejected because of a duplicate exception
    • 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
    • checkKeyMap

      void checkKeyMap(int keyIndex)
      Check whether there is a KeyMap (can also be the elements set) with specified index.
      Parameters:
      keyIndex - key map index
      Throws:
      IllegalArgumentException - if there is no such key map
    • checkAsMap

      void checkAsMap(int keyIndex)
      Check whether the key map can be viewed as Map.
      Parameters:
      keyIndex - key map index
      Throws:
      IllegalArgumentException - if the key map cannot be viewed as Map
    • checkAsSet

      void checkAsSet()
      Check whether the element set can be viewed as Set.
      Parameters:
      keyIndex - key map index
      Throws:
      IllegalArgumentException - if the element set cannot be viewed as Set
    • getKeyMap

      KeyCollectionImpl.KeyMap<E,Object> getKeyMap(int keyIndex)
    • 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
    • getByKey

      private <K> E getByKey(KeyCollectionImpl.KeyMap<E,K> keyMap, K key)
    • 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
    • doGetAllByKey

      private <K> void doGetAllByKey(KeyCollectionImpl.KeyMap<E,K> keyMap, K key, Collection<E> coll)
    • 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
    • getCountByKey

      private <K> int getCountByKey(KeyCollectionImpl.KeyMap<E,K> keyMap, K 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)
    • doInvalidateKey

      E doInvalidateKey(int keyIndex, Object oldKey, Object newKey, E elem)
    • invalidate

      private Option<Object> invalidate(KeyCollectionImpl.KeyMap keyMap, Object elem)
      Parameters:
      keyMap - key map
      elem - elem to invalidate
      Returns:
      null if key for keyMap and element is correct, else key which must be added to keymap
    • 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