Iter (net.ninjacat:smooth 0.2.3 API)

java.lang.Object
- net.ninjacat.smooth.iterators.Iter<E>

Type Parameters:

E - Type of the elements in the iterator

All Implemented Interfaces:

Iterable<E>
```
public class Iter<E>
extends Object
implements Iterable<E>
```
Functional style immutable rich iterator

Main difference from standard Iterator is that this iterator allows functions to be applied to the elements. It supports standard operations like filter(Predicate), map(Func) or reduce(Object, Function2) and others.

This is essentially a rich wrapper around Iterator over collection. Standard limitations of iterators apply, like restriction of changing collection during iteration

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`all(Predicate<E> matcher)` Checks if all elements of iterator match supplied predicate
`boolean`	`any(Predicate<E> matcher)` Checks if any of the elements of iterator match supplied predicate
`Collection<E>`	`collectWith(Collector<E> collector)` Collect this iterable into collection
`Iter<E>`	`filter(Predicate<E> predicate)` Filters out elements of iterable iterator based on predicate.
`E`	`find(Predicate<E> matcher, E defaultValue)` Finds first element in iterator that matches supplied `Predicate`
`void`	`forEach(Procedure<E> executor)` Calls specified `Procedure` for each element
`static <E> Iter<E>`	`fromArray(E[] data)` Creates rich iterator wrapper around array of elements
`Iterator<E>`	`iterator()`
`Promise<E>`	`lazyFind(Predicate<E> matcher, E defaultValue)` Lazy variant of `find(Predicate, Object)`
`<R> Promise<R>`	`lazyReduce(R starting, Function2<R,R,E> f)` Lazily folds iterable iterator left
`<R> Iter<R>`	`map(Func<R,E> func)` Maps all the values in the iterator to other values using supplied function.
`String`	`mkStr(String separator)` Joins all the elements in the collection into string with supplied separator
`static <E> Iter<E>`	`of(Collection<E> coll)` Creates iterator over collection.
`static <E> Iter<E>`	`of(E... data)` Creates rich iterator wrapper around array of elements
`static <E> Iter<E>`	`of(Enumeration<E> enumeration)`
`static <E> Iter<E>`	`of(Iterator<E> iter)` Creates rich iterator wrapper around Java `Iterator`.
`<R> R`	`reduce(R starting, Function2<R,R,E> f)` Folds iterable iterator left
`E[]`	`toArray(Class<E> arrayType)` Returns an array containing all of the elements in this iterable in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array.
`E[]`	`toArray(E[] array)` Returns an array containing all of the elements in this iterable in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array.
`List<E>`	`toList()`
`<K> Map<K,E>`	`toMap(Func<K,E> keyGenerator)` Converts this iterable into map using provided key generator function.
`Set<E>`	`toSet()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Method Detail
  - of
```
public static <E> Iter<E> of(Enumeration<E> enumeration)
```
  - of
```
public static <E> Iter<E> of(Collection<E> coll)
```
    Creates iterator over collection. If the collection is changed during iteration (especially possible with lazy calculations) ConcurrentModificationException may be thrown.
    
    Type Parameters:
    
    E - type of elements in the collection
    
    Parameters:
    
    coll - collection to be wrapped
    
    Returns:
    
    Rich iterator over collection elements
  - of
```
public static <E> Iter<E> of(Iterator<E> iter)
```
    Creates rich iterator wrapper around Java Iterator.
    Do not use wrapped iterator as it will interfere with operations over rich iterator.
    
    Type Parameters:
    
    E - type of elements in the collection
    
    Parameters:
    
    iter - Iterator to wrap with rich functionality
    
    Returns:
    
    Rich iterator wrapped around Java iterator
  - of
```
public static <E> Iter<E> of(E... data)
```
    Creates rich iterator wrapper around array of elements
    
    This iterator is created over copy of the array, so original array can be used or disposed of.
    
    Type Parameters:
    
    E - type of elements
    
    Parameters:
    
    data - the array
    
    Returns:
    
    Rich iterator for array elements
  - fromArray
```
public static <E> Iter<E> fromArray(E[] data)
```
    Creates rich iterator wrapper around array of elements
    
    Type Parameters:
    
    E - Array element type
    
    Parameters:
    
    data - Array to create iterator for
    
    Returns:
    
    Rich iterator
  - toList
```
public List<E> toList()
```
    Returns:
    
    List containing all the items from this iterator. Returned list is immutable
  - toSet
```
public Set<E> toSet()
```
    Returns:
    
    Set containing all the items from this iterator. Returned list is immutable
  - toArray
```
public E[] toArray(E[] array)
```
    Returns an array containing all of the elements in this iterable in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array. If the list fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this Iterable.
    If the list fits in the specified array with room to spare (i.e., the array has more elements than the iterable), the element in the array immediately following the end of the list is set to null. (This is useful in determining the length of the list only if the caller knows that the list does not contain any null elements.)
    
    Parameters:
    
    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 the elements of this iterable
  - toArray
```
public E[] toArray(Class<E> arrayType)
```
    Returns an array containing all of the elements in this iterable in proper sequence (from first to last element); the runtime type of the returned array is that of the specified array. If the list fits in the specified array, it is returned therein. Otherwise, a new array is allocated with the runtime type of the specified array and the size of this Iterable.
    If the list fits in the specified array with room to spare (i.e., the array has more elements than the iterable), the element in the array immediately following the end of the list is set to null. (This is useful in determining the length of the list only if the caller knows that the list does not contain any null elements.)
    
    Parameters:
    
    arrayType - Type of the array element
    
    Returns:
    
    an array containing the elements of this iterable
  - map
```
public <R> Iter<R> map(Func<R,E> func)
```
    Maps all the values in the iterator to other values using supplied function.
    
    This function will not create new iterator, instead transformation function will be applied to the next original iterator's element during each call to Iterator.next()
    
    Type Parameters:
    
    R - result type
    
    Parameters:
    
    func - mapping function
    
    Returns:
    
    Iterable iterator of mapped values
  - forEach
```
public void forEach(Procedure<E> executor)
```
    Calls specified Procedure for each element
    
    Parameters:
    
    executor - Procedure to be executed on each element of iterable
  - reduce
```
public <R> R reduce(R starting,
                    Function2<R,R,E> f)
```
    Folds iterable iterator left
    
    Type Parameters:
    
    R - type of the resulting value
    
    Parameters:
    
    starting - initial value of the result
    
    f - folding function
    
    Returns:
    
    Value of the left-folded collection
  - lazyReduce
```
public <R> Promise<R> lazyReduce(R starting,
                                 Function2<R,R,E> f)
```
    Lazily folds iterable iterator left
    
    Type Parameters:
    
    R - type of the resulting value
    
    Parameters:
    
    starting - initial value of the result
    
    f - folding function
    
    Returns:
    
    Promise of the value of the left-folded collection
  - filter
```
public Iter<E> filter(Predicate<E> predicate)
```
    Filters out elements of iterable iterator based on predicate. Supplied matcher predicate should return true if the element must be included into resulting iterator or false otherwise.
    
    Parameters:
    
    predicate - - function to verify iterator element
    
    Returns:
    
    Iterable iterator. This function will not create resulting iterator immediately, instead next element will be evaluated when requested with Iterator.next()
  - find
```
public E find(Predicate<E> matcher,
              E defaultValue)
```
    Finds first element in iterator that matches supplied Predicate
    
    Parameters:
    
    matcher - Predicate to test iterator's elements
    
    defaultValue - default value that will be returned if none of the elements in the iterator matches predicate
    
    Returns:
    
    Element found or of the default value
  - lazyFind
```
public Promise<E> lazyFind(Predicate<E> matcher,
                           E defaultValue)
```
    Lazy variant of find(Predicate, Object)
    
    Parameters:
    
    matcher - Predicate to test iterator elements
    
    defaultValue - default value that will be returned if none of the elements in the iterator matches predicate
    
    Returns:
    
    Promise to find element that matches predicate
  - all
```
public boolean all(Predicate<E> matcher)
```
    Checks if all elements of iterator match supplied predicate
    
    Parameters:
    
    matcher - - Predicate to check elements
    
    Returns:
    
    true if all elements match predicate or false otherwise
  - any
```
public boolean any(Predicate<E> matcher)
```
    Checks if any of the elements of iterator match supplied predicate
    
    Parameters:
    
    matcher - - Predicate to check elements
    
    Returns:
    
    true if any of the elements match predicate or false otherwise
  - iterator
```
public Iterator<E> iterator()
```
    Specified by:
    
    iterator in interface Iterable<E>
  - mkStr
```
public String mkStr(String separator)
```
    Joins all the elements in the collection into string with supplied separator
    
    Parameters:
    
    separator - string to separate elements
    
    Returns:
    
    String
  - collectWith
```
public Collection<E> collectWith(Collector<E> collector)
```
    Collect this iterable into collection
    
    Parameters:
    
    collector - Collector which will perform collection
    
    Returns:
    
    Collection of all the elements in this iterable
  - toMap
```
public <K> Map<K,E> toMap(Func<K,E> keyGenerator)
```
    Converts this iterable into map using provided key generator function.
    For each element map key is generated using keyGenerator and key->element pair is inserted into the map. Generated map is unmodifiable.
    
    Type Parameters:
    
    K - Type of the key.
    
    Parameters:
    
    keyGenerator - Key generator function which should create a key from the iterable element.
    
    Returns:
    
    Unmodifiable map of type <K, E>

Class Iter<E>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Method Detail

of

of

of

of

fromArray

toList

toSet

toArray

toArray

map

forEach

reduce

lazyReduce

filter

find

lazyFind

all

any

iterator

mkStr

collectWith

toMap