Package eu.simuline.util

Class CollectionsExt.ImmutableCyclicList<E>

  • Type Parameters:
    E - the class of the elements of this list.
    All Implemented Interfaces:
    CyclicList<E>, Iterable<E>, Collection<E>
    Enclosing class:
    CollectionsExt<E>
    public static final class CollectionsExt.ImmutableCyclicList<E>
extends Object
implements CyclicList<E>
    Represents an immutable cyclic list by throwing an exception when invoking a method which modifies this list.

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void add​(int index, E element)
      Inserts the specified element at the specified position in this list (optional operation).
      boolean add​(E element)  
      void addAll​(int index, Iterator<E> iter)
      Inserts the cyclic list of the specified iterator at the specified position in this list (optional operation).
      void addAll​(int index, List<? extends E> list)
      Inserts the specified list at the given position in this cyclic list (optional operation).
      boolean addAll​(Collection<? extends E> coll)  
      List<E> asList()  
      List<E> asList​(int index)
      Returns a List containing all of the elements in this cyclic list in proper sequence.
      void clear()
      Removes all of the elements from this list (optional operation).
      boolean contains​(Object obj)
      Returns true if this list contains the specified element.
      boolean containsAll​(Collection<?> coll)  
      CyclicList<E> cycle​(int num)
      Returns a cyclic permutation p of this cyclic list.
      CyclicIterator<E> cyclicIterator​(int index)
      Returns a CyclicIterator of the elements in this list (in proper sequence), starting at the specified position in this list.
      boolean equals​(Object obj)
      Compares the specified object with this cyclic list for equality.
      boolean equalsCyclic​(Object obj)
      Compares the specified object with this cyclic list for equality.
      E get​(int index)
      Returns the element at the specified position in this list.
      CyclicList<E> getCopy​(int len)
      Returns a CyclicList which is by copying this list step by step such that the length of the result is len.
      int getIndexOf​(int idx, Object obj)
      Returns the non-negative index in this cyclic list of the first occurrence of the specified element, or -1 if this cyclic list does not contain this element.
      CyclicList<E> getInverse()
      Returns the inverse of this cyclic list: the list with inverse order.
      int hashCode()
      Returns the hash code value for this cyclic list.
      int hashCodeCyclic()
      Returns a hash code value for this cyclic list which is invariant under cyclic permutation.
      boolean isEmpty()
      Returns true iff this list contains no elements.
      Iterator<E> iterator()
      Returns cyclicIterator(index) for some unspecified index.
      E remove​(int index)
      Removes the element at the specified position in this list (optional operation).
      boolean remove​(Object obj)  
      boolean removeAll​(Collection<?> coll)  
      void replace​(int index, Iterator<E> iter)
      Replaces the element at the specified position in this list with the cyclic list of the specified iterator (optional operation).
      void replace​(int index, List<E> list)
      Replaces the element at the specified position in this list with the specified list (optional operation).
      boolean retainAll​(Collection<?> coll)  
      E set​(int index, E element)
      Replaces the element at the specified position in this list with the specified element (optional operation).
      int shiftIndex​(int index)  
      int size()
      Returns the number of elements in this list.
      Object[] toArray()  
      Object[] toArray​(int index)
      Returns an array containing all of the elements in this cyclic list in proper sequence, i.e. in the ordering returned by the iterator given by CyclicList.cyclicIterator(int).
      <E> E[] toArray​(int index, E[] array)
      Returns an array containing all of the elements in this cyclic list in proper sequence, i.e. in the ordering returned by the iterator given by CyclicList.cyclicIterator(int); the runtime type of the returned array is that of the specified array.
      <E> E[] toArray​(E[] ret)  

    • Constructor Detail

      • ImmutableCyclicList

        ImmutableCyclicList​(CyclicList<E> wrapped)

    • Method Detail

      • shiftIndex

        public int shiftIndex​(int index)
        Specified by:
        shiftIndex in interface CyclicList<E>

      • size

        public int size()
        Description copied from interface: CyclicList
        Returns the number of elements in this list. If this list contains more than Integer.MAX_VALUE elements, returns Integer.MAX_VALUE.
        Specified by:
        size in interface Collection<E>
        Specified by:
        size in interface CyclicList<E>
        Returns:
        the number of elements in this list.

      • isEmpty

        public boolean isEmpty()
        Description copied from interface: CyclicList
        Returns true iff this list contains no elements.
        Specified by:
        isEmpty in interface Collection<E>
        Specified by:
        isEmpty in interface CyclicList<E>
        Returns:
        true iff this list contains no elements.

      • getInverse

        public CyclicList<E> getInverse()
        Description copied from interface: CyclicList
        Returns the inverse of this cyclic list: the list with inverse order.
        Specified by:
        getInverse in interface CyclicList<E>
        Returns:
        The list with the same entries but inverse order.

      • contains

        public boolean contains​(Object obj)
        Description copied from interface: CyclicList
        Returns true if this list contains the specified element. More formally, returns true if and only if this list contains at least one element e such that (o==null ? e==null : o.equals(e)).
        Specified by:
        contains in interface Collection<E>
        Specified by:
        contains in interface CyclicList<E>
        Parameters:
        obj - element whose presence in this list is to be tested.
        Returns:
        true if this list contains the specified element.

      • cyclicIterator

        public CyclicIterator<E> cyclicIterator​(int index)
        Description copied from interface: CyclicList
        Returns a CyclicIterator of the elements in this list (in proper sequence), starting at the specified position in this list. The specified index indicates the first element that would be returned by an initial call to the next method. An initial call to the previous method would return the element with the specified index minus one (modulo the length of this cyclic list).
        Specified by:
        cyclicIterator in interface CyclicList<E>
        Parameters:
        index - index of first element to be returned from the list iterator (by a call to the next method). This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        Returns:
        a cyclic iterator of the elements in this list (in proper sequence), starting at the specified position in this list.

      • toArray

        public Object[] toArray​(int index)
        Description copied from interface: CyclicList
        Returns an array containing all of the elements in this cyclic list in proper sequence, i.e. in the ordering returned by the iterator given by CyclicList.cyclicIterator(int). Modifying the return value does not modify this CyclicList.
        Specified by:
        toArray in interface CyclicList<E>
        Parameters:
        index - index of the element in the cyclic list which comes first in the array returned. This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        Returns:
        an array containing all of the elements in this list in proper sequence.

      • toArray

        public <E> E[] toArray​(int index,
                       E[] array)
        Description copied from interface: CyclicList
        Returns an array containing all of the elements in this cyclic list in proper sequence, i.e. in the ordering returned by the iterator given by CyclicList.cyclicIterator(int); the runtime type of the returned array is that of the specified array. Modifying the return value does not modify this CyclicList.
        Specified by:
        toArray in interface CyclicList<E>
        Parameters:
        index - index of the element in the cyclic list which comes first in the array returned. This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        array - the array into which the elements of this list are to be stored, if it is big enough; otherwise, a new array of the same runtime type is allocated for this purpose.
        Returns:
        an array containing all of the elements in this list in proper sequence.

      • toArray

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

      • asList

        public List<E> asList​(int index)
        Description copied from interface: CyclicList
        Returns a List containing all of the elements in this cyclic list in proper sequence. Modifying the return value does not modify this CyclicList.
        Specified by:
        asList in interface CyclicList<E>
        Parameters:
        index - index of the element in the cyclic list which comes first in the List returned. This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        Returns:
        a list containing all of the elements in this cyclic list in proper sequence.

      • cycle

        public CyclicList<E> cycle​(int num)
        Description copied from interface: CyclicList
        Returns a cyclic permutation p of this cyclic list.
        Specified by:
        cycle in interface CyclicList<E>
        Parameters:
        num - an int value.
        Returns:
        a cyclic permutation p of this cyclic list. It satisfies p.size() == this.size() and p.get(i) == this.get(i+num).

      • clear

        public void clear()
        Description copied from interface: CyclicList
        Removes all of the elements from this list (optional operation). This list will be empty after this call returns (unless it throws an exception).
        Specified by:
        clear in interface Collection<E>
        Specified by:
        clear in interface CyclicList<E>

      • equals

        public boolean equals​(Object obj)
        Description copied from interface: CyclicList
        Compares the specified object with this cyclic list for equality. Returns true if and only if the specified object is also a cyclic list, both lists have the same size and all corresponding pairs of elements the two lists are equal. (Two elements e1 and e2 are equal if (e1==null ? e2==null : e1.equals(e2)).) In other words, two cyclic lists are defined to be equal if they contain the same elements in the same order according to their iterators. This definition ensures that the equals method works properly across different implementations of the CyclicList interface.
        Specified by:
        equals in interface Collection<E>
        Specified by:
        equals in interface CyclicList<E>
        Overrides:
        equals in class Object
        Parameters:
        obj - the object to be compared for equality with this list.
        Returns:
        true if the specified object is equal to this list.
        See Also:
        CyclicList.equalsCyclic(Object)

      • equalsCyclic

        public boolean equalsCyclic​(Object obj)
        Description copied from interface: CyclicList
        Compares the specified object with this cyclic list for equality. Returns true if and only if the specified object is also a cyclic list, both lists have the same size, and, up to a cyclic permutation, all corresponding pairs of elements the two lists are equal. (Two elements e1 and e2 are equal if (e1==null ? e2==null : e1.equals(e2)).) In other words, two lists are defined to be equal if they contain the same elements in the same order up to a cyclic permutation. This definition ensures that the equals method works properly across different implementations of the CyclicList interface.
        Specified by:
        equalsCyclic in interface CyclicList<E>
        Parameters:
        obj - the object to be compared for equality with this list.
        Returns:
        true if the specified object is equal to this list.
        See Also:
        CyclicList.equals(Object)

      • hashCode

        public int hashCode()
        Description copied from interface: CyclicList
        Returns the hash code value for this cyclic list. The hash code of a list is defined to be the result of the following calculation: 
          hashCode = 1;
  Iterator i = list.iterator();
  while (i.hasNext()) {
      Object obj = i.next();
      hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
  }
        This ensures that list1.equals(list2) implies that list1.hashCode()==list2.hashCode() for any two lists, list1 and list2, as required by the general contract of Object.hashCode.
        Specified by:
        hashCode in interface Collection<E>
        Specified by:
        hashCode in interface CyclicList<E>
        Overrides:
        hashCode in class Object
        Returns:
        the hash code value for this list.
        See Also:
        CyclicList.equals(Object), CyclicList.hashCodeCyclic()

      • hashCodeCyclic

        public int hashCodeCyclic()
        Description copied from interface: CyclicList
        Returns a hash code value for this cyclic list which is invariant under cyclic permutation. This kind of hash code is conform with CyclicList.equalsCyclic(Object) and with CyclicList.equals(Object), i.e. equals objects have equal hash codes. The hash code of this cyclic list is the hash code of the underlying set. This ensures that list1.equalsCyclic(list2) implies that list1.hashCodeCyclic()==list2.hashCodeCyclic() for any two lists list1 and list2.
        Specified by:
        hashCodeCyclic in interface CyclicList<E>
        Returns:
        the "cyclic hash code" value for this list.
        See Also:
        CyclicList.hashCode(), CyclicList.equalsCyclic(Object)

      • get

        public E get​(int index)
        Description copied from interface: CyclicList
        Returns the element at the specified position in this list.
        Specified by:
        get in interface CyclicList<E>
        Parameters:
        index - index of element to return. This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        Returns:
        the element at the specified position in this list.

      • set

        public E set​(int index,
             E element)
        Description copied from interface: CyclicList
        Replaces the element at the specified position in this list with the specified element (optional operation).
        Specified by:
        set in interface CyclicList<E>
        Parameters:
        index - index of element to replace.
        element - element to be stored at the specified position. This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        Returns:
        the element previously at the specified position.

      • replace

        public void replace​(int index,
                    Iterator<E> iter)
        Description copied from interface: CyclicList
        Replaces the element at the specified position in this list with the cyclic list of the specified iterator (optional operation). Places the elements of that list as returned by iter.next in this list.
        Specified by:
        replace in interface CyclicList<E>
        Parameters:
        index - index of element to replace.
        iter - a CyclicIterator which determines an index in a list which replaces this.get(i).
        See Also:
        CyclicList.replace(int, List)

      • replace

        public void replace​(int index,
                    List<E> list)
        Description copied from interface: CyclicList
        Replaces the element at the specified position in this list with the specified list (optional operation). Places the elements of that list as returned by iter.next in this list.
        Specified by:
        replace in interface CyclicList<E>
        Parameters:
        index - index of element to replace.
        list - a List which determines an index in a list which replaces this.get(i).
        See Also:
        CyclicList.replace(int, Iterator)

      • add

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

      • add

        public void add​(int index,
                E element)
        Description copied from interface: CyclicList
        Inserts the specified element at the specified position in this list (optional operation). Contract: list.add(i,o);return list.get(i) yields o. In contrast to CyclicList.set(int, E), the element currently at the specified position is not lost.
        Specified by:
        add in interface CyclicList<E>
        Parameters:
        index - index at which the specified element is to be inserted. This is interpreted modulo the length of this cyclic list plus one (The list emerging after the insertion). In contrast to List.add(int,Object) any index (even a negative one) is valid.
        element - element to be inserted.

      • addAll

        public void addAll​(int index,
                   Iterator<E> iter)
        Description copied from interface: CyclicList
        Inserts the cyclic list of the specified iterator at the specified position in this list (optional operation). In contrast to CyclicList.replace(int, Iterator), the element currently at the specified position is not lost.
        Specified by:
        addAll in interface CyclicList<E>
        Parameters:
        index - index at which the specified list is to be inserted. This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        iter - element to be inserted. *****
        See Also:
        CyclicList.addAll(int, List)

      • addAll

        public void addAll​(int index,
                   List<? extends E> list)
        Description copied from interface: CyclicList
        Inserts the specified list at the given position in this cyclic list (optional operation). In contrast to CyclicList.replace(int, Iterator), the element currently at the specified position is not lost.
        Specified by:
        addAll in interface CyclicList<E>
        Parameters:
        index - index at which the specified list is to be inserted. This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        list - the list to be inserted.
        See Also:
        CyclicList.addAll(int, Iterator)

      • remove

        public E remove​(int index)
         throws EmptyCyclicListException
        Description copied from interface: CyclicList
        Removes the element at the specified position in this list (optional operation). Returns the element that was removed from the list.
        Specified by:
        remove in interface CyclicList<E>
        Parameters:
        index - the index of the element to removed. This is interpreted modulo the length of this cyclic list. Any index (even negative ones) are valid.
        Returns:
        the element previously at the specified position.
        Throws:
        EmptyCyclicListException - if this list is empty.

      • getIndexOf

        public int getIndexOf​(int idx,
                      Object obj)
        Description copied from interface: CyclicList
        Returns the non-negative index in this cyclic list of the first occurrence of the specified element, or -1 if this cyclic list does not contain this element. More formally, returns the lowest index i such that (o==null ? get(i)==null : o.equals(get(i))), or some negative index if there is no such index.

        Note that this specification slightly differs from List.indexOf(Object).

        Specified by:
        getIndexOf in interface CyclicList<E>
        Parameters:
        idx - the index to start search with. Independently of this, the search comprises all entries of this cyclic list.
        obj - element to search for or null.
        Returns:
        the index in this cyclic list of the first occurrence of the specified element, or -1 if this list does not contain this element.

      • getCopy

        public CyclicList<E> getCopy​(int len)
        Description copied from interface: CyclicList
        Returns a CyclicList which is by copying this list step by step such that the length of the result is len. For example len == size()*n yields an n-fold copy of this cyclic list.
        Specified by:
        getCopy in interface CyclicList<E>
        Parameters:
        len - a non-negative int value.
        Returns:
        a CyclicList which is by copying this list step by step such that the length of the result is as specified.