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 Predicates, Mappers and Reducers) 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

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 Mappers; 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 Mappers; 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