Package com.linecorp.armeria.common.util

Class Functions

java.lang.Object

com.linecorp.armeria.common.util.Functions

public final class Functions
extends Object

Utility methods related with function composition.

Method Summary

Modifier and Type	Method	Description
static <A,B,C> Function<A,C>	compose(Function<A,B> f1, Function<B,C> f2)	Returns a Function that composes the specified Functions with chained Function.andThen(Function).
static <A,B,C,D> Function<A,D>	compose(Function<A,B> f1, Function<B,C> f2, Function<C,D> f3)	Returns a Function that composes the specified Functions with chained Function.andThen(Function).
static <A,B,C,D,E> Function<A,E>	compose(Function<A,B> f1, Function<B,C> f2, Function<C,D> f3, Function<D,E> f4)	Returns a Function that composes the specified Functions with chained Function.andThen(Function).
static <A,B,C,D,E,F> Function<A,F>	compose(Function<A,B> f1, Function<B,C> f2, Function<C,D> f3, Function<D,E> f4, Function<E,F> f5)	Returns a Function that composes the specified Functions with chained Function.andThen(Function).
static <A,B,C,D,E,F,G> Function<A,G>	compose(Function<A,B> f1, Function<B,C> f2, Function<C,D> f3, Function<D,E> f4, Function<E,F> f5, Function<F,G> f6)	Returns a Function that composes the specified Functions with chained Function.andThen(Function).
static <A,B,C,D,E,F,G,H> Function<A,H>	compose(Function<A,B> f1, Function<B,C> f2, Function<C,D> f3, Function<D,E> f4, Function<E,F> f5, Function<F,G> f6, Function<G,H> f7)	Returns a Function that composes the specified Functions with chained Function.andThen(Function).
static <A,B,C,D,E,F,G,H,I> Function<A,I>	compose(Function<A,B> f1, Function<B,C> f2, Function<C,D> f3, Function<D,E> f4, Function<E,F> f5, Function<F,G> f6, Function<G,H> f7, Function<H,I> f8)	Returns a Function that composes the specified Functions with chained Function.andThen(Function).
static <A,B,C,D,E,F,G,H,I,J> Function<A,J>	compose(Function<A,B> f1, Function<B,C> f2, Function<C,D> f3, Function<D,E> f4, Function<E,F> f5, Function<F,G> f6, Function<G,H> f7, Function<H,I> f8, Function<I,J> f9)	Returns a Function that composes the specified Functions with chained Function.andThen(Function).
static <T,U> BiFunction<T,U,Void>	voidFunction(BiConsumer<T,U> consumer)	Converts the specified BiConsumer into a BiFunction that returns null.
static <T> Function<T,Void>	voidFunction(Consumer<T> consumer)	Converts the specified Consumer into a Function that returns null.

Methods inherited from class java.lang.Object

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

Method Detail

compose

public static <A,B,C> Function<A,C> compose(Function<A,B> f1,
                                                              Function<B,C> f2)

Returns a Function that composes the specified Functions with chained Function.andThen(Function). It is useful when you need to compose method handles, which is impossible with Function.andThen(Function):

 Function<A, B> f = Functions.compose(TypeA::new, TypeB::new);
 

compose

public static <A,B,C,D> Function<A,D> compose(Function<A,B> f1,
                                                                      Function<B,C> f2,
                                                                      Function<C,D> f3)

Returns a Function that composes the specified Functions with chained Function.andThen(Function). It is useful when you need to compose method handles, which is impossible with Function.andThen(Function):

 Function<A, B> f = Functions.compose(TypeA::new, TypeB::new);
 

compose

public static <A,B,C,D,E> Function<A,E> compose(Function<A,B> f1,
                                                                              Function<B,C> f2,
                                                                              Function<C,D> f3,
                                                                              Function<D,E> f4)

Returns a Function that composes the specified Functions with chained Function.andThen(Function). It is useful when you need to compose method handles, which is impossible with Function.andThen(Function):

 Function<A, B> f = Functions.compose(TypeA::new, TypeB::new);
 

compose

public static <A,B,C,D,E,F> Function<A,F> compose(Function<A,B> f1,
                                                                                      Function<B,C> f2,
                                                                                      Function<C,D> f3,
                                                                                      Function<D,E> f4,
                                                                                      Function<E,F> f5)

Returns a Function that composes the specified Functions with chained Function.andThen(Function). It is useful when you need to compose method handles, which is impossible with Function.andThen(Function):

 Function<A, B> f = Functions.compose(TypeA::new, TypeB::new);
 

compose

public static <A,B,C,D,E,F,G> Function<A,G> compose(Function<A,B> f1,
                                                                                              Function<B,C> f2,
                                                                                              Function<C,D> f3,
                                                                                              Function<D,E> f4,
                                                                                              Function<E,F> f5,
                                                                                              Function<F,G> f6)

Returns a Function that composes the specified Functions with chained Function.andThen(Function). It is useful when you need to compose method handles, which is impossible with Function.andThen(Function):

 Function<A, B> f = Functions.compose(TypeA::new, TypeB::new);
 

compose

public static <A,B,C,D,E,F,G,H> Function<A,H> compose(Function<A,B> f1,
                                                                                                      Function<B,C> f2,
                                                                                                      Function<C,D> f3,
                                                                                                      Function<D,E> f4,
                                                                                                      Function<E,F> f5,
                                                                                                      Function<F,G> f6,
                                                                                                      Function<G,H> f7)

Returns a Function that composes the specified Functions with chained Function.andThen(Function). It is useful when you need to compose method handles, which is impossible with Function.andThen(Function):

 Function<A, B> f = Functions.compose(TypeA::new, TypeB::new);
 

compose

public static <A,B,C,D,E,F,G,H,I> Function<A,I> compose(Function<A,B> f1,
                                                                                                              Function<B,C> f2,
                                                                                                              Function<C,D> f3,
                                                                                                              Function<D,E> f4,
                                                                                                              Function<E,F> f5,
                                                                                                              Function<F,G> f6,
                                                                                                              Function<G,H> f7,
                                                                                                              Function<H,I> f8)

Returns a Function that composes the specified Functions with chained Function.andThen(Function). It is useful when you need to compose method handles, which is impossible with Function.andThen(Function):

 Function<A, B> f = Functions.compose(TypeA::new, TypeB::new);
 

compose

public static <A,B,C,D,E,F,G,H,I,J> Function<A,J> compose(Function<A,B> f1,
                                                                                                                      Function<B,C> f2,
                                                                                                                      Function<C,D> f3,
                                                                                                                      Function<D,E> f4,
                                                                                                                      Function<E,F> f5,
                                                                                                                      Function<F,G> f6,
                                                                                                                      Function<G,H> f7,
                                                                                                                      Function<H,I> f8,
                                                                                                                      Function<I,J> f9)

Returns a Function that composes the specified Functions with chained Function.andThen(Function). It is useful when you need to compose method handles, which is impossible with Function.andThen(Function):

 Function<A, B> f = Functions.compose(TypeA::new, TypeB::new);
 

voidFunction

public static <T> Function<T,Void> voidFunction(Consumer<T> consumer)

Converts the specified Consumer into a Function that returns null.

voidFunction

public static <T,U> BiFunction<T,U,Void> voidFunction(BiConsumer<T,U> consumer)

Converts the specified BiConsumer into a BiFunction that returns null.