Example usage for java.util.function ToLongFunction applyAsLong

List of usage examples for java.util.function ToLongFunction applyAsLong

  1. HOME
  2. Java
  3. java
  4. java.util.function.*
  5. ToLongFunction
  6. applyAsLong

Introduction

In this page you can find the example usage for java.util.function ToLongFunction applyAsLong.

Prototype

long applyAsLong(T value);

Source Link

Document

Applies this function to the given argument.

Usage

From source file:at.gridtec.lambda4j.function.tri.conversion.TriLongToIntFunction.java

/**
 * Returns a composed {@link ToIntTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToIntTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 *//* ww  w.j a  va2 s.  co  m*/
@Nonnull
default <A, B, C> ToIntTriFunction<A, B, C> compose(@Nonnull final ToLongFunction<? super A> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsInt(before1.applyAsLong(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.conversion.TriLongToByteFunction.java

/**
 * Returns a composed {@link ToByteTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToByteTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 *///  w ww  .j  av  a 2s . com
@Nonnull
default <A, B, C> ToByteTriFunction<A, B, C> compose(@Nonnull final ToLongFunction<? super A> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsByte(before1.applyAsLong(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.conversion.TriLongToCharFunction.java

/**
 * Returns a composed {@link ToCharTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToCharTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 */// w w  w.  j  av a2  s. com
@Nonnull
default <A, B, C> ToCharTriFunction<A, B, C> compose(@Nonnull final ToLongFunction<? super A> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsChar(before1.applyAsLong(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.conversion.TriLongToFloatFunction.java

/**
 * Returns a composed {@link ToFloatTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToFloatTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 */// w  w w .  ja va2  s . com
@Nonnull
default <A, B, C> ToFloatTriFunction<A, B, C> compose(@Nonnull final ToLongFunction<? super A> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsFloat(before1.applyAsLong(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.conversion.TriLongToShortFunction.java

/**
 * Returns a composed {@link ToShortTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToShortTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 *///ww w  .  ja  va2  s.  co m
@Nonnull
default <A, B, C> ToShortTriFunction<A, B, C> compose(@Nonnull final ToLongFunction<? super A> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsShort(before1.applyAsLong(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiLongToIntFunction.java

/**
 * Returns a composed {@link ToIntTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToIntTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 *//*from   ww  w  . j  a v a  2s .co  m*/
@Nonnull
default <A, B, C> ToIntTriFunction<A, B, C> compose(@Nonnull final Function<? super A, ? extends T> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsInt(before1.apply(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiLongToLongFunction.java

/**
 * Returns a composed {@link ToLongTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToLongTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 *//*from ww w .jav a  2  s  .  c  o m*/
@Nonnull
default <A, B, C> ToLongTriFunction<A, B, C> compose(@Nonnull final Function<? super A, ? extends T> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsLong(before1.apply(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiLongToByteFunction.java

/**
 * Returns a composed {@link ToByteTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToByteTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 *///from  w  ww.  ja v  a 2 s .com
@Nonnull
default <A, B, C> ToByteTriFunction<A, B, C> compose(@Nonnull final Function<? super A, ? extends T> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsByte(before1.apply(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.obj.ObjBiLongToCharFunction.java

/**
 * Returns a composed {@link ToCharTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToCharTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 *///from w  ww .j  a  v a2 s  .  c om
@Nonnull
default <A, B, C> ToCharTriFunction<A, B, C> compose(@Nonnull final Function<? super A, ? extends T> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsChar(before1.apply(a), before2.applyAsLong(b), before3.applyAsLong(c));
}

From source file:at.gridtec.lambda4j.function.tri.conversion.TriLongToDoubleFunction.java

/**
 * Returns a composed {@link ToDoubleTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * If evaluation of either operation throws an exception, it is relayed to the caller of the composed operation.
 *
 * @param <A> The type of the argument to the first given function, and of composed function
 * @param <B> The type of the argument to the second given function, and of composed function
 * @param <C> The type of the argument to the third given function, and of composed function
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second function to apply before this function is applied
 * @param before3 The third function to apply before this function is applied
 * @return A composed {@code ToDoubleTriFunction} that first applies the {@code before} functions to its input, and
 * then applies this function to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is able to handle every type.
 *//* w  ww  . j a va 2 s. com*/
@Nonnull
default <A, B, C> ToDoubleTriFunction<A, B, C> compose(@Nonnull final ToLongFunction<? super A> before1,
        @Nonnull final ToLongFunction<? super B> before2, @Nonnull final ToLongFunction<? super C> before3) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    Objects.requireNonNull(before3);
    return (a, b, c) -> applyAsDouble(before1.applyAsLong(a), before2.applyAsLong(b), before3.applyAsLong(c));
}