Example usage for java.util.function LongUnaryOperator applyAsLong

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

Introduction

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

Prototype

long applyAsLong(long operand);

Source Link

Document

Applies this operator to the given operand.

Usage

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

/**
 * Creates a {@link BiObjLongToLongFunction} which uses the {@code third} parameter of this one as argument for the
 * given {@link LongUnaryOperator}.//from www .jav a2  s. c o  m
 *
 * @param <T> The type of the first argument to the function
 * @param <U> The type of the second argument to the function
 * @param operator The operator which accepts the {@code third} parameter of this one
 * @return Creates a {@code BiObjLongToLongFunction} which uses the {@code third} parameter of this one as argument
 * for the given {@code LongUnaryOperator}.
 * @throws NullPointerException If given argument is {@code null}
 */
@Nonnull
static <T, U> BiObjLongToLongFunction<T, U> onlyThird(@Nonnull final LongUnaryOperator operator) {
    Objects.requireNonNull(operator);
    return (t, u, value) -> operator.applyAsLong(value);
}

From source file:at.gridtec.lambda4j.function.bi.to.ToLongBiFunction2.java

/**
 * Returns a composed {@link ToLongBiFunction2} that first applies this function to its input, and then applies the
 * {@code after} operator to the result. If evaluation of either operation throws an exception, it is relayed to the
 * caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code long}.
 *
 * @param after The operator to apply after this function is applied
 * @return A composed {@code ToLongBiFunction2} that first applies this function to its input, and then applies the
 * {@code after} operator to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * long}.//from w  ww. j  a  v  a  2 s  . c  o m
 */
@Nonnull
default ToLongBiFunction2<T, U> andThenToLong(@Nonnull final LongUnaryOperator after) {
    Objects.requireNonNull(after);
    return (t, u) -> after.applyAsLong(applyAsLong(t, u));
}

From source file:at.gridtec.lambda4j.function.tri.to.ToLongTriFunction.java

/**
 * Returns a composed {@link ToLongTriFunction} that first applies this function to its input, and then applies the
 * {@code after} operator to the result. If evaluation of either operation throws an exception, it is relayed to the
 * caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code long}.
 *
 * @param after The operator to apply after this function is applied
 * @return A composed {@code ToLongTriFunction} that first applies this function to its input, and then applies the
 * {@code after} operator to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * long}./*from   w  ww  .j a v  a 2 s . c om*/
 */
@Nonnull
default ToLongTriFunction<T, U, V> andThenToLong(@Nonnull final LongUnaryOperator after) {
    Objects.requireNonNull(after);
    return (t, u, v) -> after.applyAsLong(applyAsLong(t, u, v));
}

From source file:at.gridtec.lambda4j.function.bi.BiLongFunction.java

/**
 * Returns a composed {@link BiLongFunction} that first applies the {@code before} operators 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.
 * This method is just convenience, to provide the ability to execute an operation which accepts {@code long} input,
 * before this primitive function is executed.
 *
 * @param before1 The first operator to apply before this function is applied
 * @param before2 The second operator to apply before this function is applied
 * @return A composed {@code BiLongFunction} that first applies the {@code before} operators to its input, and then
 * applies this function to the result./*  w ww .j av  a 2  s.com*/
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code
 * long}.
 */
@Nonnull
default BiLongFunction<R> composeFromLong(@Nonnull final LongUnaryOperator before1,
        @Nonnull final LongUnaryOperator before2) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    return (value1, value2) -> apply(before1.applyAsLong(value1), before2.applyAsLong(value2));
}

From source file:at.gridtec.lambda4j.function.bi.obj.ObjLongFunction.java

/**
 * Returns a composed {@link BiLongFunction} 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.
 * This method is just convenience, to provide the ability to execute an operation which accepts {@code long} input,
 * before this primitive function is executed.
 *
 * @param before1 The first function to apply before this function is applied
 * @param before2 The second operator to apply before this function is applied
 * @return A composed {@code BiLongFunction} that first applies the {@code before} functions to its input, and then
 * applies this function to the result.// ww w . j ava 2 s .c o m
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to handle primitive values. In this case this is {@code
 * long}.
 */
@Nonnull
default BiLongFunction<R> composeFromLong(@Nonnull final LongFunction<? extends T> before1,
        @Nonnull final LongUnaryOperator before2) {
    Objects.requireNonNull(before1);
    Objects.requireNonNull(before2);
    return (value1, value2) -> apply(before1.apply(value1), before2.applyAsLong(value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiBooleanToLongFunction.java

/**
 * Returns a composed {@link BiBooleanToLongFunction} that first applies this function to its input, and then
 * applies the {@code after} operator to the result. If evaluation of either operation throws an exception, it is
 * relayed to the caller of the composed operation. This method is just convenience, to provide the ability to
 * transform this primitive function to an operation returning {@code long}.
 *
 * @param after The operator to apply after this function is applied
 * @return A composed {@code BiBooleanToLongFunction} that first applies this function to its input, and then
 * applies the {@code after} operator to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * long}./*www  .  j  a v  a2s  . c o m*/
 */
@Nonnull
default BiBooleanToLongFunction andThenToLong(@Nonnull final LongUnaryOperator after) {
    Objects.requireNonNull(after);
    return (value1, value2) -> after.applyAsLong(applyAsLong(value1, value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiByteToLongFunction.java

/**
 * Returns a composed {@link BiByteToLongFunction} that first applies this function to its input, and then applies
 * the {@code after} operator to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code long}.
 *
 * @param after The operator to apply after this function is applied
 * @return A composed {@code BiByteToLongFunction} that first applies this function to its input, and then applies
 * the {@code after} operator to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * long}./*  w  w w  .j  av  a2 s . c o  m*/
 */
@Nonnull
default BiByteToLongFunction andThenToLong(@Nonnull final LongUnaryOperator after) {
    Objects.requireNonNull(after);
    return (value1, value2) -> after.applyAsLong(applyAsLong(value1, value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiCharToLongFunction.java

/**
 * Returns a composed {@link BiCharToLongFunction} that first applies this function to its input, and then applies
 * the {@code after} operator to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code long}.
 *
 * @param after The operator to apply after this function is applied
 * @return A composed {@code BiCharToLongFunction} that first applies this function to its input, and then applies
 * the {@code after} operator to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * long}.//from  w  w w.j  ava 2  s  . co  m
 */
@Nonnull
default BiCharToLongFunction andThenToLong(@Nonnull final LongUnaryOperator after) {
    Objects.requireNonNull(after);
    return (value1, value2) -> after.applyAsLong(applyAsLong(value1, value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiFloatToLongFunction.java

/**
 * Returns a composed {@link BiFloatToLongFunction} that first applies this function to its input, and then applies
 * the {@code after} operator to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code long}.
 *
 * @param after The operator to apply after this function is applied
 * @return A composed {@code BiFloatToLongFunction} that first applies this function to its input, and then applies
 * the {@code after} operator to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * long}.//from   w w w.ja  v a2  s.  co m
 */
@Nonnull
default BiFloatToLongFunction andThenToLong(@Nonnull final LongUnaryOperator after) {
    Objects.requireNonNull(after);
    return (value1, value2) -> after.applyAsLong(applyAsLong(value1, value2));
}

From source file:at.gridtec.lambda4j.function.bi.conversion.BiShortToLongFunction.java

/**
 * Returns a composed {@link BiShortToLongFunction} that first applies this function to its input, and then applies
 * the {@code after} operator to the result. If evaluation of either operation throws an exception, it is relayed to
 * the caller of the composed operation. This method is just convenience, to provide the ability to transform this
 * primitive function to an operation returning {@code long}.
 *
 * @param after The operator to apply after this function is applied
 * @return A composed {@code BiShortToLongFunction} that first applies this function to its input, and then applies
 * the {@code after} operator to the result.
 * @throws NullPointerException If given argument is {@code null}
 * @implSpec The input argument of this method is a able to return primitive values. In this case this is {@code
 * long}./*  www  .  j  a  v a 2s . c  o  m*/
 */
@Nonnull
default BiShortToLongFunction andThenToLong(@Nonnull final LongUnaryOperator after) {
    Objects.requireNonNull(after);
    return (value1, value2) -> after.applyAsLong(applyAsLong(value1, value2));
}