de.caff.generics

## Class ListIteratorConverter<T,S>

- java.lang.Object
- - de.caff.generics.ListIteratorConverter<T,S>

- Type Parameters:
    `T` - target type
    `S` - source type
  All Implemented Interfaces:
    java.util.Iterator<T>, java.util.ListIterator<T>

      public class ListIteratorConverter<T,S>
      extends java.lang.Object
      implements java.util.ListIterator<T>

  A list iterator which maps the returned value.

  It does not support setting or adding.

  Since:
    Mai.25, 2016
  Author:
    Rammi

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ListIteratorConverter(java.util.ListIterator<S> sourceIterator, java.util.function.Function<? super S,T> mapper)` Constructor.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `add(T t)` Inserts the specified element into the list (optional operation).
    `boolean` | `hasNext()` Returns `true` if this list iterator has more elements when traversing the list in the forward direction.
    `boolean` | `hasPrevious()` Returns `true` if this list iterator has more elements when traversing the list in the reverse direction.
    `T` | `next()` Returns the next element in the list and advances the cursor position.
    `int` | `nextIndex()` Returns the index of the element that would be returned by a subsequent call to `next()`.
    `T` | `previous()` Returns the previous element in the list and moves the cursor position backwards.
    `int` | `previousIndex()` Returns the index of the element that would be returned by a subsequent call to `previous()`.
    `void` | `remove()` Removes from the list the last element that was returned by `next()` or `previous()` (optional operation).
    `void` | `set(T t)` Replaces the last element returned by `next()` or `previous()` with the specified element (optional operation).

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface java.util.Iterator

      `forEachRemaining`

- - ### Constructor Detail

    - #### ListIteratorConverter

          public ListIteratorConverter(@NotNull
                                       java.util.ListIterator<S> sourceIterator,
                                       @NotNull
                                       java.util.function.Function<? super S,T> mapper)

      Constructor.
      Parameters:
        `sourceIterator` - source iterator
        `mapper` - mapper from source to target type

  - ### Method Detail

    - #### hasNext

          public boolean hasNext()

      Returns `true` if this list iterator has more elements when traversing the list in the forward direction. (In other words, returns `true` if `next()` would return an element rather than throwing an exception.)
      Specified by:
        `hasNext` in interface `java.util.Iterator<T>`
      Specified by:
        `hasNext` in interface `java.util.ListIterator<T>`
      Returns:
        `true` if the list iterator has more elements when traversing the list in the forward direction

    - #### next

          public T next()

      Returns the next element in the list and advances the cursor position. This method may be called repeatedly to iterate through the list, or intermixed with calls to `previous()` to go back and forth. (Note that alternating calls to `next` and `previous` will return the same element repeatedly.)
      Specified by:
        `next` in interface `java.util.Iterator<T>`
      Specified by:
        `next` in interface `java.util.ListIterator<T>`
      Returns:
        the next element in the list
      Throws:
        `java.util.NoSuchElementException` - if the iteration has no next element

    - #### hasPrevious

          public boolean hasPrevious()

      Returns `true` if this list iterator has more elements when traversing the list in the reverse direction. (In other words, returns `true` if `previous()` would return an element rather than throwing an exception.)
      Specified by:
        `hasPrevious` in interface `java.util.ListIterator<T>`
      Returns:
        `true` if the list iterator has more elements when traversing the list in the reverse direction

    - #### previous

          public T previous()

      Returns the previous element in the list and moves the cursor position backwards. This method may be called repeatedly to iterate through the list backwards, or intermixed with calls to `next()` to go back and forth. (Note that alternating calls to `next` and `previous` will return the same element repeatedly.)
      Specified by:
        `previous` in interface `java.util.ListIterator<T>`
      Returns:
        the previous element in the list
      Throws:
        `java.util.NoSuchElementException` - if the iteration has no previous element

    - #### nextIndex

          public int nextIndex()

      Returns the index of the element that would be returned by a subsequent call to `next()`. (Returns list size if the list iterator is at the end of the list.)
      Specified by:
        `nextIndex` in interface `java.util.ListIterator<T>`
      Returns:
        the index of the element that would be returned by a subsequent call to `next`, or list size if the list iterator is at the end of the list

    - #### previousIndex

          public int previousIndex()

      Returns the index of the element that would be returned by a subsequent call to `previous()`. (Returns -1 if the list iterator is at the beginning of the list.)
      Specified by:
        `previousIndex` in interface `java.util.ListIterator<T>`
      Returns:
        the index of the element that would be returned by a subsequent call to `previous`, or -1 if the list iterator is at the beginning of the list

    - #### remove

          public void remove()

      Removes from the list the last element that was returned by `next()` or `previous()` (optional operation). This call can only be made once per call to `next` or `previous`. It can be made only if `add(T)` has not been called after the last call to `next` or `previous`.
      Specified by:
        `remove` in interface `java.util.Iterator<T>`
      Specified by:
        `remove` in interface `java.util.ListIterator<T>`
      Throws:
        `java.lang.UnsupportedOperationException` - if the `remove` operation is not supported by this list iterator
        `java.lang.IllegalStateException` - if neither `next` nor `previous` have been called, or `remove` or `add` have been called after the last call to `next` or `previous`

    - #### set

          public void set(T t)

      Replaces the last element returned by `next()` or `previous()` with the specified element (optional operation). This call can be made only if neither `remove()` nor `add(T)` have been called after the last call to `next` or `previous`.
      Specified by:
        `set` in interface `java.util.ListIterator<T>`
      Parameters:
        `t` - the element with which to replace the last element returned by `next` or `previous`
      Throws:
        `java.lang.UnsupportedOperationException` - if the `set` operation is not supported by this list iterator
        `java.lang.ClassCastException` - if the class of the specified element prevents it from being added to this list
        `java.lang.IllegalArgumentException` - if some aspect of the specified element prevents it from being added to this list
        `java.lang.IllegalStateException` - if neither `next` nor `previous` have been called, or `remove` or `add` have been called after the last call to `next` or `previous`

    - #### add

          public void add(T t)

      Inserts the specified element into the list (optional operation). The element is inserted immediately before the element that would be returned by `next()`, if any, and after the element that would be returned by `previous()`, if any. (If the list contains no elements, the new element becomes the sole element on the list.) The new element is inserted before the implicit cursor: a subsequent call to `next` would be unaffected, and a subsequent call to `previous` would return the new element. (This call increases by one the value that would be returned by a call to `nextIndex` or `previousIndex`.)
      Specified by:
        `add` in interface `java.util.ListIterator<T>`
      Parameters:
        `t` - the element to insert
      Throws:
        `java.lang.UnsupportedOperationException` - if the `add` method is not supported by this list iterator
        `java.lang.ClassCastException` - if the class of the specified element prevents it from being added to this list
        `java.lang.IllegalArgumentException` - if some aspect of this element prevents it from being added to this list