co.streamx.fluent.extree.function

Class Functions

java.lang.Object

co.streamx.fluent.extree.function.Functions

public final class Functions
extends Object

Contains static factory methods to create composed functions.

Method Summary

Modifier and Type	Method and Description
static <N extends Number> Function<N,Number>	abs() Returns the absolute value of an argument.
static <T> Function<T,Number>	abs(Function<T,? extends Number> selector) Returns the absolute value of an argument evaluation result.
static <T,U> BiFunction<T,U,Number>	add(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) + right.apply(U).
static <T,U> BiPredicate<T,U>	and(Function<T,Boolean> left, Function<U,Boolean> right) Returns the value of left.apply(T) && right.apply(U).
static <T,U> BiPredicate<T,U>	and(Predicate<T> left, Predicate<U> right) Returns the value of left.apply(T) && right.apply(U).
static <T,U> BiFunction<T,U,Number>	bitwiseAnd(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) & right.apply(U).
static Function<?,Number>	bitwiseNot() Returns the bitwise not value of an argument.
static Function<?,Number>	bitwiseNot(Function<?,? extends Number> selector) Returns the bitwise not value of an argument evaluation result.
static <T,U> BiFunction<T,U,Number>	bitwiseOr(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) | right.apply(U).
static <T,Result> Function<T,Result>	constant(Result result) Represents a function returning a constant value.
static <T,U> BiFunction<T,U,Number>	divide(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) / right.apply(U).
static <T,U> BiPredicate<T,U>	equal(Function<T,?> left, Function<U,?> right) Returns the value of left.apply(T) == right.apply(U).
static <T,Result> Function<T,Result>	field(Class<? super T> outerType, String fieldName) Represents a function returning value of a field using reflection.
static <T,U,Key extends Comparable<Key>> BiPredicate<T,U>	greaterThan(Function<T,Key> left, Function<U,Key> right) Returns the value of left.apply(T) > right.apply(U).
static <T,U,Key extends Comparable<Key>> BiPredicate<T,U>	greaterThanOrEqual(Function<T,Key> left, Function<U,Key> right) Returns the value of left.apply(T) >= right.apply(U).
static <Result,T> Function<T,Result>	iif(Function<? super T,Boolean> predicate, Function<? super T,? extends Result> ifTrue, Function<? super T,? extends Result> ifFalse) Returns the value of predicate.apply(T) ? ifTrue.apply(T) : ifFalse.apply(T).
static <Result,T> Predicate<T>	instanceOf(Function<? super T,? extends Result> operand, Class<?> type) Returns the value of operand.apply(T) instanceof type.
static <T,U,Key extends Comparable<Key>> BiPredicate<T,U>	lessThan(Function<T,Key> left, Function<U,Key> right) Returns the value of left.apply(T) < right.apply(U).
static <T,U,Key extends Comparable<Key>> BiPredicate<T,U>	lessThanOrEqual(Function<T,Key> left, Function<U,Key> right) Returns the value of left.apply(T) <= right.apply(U).
static <T,U> BiFunction<T,U,Number>	modulo(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) % right.apply(U).
static <T,U> BiFunction<T,U,Number>	multiply(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) * right.apply(U).
static Function<?,Number>	negate() Returns the negative value of an argument.
static Function<?,Number>	negate(Function<?,? extends Number> selector) Returns the negative value of an argument evaluation result.
static <T> Predicate<T>	not(Function<T,Boolean> predicate) Negates the return value of a predicate.
static <T,U> BiPredicate<T,U>	or(Function<T,Boolean> left, Function<U,Boolean> right) Returns the value of left.apply(T) || right.apply(U).
static <T,U> BiPredicate<T,U>	or(Predicate<T> left, Predicate<U> right) Returns the value of left.apply(T) || right.apply(U).
static <T,U> BiFunction<T,U,Number>	power(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T)right.apply(U).
static <T,Result> Function<T,Result>	property(Class<? super T> outerType, String propertyName) Represents a function returning value of a property using reflection.
static <T,U> BiFunction<T,U,Number>	shiftLeft(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) << right.apply(U).
static <T,U> BiFunction<T,U,Number>	shiftRight(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) >> right.apply(U).
static <T,U> BiFunction<T,U,Number>	subtract(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) - right.apply(U).
static <T,U> BiFunction<T,U,Number>	xor(Function<T,? extends Number> left, Function<U,? extends Number> right) Returns the value of left.apply(T) ^ right.apply(U).

Methods inherited from class java.lang.Object

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

Method Detail

abs

public static <T> Function<T,Number> abs(Function<T,? extends Number> selector)

Returns the absolute value of an argument evaluation result. In other words, the result is semantically equivalent to this pseudo-code: abs(selector.apply(N))

Type Parameters:

T - the type of the input type.

Parameters:

selector - a function to extract the numeric value from T.

Returns:

the absolute value of an argument evaluation result.

abs

public static <N extends Number> Function<N,Number> abs()

Returns the absolute value of an argument.

Type Parameters:

N - the type of the argument.

Returns:

the absolute value of an argument.

negate

public static Function<?,Number> negate(Function<?,? extends Number> selector)

Returns the negative value of an argument evaluation result. In other words, the result is semantically equivalent to this pseudo-code: -selector.invoke(?)

Parameters:

selector - a function to negate the numeric parameter.

Returns:

the negative value of an argument evaluation result.

negate

public static Function<?,Number> negate()

Returns the negative value of an argument.

Returns:

the negative value of an argument.

bitwiseNot

public static Function<?,Number> bitwiseNot(Function<?,? extends Number> selector)

Returns the bitwise not value of an argument evaluation result. In other words, the result is semantically equivalent to this pseudo-code: ~selector.invoke(?)

Parameters:

selector - a function to complement the numeric parameter.

Returns:

the bitwise not value of an argument evaluation result.

bitwiseNot

public static Function<?,Number> bitwiseNot()

Returns the bitwise not value of an argument.

Returns:

the bitwise not value of an argument.

bitwiseAnd

public static <T,U> BiFunction<T,U,Number> bitwiseAnd(Function<T,? extends Number> left,
                                                      Function<U,? extends Number> right)

Returns the value of left.apply(T) & right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) & right.apply(U)

add

public static <T,U> BiFunction<T,U,Number> add(Function<T,? extends Number> left,
                                               Function<U,? extends Number> right)

Returns the value of left.apply(T) + right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) + right.apply(U)

subtract

public static <T,U> BiFunction<T,U,Number> subtract(Function<T,? extends Number> left,
                                                    Function<U,? extends Number> right)

Returns the value of left.apply(T) - right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) - right.apply(U)

multiply

public static <T,U> BiFunction<T,U,Number> multiply(Function<T,? extends Number> left,
                                                    Function<U,? extends Number> right)

Returns the value of left.apply(T) * right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) * right.apply(U)

divide

public static <T,U> BiFunction<T,U,Number> divide(Function<T,? extends Number> left,
                                                  Function<U,? extends Number> right)

Returns the value of left.apply(T) / right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) / right.apply(U)

modulo

public static <T,U> BiFunction<T,U,Number> modulo(Function<T,? extends Number> left,
                                                  Function<U,? extends Number> right)

Returns the value of left.apply(T) % right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) % right.apply(U)

bitwiseOr

public static <T,U> BiFunction<T,U,Number> bitwiseOr(Function<T,? extends Number> left,
                                                     Function<U,? extends Number> right)

Returns the value of left.apply(T) | right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) | right.apply(U)

power

public static <T,U> BiFunction<T,U,Number> power(Function<T,? extends Number> left,
                                                 Function<U,? extends Number> right)

Returns the value of left.apply(T)^{right.apply(U)}.

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T)^{right.apply(U)}

shiftLeft

public static <T,U> BiFunction<T,U,Number> shiftLeft(Function<T,? extends Number> left,
                                                     Function<U,? extends Number> right)

Returns the value of left.apply(T) << right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) << right.apply(U)

shiftRight

public static <T,U> BiFunction<T,U,Number> shiftRight(Function<T,? extends Number> left,
                                                      Function<U,? extends Number> right)

Returns the value of left.apply(T) >> right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) >> right.apply(U)

xor

public static <T,U> BiFunction<T,U,Number> xor(Function<T,? extends Number> left,
                                               Function<U,? extends Number> right)

Returns the value of left.apply(T) ^ right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) ^ right.apply(U)

and

public static <T,U> BiPredicate<T,U> and(Predicate<T> left,
                                         Predicate<U> right)

Returns the value of left.apply(T) && right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) && right.apply(U)

and

public static <T,U> BiPredicate<T,U> and(Function<T,Boolean> left,
                                         Function<U,Boolean> right)

Returns the value of left.apply(T) && right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) && right.apply(U)

or

public static <T,U> BiPredicate<T,U> or(Predicate<T> left,
                                        Predicate<U> right)

Returns the value of left.apply(T) || right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) || right.apply(U)

or

public static <T,U> BiPredicate<T,U> or(Function<T,Boolean> left,
                                        Function<U,Boolean> right)

Returns the value of left.apply(T) || right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) || right.apply(U)

lessThan

public static <T,U,Key extends Comparable<Key>> BiPredicate<T,U> lessThan(Function<T,Key> left,
                                                                          Function<U,Key> right)

Returns the value of left.apply(T) < right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Key - the type of the value to compare on.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) < right.apply(U)

lessThanOrEqual

public static <T,U,Key extends Comparable<Key>> BiPredicate<T,U> lessThanOrEqual(Function<T,Key> left,
                                                                                 Function<U,Key> right)

Returns the value of left.apply(T) <= right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Key - the type of the value to compare on.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) <= right.apply(U)

equal

public static <T,U> BiPredicate<T,U> equal(Function<T,?> left,
                                           Function<U,?> right)

Returns the value of left.apply(T) == right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) == right.apply(U)

greaterThanOrEqual

public static <T,U,Key extends Comparable<Key>> BiPredicate<T,U> greaterThanOrEqual(Function<T,Key> left,
                                                                                    Function<U,Key> right)

Returns the value of left.apply(T) >= right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Key - the type of the value to compare on.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) >= right.apply(U)

greaterThan

public static <T,U,Key extends Comparable<Key>> BiPredicate<T,U> greaterThan(Function<T,Key> left,
                                                                             Function<U,Key> right)

Returns the value of left.apply(T) > right.apply(U).

Type Parameters:

T - the type of the first argument.

U - the type of the second argument.

Key - the type of the value to compare on.

Parameters:

left - a function to extract the left hand value from T.

right - a function to extract the right hand value from T.

Returns:

the value of left.apply(T) > right.apply(U)

constant

public static <T,Result> Function<T,Result> constant(Result result)

Represents a function returning a constant value.

Type Parameters:

Result - the type of returned value.

T - the type of the ignored argument.

Parameters:

result - value to return.

Returns:

result.

property

public static <T,Result> Function<T,Result> property(Class<? super T> outerType,
                                                     String propertyName)
                                              throws NoSuchMethodException

Represents a function returning value of a property using reflection.

Type Parameters:

Result - the type of returned value.

T - the type of the argument.

Parameters:

outerType - Class of the objects in the sequence.

propertyName - name of the property to retrieve. The implementation will look for get<propertyName>() method.

Returns:

value of the property.

Throws:

NoSuchMethodException - if a matching method is not found.

field

public static <T,Result> Function<T,Result> field(Class<? super T> outerType,
                                                  String fieldName)
                                           throws NoSuchFieldException

Represents a function returning value of a field using reflection.

Type Parameters:

Result - the type of returned value.

T - the type of the argument.

Parameters:

outerType - Class of the objects in the sequence.

fieldName - name of the field to retrieve.

Returns:

value of the field.

Throws:

NoSuchFieldException - if a field with the specified name is not found.

instanceOf

public static <Result,T> Predicate<T> instanceOf(Function<? super T,? extends Result> operand,
                                                 Class<?> type)

Returns the value of operand.apply(T) instanceof type.

Type Parameters:

Result - the type of returned value.

T - the type of the argument.

Parameters:

operand - a function to extract the operand from T

type - the Class to test by.

Returns:

the value of operand.apply(T) instanceof type.

iif

public static <Result,T> Function<T,Result> iif(Function<? super T,Boolean> predicate,
                                                Function<? super T,? extends Result> ifTrue,
                                                Function<? super T,? extends Result> ifFalse)

Returns the value of predicate.apply(T) ? ifTrue.apply(T) : ifFalse.apply(T).

Note, that either ifTrue or ifFalse function is evaluated.

Type Parameters:

Result - the type of returned value.

T - the type of the argument.

Parameters:

predicate - predicate to test.

ifTrue - a function to evaluate if predicate returns true.

ifFalse - a function to evaluate if predicate returns false.

Returns:

the value of predicate.apply(T) ? ifTrue.apply(T) : ifFalse.apply(T).

not

public static <T> Predicate<T> not(Function<T,Boolean> predicate)

Negates the return value of a predicate. In other words: !predicate.apply(T).

Type Parameters:

T - the type of the argument.

Parameters:

predicate - predicate to negate its evaluation result.

Returns:

value of !predicate.apply(T).