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 and 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 and Description
    `F()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and 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(Collection<T> values)` Extracts the values from the collection to form a `Flow`.
    `static <T> Flow<T>` | `flow(Iterable<T> iterable)` Creates a lazy Flow from the `Iterator` obtained from the iterable.
    `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

${project.version} - Copyright © 2003-2015 The Apache Software Foundation.