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

  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 Details

  - ### 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 Details

  - ### F

    public F()

- ## Method Details

  - ### 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