Package net.shibboleth.shared.logic

# Class FunctionSupport

java.lang.Object
net.shibboleth.shared.logic.FunctionSupport

public final class FunctionSupport extends Object
Helper class for constructing functions that are fully generic, in contrast to the broken, Object-bound types Guava can build.

## Constructor Summary

Constructors
Modifier
Constructor
Description
`private`
`FunctionSupport()`
Constructor.

## Method Summary

Modifier and Type
Method
Description
`static <A, B, C> Function<A,C>`
`compose(Function<? super B,? extends C> g, Function<A,? extends B> f)`
Returns the composition of two functions.
`static <T1, T2> Function<T1,T2>`
`constant(T2 target)`
Creates a function that returns a constant value.
`static <T> Function<T,Boolean>`
`forPredicate(Predicate<T> predicate)`
Creates a function that returns the same boolean output as the given predicate for all inputs.

### Methods inherited from class java.lang.Object

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

## Constructor Details

### FunctionSupport

private FunctionSupport()
Constructor.

## Method Details

### constant

@Nonnull public static <T1, T2> Function<T1,T2> constant(@Nullable @ParameterName(name="target") T2 target)
Creates a function that returns a constant value.

Type Parameters:
  `T1` - type of object the function needs to act on
  `T2` - type of object being returned
Parameters:
  `target` - the value to return from the function
Returns:
  the constructed function

### compose

@Nonnull public static <A, B, C> Function<A,C> compose(@Nonnull @ParameterName(name="g") Function<? super B,? extends C> g, @Nonnull @ParameterName(name="f") Function<A,? extends B> f)
Returns the composition of two functions. For `f: A->B` and `g: B->C`, composition is defined as the function h such that `h(a) == g(f(a))` for each `a`.

Type Parameters:
  `A` - input to composed function
  `B` - output of inner function
  `C` - output of composed function
Parameters:
  `g` - the second function to apply
  `f` - the first function to apply
Returns:
  the composition of `f` and `g`
See Also:
  - function composition

### forPredicate

@Nonnull public static <T> Function<T,Boolean> forPredicate(@Nonnull @ParameterName(name="predicate") Predicate<T> predicate)
Creates a function that returns the same boolean output as the given predicate for all inputs.

Primarily provided for Spring wiring use cases that can't express a method reference.

Type Parameters:
  `T` - input type
Parameters:
  `predicate` - input predicate
Returns:
  a corresponding function