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

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