Package org.apache.tapestry5.func

## Class F

- java.lang.Object
- - org.apache.tapestry5.func.F

-     public class F
      extends Object

  Functional operations on collections with generics support. The core interface is `Flow` to which operations and transformations (in terms of `Predicate`s, `Mapper`s and `Reducer`s) to create new Flows. Flows are initially created using `flow(Collection)` and `flow(Object...)`. F will be used a bit, thus it has a short name (for those who don't like static imports). It provides a base set of Predicate, Mapper and Reducer factories. A good development pattern for applications is to provide a similar, application-specific, set of such factories.
  Since:
    5.2.0

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static Mapper2<Integer,​Integer,​Integer>` | `ADD_INTS` | A two-input Mapper used to add the values from two Flows of Integers into a Flow of Integer sums.
    `static Predicate<String>` | `IS_BLANK` | Predicate that returns true if the provided string is blank (null or all whitespace).
    `static Reducer<Integer,​Integer>` | `SUM_INTS` | A Reducer that operates on a Flow of Integers and is used to sum the values.

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `F()` |

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <T> Worker<T>` | `addToCollection​(Collection<T> coll)` | A Worker factory; the returnedWorker adds the values to a provided collection.
    `static <S,​T> Mapper<S,​T>` | `always​(T fixedResult)` | A Mapper factory; the returned Mapper ignores its input value and always returns a predetermined result.
    `static <T> Predicate<T>` | `and​(Predicate<? super T>... delegates)` | Combines any number of delegates as a logical and operation.
    `static <A,​B,​C> Mapper<A,​C>` | `combine​(Mapper<A,​B> abMapper, Mapper<B,​C> bcMapper)` | Combines two mappers into a composite mapping from type A to type C via type B.
    `static <T> Worker<T>` | `combine​(Worker<? super T>... delegates)` | Combines several compatible workers together into a composite.
    `static Predicate<String>` | `endsWith​(String suffix)` | A Predicate factory for matching String elements with a given suffix.
    `static Predicate<String>` | `endsWithIgnoringCase​(String suffix)` | As with `endsWith(String)` but ignores case.
    `static <T extends Comparable<T>> Predicate<T>` | `eq​(T value)` | A Predicate factory for comparison of a Comparable element from a flow against a fixed value.
    `static <T> Predicate<T>` | `eql​(T value)` | A Predicate factory for equality of an element from a flow against a specified value.
    `static <T> Flow<T>` | `flow​(Iterable<T> iterable)` | Creates a lazy Flow from the `Iterator` obtained from the iterable.
    `static <T> Flow<T>` | `flow​(Collection<T> values)` | Extracts the values from the collection to form a `Flow`.
    `static <T> Flow<T>` | `flow​(Iterator<T> iterator)` | Creates a lazy Flow from the `Iterator`.
    `static <T> Flow<T>` | `flow​(T... values)` | Creates a new Flow from the values.
    `static <T extends Comparable<T>> Predicate<T>` | `gt​(T value)` | A Predicate factory for comparison of a Comparable against a fixed value; true if the flow element is greater than the provided value.
    `static <T extends Comparable<T>> Predicate<T>` | `gteq​(T value)` | A Predicate factory for comparison of a Comparable against a fixed value; true if the flow element is greater than or equal to the value.
    `static <S> Mapper<S,​S>` | `identity()` | A Mapper factory; the Mapper returns the the flow value unchanged.
    `static <T> Predicate<T>` | `isNull()` | A Predicate factory; returns true if the value from the Flow is null.
    `static <T> Flow<T>` | `iterate​(T initial, Mapper<T,​T> function)` | Creates an infinite lazy flow from an initial value and a function to map from the current value to the next value.
    `static <T> Flow<T>` | `lazy​(LazyFunction<T> function)` | Creates a `Flow` from a lazy function.
    `static <T extends Comparable<T>> Predicate<T>` | `lt​(T value)` | A Predicate factory for comparison of a Comparable against a fixed value; true if the element is less than the value.
    `static <T extends Comparable<T>> Predicate<T>` | `lteq​(T value)` | A Predicate factory for comparison of a Comprable element against a fixed value; true if the element is less than or equal to the value.
    `static <T extends Comparable<T>> Predicate<T>` | `neq​(T value)` | A Predicate factory for comparison of a Comparable element against a fixed value.
    `static <T> Predicate<T>` | `not​(Predicate<? super T> delegate)` | Inverts a predicate.
    `static <T> Predicate<T>` | `notNull()` | A Predicate factory; returns true if the value from the Flow is not null.
    `static <T> Predicate<T>` | `or​(Predicate<? super T>... delegates)` | Combines any number of delegates as a logical or operation.
    `static <A extends Comparable<A>,​B> Comparator<Tuple<A,​B>>` | `orderByFirst()` | Creates a Comparator for the Tuples of a `ZippedFlow` that sorts the Tuple elements based on the first value in the Tuple.
    `static <A,​B extends Comparable<B>> Comparator<Tuple<A,​B>>` | `orderBySecond()` | Creates a Comparator for the Tuples of a `ZippedFlow` that sorts the Tuple elements based on the first value in the Tuple.
    `static Flow<Integer>` | `range​(int lower, int upper)` | Creates a lazy Flow that returns integers in the given range.
    `static <S,​T> Mapper<S,​T>` | `select​(Predicate<? super S> predicate, Mapper<S,​T> ifAccepted)` | Override of `select(Predicate, Mapper, Mapper)` where rejected values are replaced with null.
    `static <S,​T> Mapper<S,​T>` | `select​(Predicate<? super S> predicate, Mapper<S,​T> ifAccepted, Mapper<S,​T> ifRejected)` | A Mapper factory that combines a Predicate with two `Mapper`s; evaluating the predicate selects one of the two mappers.
    `static <S,​T> Mapper<S,​T>` | `select​(Predicate<? super S> predicate, Mapper<S,​T> ifAccepted, T ifRejectedValue)` | Override of `select(Predicate, Mapper)` where rejected values are replaced with a fixed value.
    `static Flow<Integer>` | `series​(int start, int delta)` | Creates an infinite series of numbers.
    `static Predicate<String>` | `startsWith​(String prefix)` | A Predicate factory for matching String elements with a given prefix.
    `static Predicate<String>` | `startsWithIgnoringCase​(String prefix)` | As `startsWith(String)`, but ignores case.
    `static <T> Mapper<T,​String>` | `stringValueOf()` | A Mapper factory that gets the string value of the flow value using `String.valueOf(Object)`.
    `static <S> Predicate<S>` | `toPredicate​(Mapper<S,​Boolean> mapper)` | Allows a Mapper that maps to boolean to be used as a Predicate.
    `static <A,​B> ZippedFlow<A,​B>` | `zippedFlow​(Map<A,​B> map)` | Creates a ZippedFlow from the provided map; the order of the tuples in the ZippedFlow is defined by the iteration order of the map entries.

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

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

- - ### Field Detail

    - #### IS_BLANK

          public static Predicate<String> IS_BLANK

      Predicate that returns true if the provided string is blank (null or all whitespace).

    - #### SUM_INTS

          public static Reducer<Integer,​Integer> SUM_INTS

      A Reducer that operates on a Flow of Integers and is used to sum the values.

    - #### ADD_INTS

          public static Mapper2<Integer,​Integer,​Integer> ADD_INTS

      A two-input Mapper used to add the values from two Flows of Integers into a Flow of Integer sums.

  - ### Constructor Detail

    - #### F

          public F()

  - ### Method Detail

    - #### eql

          public static <T> Predicate<T> eql​(T value)

      A Predicate factory for equality of an element from a flow against a specified value.

    - #### eq

          public static <T extends Comparable<T>> Predicate<T> eq​(T value)

      A Predicate factory for comparison of a Comparable element from a flow against a fixed value.

    - #### neq

          public static <T extends Comparable<T>> Predicate<T> neq​(T value)

      A Predicate factory for comparison of a Comparable element against a fixed value.

    - #### gt

          public static <T extends Comparable<T>> Predicate<T> gt​(T value)

      A Predicate factory for comparison of a Comparable against a fixed value; true if the flow element is greater than the provided value.

    - #### gteq

          public static <T extends Comparable<T>> Predicate<T> gteq​(T value)

      A Predicate factory for comparison of a Comparable against a fixed value; true if the flow element is greater than or equal to the value.

    - #### lt

          public static <T extends Comparable<T>> Predicate<T> lt​(T value)

      A Predicate factory for comparison of a Comparable against a fixed value; true if the element is less than the value.

    - #### lteq

          public static <T extends Comparable<T>> Predicate<T> lteq​(T value)

      A Predicate factory for comparison of a Comprable element against a fixed value; true if the element is less than or equal to the value.

    - #### isNull

          public static <T> Predicate<T> isNull()

      A Predicate factory; returns true if the value from the Flow is null.

    - #### notNull

          public static <T> Predicate<T> notNull()

      A Predicate factory; returns true if the value from the Flow is not null.

    - #### stringValueOf

          public static <T> Mapper<T,​String> stringValueOf()

      A Mapper factory that gets the string value of the flow value using `String.valueOf(Object)`.

    - #### always

          public static <S,​T> Mapper<S,​T> always​(T fixedResult)

      A Mapper factory; the returned Mapper ignores its input value and always returns a predetermined result.

    - #### select

          public static <S,​T> Mapper<S,​T> select​(Predicate<? super S> predicate,
                                                             Mapper<S,​T> ifAccepted,
                                                             Mapper<S,​T> ifRejected)

      A Mapper factory that combines a Predicate with two `Mapper`s; evaluating the predicate selects one of the two mappers.
      Parameters:
        `predicate` - evaluated to selected a coercion
        `ifAccepted` - used when predicate evaluates to true
        `ifRejected` - used when predicate evaluates to false

    - #### select

          public static <S,​T> Mapper<S,​T> select​(Predicate<? super S> predicate,
                                                             Mapper<S,​T> ifAccepted)

      Override of `select(Predicate, Mapper, Mapper)` where rejected values are replaced with null.

    - #### select

          public static <S,​T> Mapper<S,​T> select​(Predicate<? super S> predicate,
                                                             Mapper<S,​T> ifAccepted,
                                                             T ifRejectedValue)

      Override of `select(Predicate, Mapper)` where rejected values are replaced with a fixed value.

    - #### identity

          public static <S> Mapper<S,​S> identity()

      A Mapper factory; the Mapper returns the the flow value unchanged.

    - #### toPredicate

          public static <S> Predicate<S> toPredicate​(Mapper<S,​Boolean> mapper)

      Allows a Mapper that maps to boolean to be used as a Predicate.

    - #### flow

          public static <T> Flow<T> flow​(Collection<T> values)

      Extracts the values from the collection to form a `Flow`. The Collection may change after the Flow is created without affecting the Flow.

    - #### flow

          public static <T> Flow<T> flow​(T... values)

      Creates a new Flow from the values. You should not change the values array after invoking this method (i.e., no defensive copy of the values is made).

    - #### flow

          public static <T> Flow<T> flow​(Iterable<T> iterable)

      Creates a lazy Flow from the `Iterator` obtained from the iterable. The Flow will be threadsafe as long as the iterable yields a new Iterator on each invocation and the underlying iterable object is not modified while the Flow is evaluating. In other words, not extremely threadsafe.

    - #### flow

          public static <T> Flow<T> flow​(Iterator<T> iterator)

      Creates a lazy Flow from the `Iterator`. The Flow will be threadsafe as long as the underlying iterable object is not modified while the Flow is evaluating. In other words, not extremely threadsafe.
      Since:
        5.3

    - #### zippedFlow

          public static <A,​B> ZippedFlow<A,​B> zippedFlow​(Map<A,​B> map)

      Creates a ZippedFlow from the provided map; the order of the tuples in the ZippedFlow is defined by the iteration order of the map entries.
      Type Parameters:
        `A` - type of key and first tuple value
        `B` - type of value and second tuple value
      Parameters:
        `map` - source of tuples
      Returns:
        zipped flow created from map
      Since:
        5.3

    - #### range

          public static Flow<Integer> range​(int lower,
                                            int upper)

      Creates a lazy Flow that returns integers in the given range. The range starts with the lower value and counts by 1 up to the upper range (which is not part of the Flow). If lower equals upper, the Flow is empty. If upper is less than lower, the Flow counts down instead.
      Parameters:
        `lower` - start of range (inclusive)
        `upper` - end of range (exclusive)

    - #### lazy

          public static <T> Flow<T> lazy​(LazyFunction<T> function)

      Creates a `Flow` from a lazy function.

    - #### iterate

          public static <T> Flow<T> iterate​(T initial,
                                            Mapper<T,​T> function)

      Creates an infinite lazy flow from an initial value and a function to map from the current value to the next value.
      Parameters:
        `initial` - initial value in flow
        `function` - maps from current value in flow to next value in flow
      Returns:
        lazy flow

    - #### series

          public static Flow<Integer> series​(int start,
                                             int delta)

      Creates an infinite series of numbers. Attempting to get the FlowOperations.count() of the series will form an infinite loop.

    - #### addToCollection

          public static <T> Worker<T> addToCollection​(Collection<T> coll)

      A Worker factory; the returnedWorker adds the values to a provided collection.

    - #### startsWith

          public static Predicate<String> startsWith​(String prefix)

      A Predicate factory for matching String elements with a given prefix.
      Since:
        5.3

    - #### startsWithIgnoringCase

          public static Predicate<String> startsWithIgnoringCase​(String prefix)

      As `startsWith(String)`, but ignores case.
      Since:
        5.3

    - #### endsWith

          public static Predicate<String> endsWith​(String suffix)

      A Predicate factory for matching String elements with a given suffix.
      Since:
        5.3

    - #### endsWithIgnoringCase

          public static Predicate<String> endsWithIgnoringCase​(String suffix)

      As with `endsWith(String)` but ignores case.
      Since:
        5.3

    - #### orderByFirst

          public static <A extends Comparable<A>,​B> Comparator<Tuple<A,​B>> orderByFirst()

      Creates a Comparator for the Tuples of a `ZippedFlow` that sorts the Tuple elements based on the first value in the Tuple.
      Since:
        5.3

    - #### orderBySecond

          public static <A,​B extends Comparable<B>> Comparator<Tuple<A,​B>> orderBySecond()

      Creates a Comparator for the Tuples of a `ZippedFlow` that sorts the Tuple elements based on the first value in the Tuple.
      Since:
        5.3

    - #### not

          public static <T> Predicate<T> not​(Predicate<? super T> delegate)

      Inverts a predicate.
      Parameters:
        `delegate` - the predicate to invert
      Returns:
        a new predicate that is inverse to the existing predicate
      Since:
        5.3

    - #### combine

          public static <A,​B,​C> Mapper<A,​C> combine​(Mapper<A,​B> abMapper,
                                                                      Mapper<B,​C> bcMapper)

      Combines two mappers into a composite mapping from type A to type C via type B.
      Parameters:
        `abMapper` - maps from A to B
        `bcMapper` - maps from B to C
      Returns:
        mapper from A to C

    - #### and

          public static <T> Predicate<T> and​(Predicate<? super T>... delegates)

      Combines any number of delegates as a logical and operation. Evaluation terminates with the first delegate predicate that returns false.
      Parameters:
        `delegates` - to evaluate
      Returns:
        combined delegate
      Since:
        5.3

    - #### or

          public static <T> Predicate<T> or​(Predicate<? super T>... delegates)

      Combines any number of delegates as a logical or operation. Evaluation terminates with the first delegate predicate that returns true.
      Parameters:
        `delegates` - to evaluate
      Returns:
        combined delegate
      Since:
        5.3

    - #### combine

          public static <T> Worker<T> combine​(Worker<? super T>... delegates)

      Combines several compatible workers together into a composite.
      Since:
        5.3