| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.internal.util.function.pooled; |
| |
| import static com.android.internal.util.function.pooled.PooledLambdaImpl.acquire; |
| import static com.android.internal.util.function.pooled.PooledLambdaImpl.acquireConstSupplier; |
| |
| import android.os.Message; |
| |
| import com.android.internal.util.function.HeptConsumer; |
| import com.android.internal.util.function.HeptFunction; |
| import com.android.internal.util.function.HexConsumer; |
| import com.android.internal.util.function.HexFunction; |
| import com.android.internal.util.function.NonaConsumer; |
| import com.android.internal.util.function.NonaFunction; |
| import com.android.internal.util.function.OctConsumer; |
| import com.android.internal.util.function.OctFunction; |
| import com.android.internal.util.function.QuadConsumer; |
| import com.android.internal.util.function.QuadFunction; |
| import com.android.internal.util.function.QuintConsumer; |
| import com.android.internal.util.function.QuintFunction; |
| import com.android.internal.util.function.TriConsumer; |
| import com.android.internal.util.function.TriFunction; |
| import com.android.internal.util.function.pooled.PooledLambdaImpl.LambdaType.ReturnType; |
| |
| import java.util.function.BiConsumer; |
| import java.util.function.BiFunction; |
| import java.util.function.BiPredicate; |
| import java.util.function.Consumer; |
| import java.util.function.Function; |
| import java.util.function.Predicate; |
| import java.util.function.Supplier; |
| |
| /** |
| * A recyclable anonymous function. |
| * Allows obtaining {@link Function}s/{@link Runnable}s/{@link Supplier}s/etc. without allocating a |
| * new instance each time |
| * |
| * This exploits the mechanic that stateless lambdas (such as plain/non-bound method references) |
| * get translated into a singleton instance, making it possible to create a recyclable container |
| * ({@link PooledLambdaImpl}) holding a reference to such a singleton function, as well as |
| * (possibly partial) arguments required for its invocation. |
| * |
| * To obtain an instance, use one of the factory methods in this class. |
| * |
| * You can call {@link #recycleOnUse} to make the instance automatically recycled upon invocation, |
| * making if effectively <b>one-time use</b>. |
| * This is often the behavior you want, as it allows to not worry about manual recycling. |
| * Some notable examples: {@link android.os.Handler#post(Runnable)}, |
| * {@link android.app.Activity#runOnUiThread(Runnable)}, {@link android.view.View#post(Runnable)} |
| * |
| * For factories of functions that take further arguments, the corresponding 'missing' argument's |
| * position is marked by an argument of type {@link ArgumentPlaceholder} with the type parameter |
| * corresponding to missing argument's type. |
| * You can fill the 'missing argument' spot with {@link #__()} |
| * (which is the factory function for {@link ArgumentPlaceholder}) |
| * |
| * NOTE: It is highly recommended to <b>only</b> use {@code ClassName::methodName} |
| * (aka unbounded method references) as the 1st argument for any of the |
| * factories ({@code obtain*(...)}) to avoid unwanted allocations. |
| * This means <b>not</b> using: |
| * <ul> |
| * <li>{@code someVar::methodName} or {@code this::methodName} as it captures the reference |
| * on the left of {@code ::}, resulting in an allocation on each evaluation of such |
| * bounded method references</li> |
| * |
| * <li>A lambda expression, e.g. {@code () -> toString()} due to how easy it is to accidentally |
| * capture state from outside. In the above lambda expression for example, no variable from |
| * outer scope is explicitly mentioned, yet one is still captured due to {@code toString()} |
| * being an equivalent of {@code this.toString()}</li> |
| * </ul> |
| * |
| * @hide |
| */ |
| @SuppressWarnings({"unchecked", "unused", "WeakerAccess"}) |
| public interface PooledLambda { |
| |
| /** |
| * Recycles this instance. No-op if already recycled. |
| */ |
| void recycle(); |
| |
| /** |
| * Makes this instance automatically {@link #recycle} itself after the first call. |
| * |
| * @return this instance for convenience |
| */ |
| PooledLambda recycleOnUse(); |
| |
| |
| // Factories |
| |
| /** |
| * @return {@link ArgumentPlaceholder} with the inferred type parameter value |
| */ |
| static <R> ArgumentPlaceholder<R> __() { |
| return (ArgumentPlaceholder<R>) ArgumentPlaceholder.INSTANCE; |
| } |
| |
| /** |
| * @param typeHint the explicitly specified type of the missing argument |
| * @return {@link ArgumentPlaceholder} with the specified type parameter value |
| */ |
| static <R> ArgumentPlaceholder<R> __(Class<R> typeHint) { |
| return __(); |
| } |
| |
| /** |
| * Wraps the given value into a {@link PooledSupplier} |
| * |
| * @param value a value to wrap |
| * @return a pooled supplier of {@code value} |
| */ |
| static <R> PooledSupplier<R> obtainSupplier(R value) { |
| PooledLambdaImpl r = acquireConstSupplier(ReturnType.OBJECT); |
| r.mFunc = value; |
| return r; |
| } |
| |
| /** |
| * Wraps the given value into a {@link PooledSupplier} |
| * |
| * @param value a value to wrap |
| * @return a pooled supplier of {@code value} |
| */ |
| static PooledSupplier.OfInt obtainSupplier(int value) { |
| PooledLambdaImpl r = acquireConstSupplier(ReturnType.INT); |
| r.mConstValue = value; |
| return r; |
| } |
| |
| /** |
| * Wraps the given value into a {@link PooledSupplier} |
| * |
| * @param value a value to wrap |
| * @return a pooled supplier of {@code value} |
| */ |
| static PooledSupplier.OfLong obtainSupplier(long value) { |
| PooledLambdaImpl r = acquireConstSupplier(ReturnType.LONG); |
| r.mConstValue = value; |
| return r; |
| } |
| |
| /** |
| * Wraps the given value into a {@link PooledSupplier} |
| * |
| * @param value a value to wrap |
| * @return a pooled supplier of {@code value} |
| */ |
| static PooledSupplier.OfDouble obtainSupplier(double value) { |
| PooledLambdaImpl r = acquireConstSupplier(ReturnType.DOUBLE); |
| r.mConstValue = Double.doubleToRawLongBits(value); |
| return r; |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1) } |
| */ |
| static <A> PooledRunnable obtainRunnable( |
| Consumer<? super A> function, |
| A arg1) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 1, 0, ReturnType.VOID, arg1, null, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1) } |
| */ |
| static <A> PooledSupplier<Boolean> obtainSupplier( |
| Predicate<? super A> function, |
| A arg1) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 1, 0, ReturnType.BOOLEAN, arg1, null, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1) } |
| */ |
| static <A, R> PooledSupplier<R> obtainSupplier( |
| Function<? super A, ? extends R> function, |
| A arg1) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 1, 0, ReturnType.OBJECT, arg1, null, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(Consumer, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1) } when handled |
| */ |
| static <A> Message obtainMessage( |
| Consumer<? super A> function, |
| A arg1) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 1, 0, ReturnType.VOID, arg1, null, null, null, null, null, null, null, |
| null); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2) } |
| */ |
| static <A, B> PooledRunnable obtainRunnable( |
| BiConsumer<? super A, ? super B> function, |
| A arg1, B arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 0, ReturnType.VOID, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2) } |
| */ |
| static <A, B> PooledSupplier<Boolean> obtainSupplier( |
| BiPredicate<? super A, ? super B> function, |
| A arg1, B arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 0, ReturnType.BOOLEAN, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2) } |
| */ |
| static <A, B, R> PooledSupplier<R> obtainSupplier( |
| BiFunction<? super A, ? super B, ? extends R> function, |
| A arg1, B arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 0, ReturnType.OBJECT, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg2 parameter supplied to {@code function} on call |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg1) -> function(arg1, arg2) } |
| */ |
| static <A, B> PooledConsumer<A> obtainConsumer( |
| BiConsumer<? super A, ? super B> function, |
| ArgumentPlaceholder<A> arg1, B arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 1, ReturnType.VOID, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledPredicate} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg2 parameter supplied to {@code function} on call |
| * @return a {@link PooledPredicate}, equivalent to lambda: |
| * {@code (arg1) -> function(arg1, arg2) } |
| */ |
| static <A, B> PooledPredicate<A> obtainPredicate( |
| BiPredicate<? super A, ? super B> function, |
| ArgumentPlaceholder<A> arg1, B arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 1, ReturnType.BOOLEAN, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg2 parameter supplied to {@code function} on call |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg1) -> function(arg1, arg2) } |
| */ |
| static <A, B, R> PooledFunction<A, R> obtainFunction( |
| BiFunction<? super A, ? super B, ? extends R> function, |
| ArgumentPlaceholder<A> arg1, B arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 1, ReturnType.OBJECT, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 placeholder for a missing argument. Use {@link #__} to get one |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg2) -> function(arg1, arg2) } |
| */ |
| static <A, B> PooledConsumer<B> obtainConsumer( |
| BiConsumer<? super A, ? super B> function, |
| A arg1, ArgumentPlaceholder<B> arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 1, ReturnType.VOID, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledPredicate} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 placeholder for a missing argument. Use {@link #__} to get one |
| * @return a {@link PooledPredicate}, equivalent to lambda: |
| * {@code (arg2) -> function(arg1, arg2) } |
| */ |
| static <A, B> PooledPredicate<B> obtainPredicate( |
| BiPredicate<? super A, ? super B> function, |
| A arg1, ArgumentPlaceholder<B> arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 1, ReturnType.BOOLEAN, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 placeholder for a missing argument. Use {@link #__} to get one |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg2) -> function(arg1, arg2) } |
| */ |
| static <A, B, R> PooledFunction<B, R> obtainFunction( |
| BiFunction<? super A, ? super B, ? extends R> function, |
| A arg1, ArgumentPlaceholder<B> arg2) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 2, 1, ReturnType.OBJECT, arg1, arg2, null, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(BiConsumer, Object, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1, arg2) } when handled |
| */ |
| static <A, B> Message obtainMessage( |
| BiConsumer<? super A, ? super B> function, |
| A arg1, B arg2) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 2, 0, ReturnType.VOID, arg1, arg2, null, null, null, null, null, null, |
| null); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3) } |
| */ |
| static <A, B, C> PooledRunnable obtainRunnable( |
| TriConsumer<? super A, ? super B, ? super C> function, |
| A arg1, B arg2, C arg3) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 3, 0, ReturnType.VOID, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3) } |
| */ |
| static <A, B, C, R> PooledSupplier<R> obtainSupplier( |
| TriFunction<? super A, ? super B, ? super C, ? extends R> function, |
| A arg1, B arg2, C arg3) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 3, 0, ReturnType.OBJECT, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg1) -> function(arg1, arg2, arg3) } |
| */ |
| static <A, B, C> PooledConsumer<A> obtainConsumer( |
| TriConsumer<? super A, ? super B, ? super C> function, |
| ArgumentPlaceholder<A> arg1, B arg2, C arg3) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 3, 1, ReturnType.VOID, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg1) -> function(arg1, arg2, arg3) } |
| */ |
| static <A, B, C, R> PooledFunction<A, R> obtainFunction( |
| TriFunction<? super A, ? super B, ? super C, ? extends R> function, |
| ArgumentPlaceholder<A> arg1, B arg2, C arg3) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 3, 1, ReturnType.OBJECT, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg3 parameter supplied to {@code function} on call |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg2) -> function(arg1, arg2, arg3) } |
| */ |
| static <A, B, C> PooledConsumer<B> obtainConsumer( |
| TriConsumer<? super A, ? super B, ? super C> function, |
| A arg1, ArgumentPlaceholder<B> arg2, C arg3) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 3, 1, ReturnType.VOID, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg3 parameter supplied to {@code function} on call |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg2) -> function(arg1, arg2, arg3) } |
| */ |
| static <A, B, C, R> PooledFunction<B, R> obtainFunction( |
| TriFunction<? super A, ? super B, ? super C, ? extends R> function, |
| A arg1, ArgumentPlaceholder<B> arg2, C arg3) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 3, 1, ReturnType.OBJECT, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 placeholder for a missing argument. Use {@link #__} to get one |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg3) -> function(arg1, arg2, arg3) } |
| */ |
| static <A, B, C> PooledConsumer<C> obtainConsumer( |
| TriConsumer<? super A, ? super B, ? super C> function, |
| A arg1, B arg2, ArgumentPlaceholder<C> arg3) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 3, 1, ReturnType.VOID, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 placeholder for a missing argument. Use {@link #__} to get one |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg3) -> function(arg1, arg2, arg3) } |
| */ |
| static <A, B, C, R> PooledFunction<C, R> obtainFunction( |
| TriFunction<? super A, ? super B, ? super C, ? extends R> function, |
| A arg1, B arg2, ArgumentPlaceholder<C> arg3) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 3, 1, ReturnType.OBJECT, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(TriConsumer, Object, Object, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1, arg2, arg3) } when handled |
| */ |
| static <A, B, C> Message obtainMessage( |
| TriConsumer<? super A, ? super B, ? super C> function, |
| A arg1, B arg2, C arg3) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 3, 0, ReturnType.VOID, arg1, arg2, arg3, null, null, null, null, null, |
| null); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D> PooledRunnable obtainRunnable( |
| QuadConsumer<? super A, ? super B, ? super C, ? super D> function, |
| A arg1, B arg2, C arg3, D arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D, R> PooledSupplier<R> obtainSupplier( |
| QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends R> function, |
| A arg1, B arg2, C arg3, D arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 0, ReturnType.OBJECT, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg1) -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D> PooledConsumer<A> obtainConsumer( |
| QuadConsumer<? super A, ? super B, ? super C, ? super D> function, |
| ArgumentPlaceholder<A> arg1, B arg2, C arg3, D arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 1, ReturnType.VOID, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg1) -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D, R> PooledFunction<A, R> obtainFunction( |
| QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends R> function, |
| ArgumentPlaceholder<A> arg1, B arg2, C arg3, D arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 1, ReturnType.OBJECT, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg2) -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D> PooledConsumer<B> obtainConsumer( |
| QuadConsumer<? super A, ? super B, ? super C, ? super D> function, |
| A arg1, ArgumentPlaceholder<B> arg2, C arg3, D arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 1, ReturnType.VOID, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg2) -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D, R> PooledFunction<B, R> obtainFunction( |
| QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends R> function, |
| A arg1, ArgumentPlaceholder<B> arg2, C arg3, D arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 1, ReturnType.OBJECT, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg3) -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D> PooledConsumer<C> obtainConsumer( |
| QuadConsumer<? super A, ? super B, ? super C, ? super D> function, |
| A arg1, B arg2, ArgumentPlaceholder<C> arg3, D arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 1, ReturnType.VOID, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 placeholder for a missing argument. Use {@link #__} to get one |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg3) -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D, R> PooledFunction<C, R> obtainFunction( |
| QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends R> function, |
| A arg1, B arg2, ArgumentPlaceholder<C> arg3, D arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 1, ReturnType.OBJECT, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledConsumer} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 placeholder for a missing argument. Use {@link #__} to get one |
| * @return a {@link PooledConsumer}, equivalent to lambda: |
| * {@code (arg4) -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D> PooledConsumer<D> obtainConsumer( |
| QuadConsumer<? super A, ? super B, ? super C, ? super D> function, |
| A arg1, B arg2, C arg3, ArgumentPlaceholder<D> arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 1, ReturnType.VOID, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledFunction} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 placeholder for a missing argument. Use {@link #__} to get one |
| * @return a {@link PooledFunction}, equivalent to lambda: |
| * {@code (arg4) -> function(arg1, arg2, arg3, arg4) } |
| */ |
| static <A, B, C, D, R> PooledFunction<D, R> obtainFunction( |
| QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends R> function, |
| A arg1, B arg2, C arg3, ArgumentPlaceholder<D> arg4) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 4, 1, ReturnType.OBJECT, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(QuadConsumer, Object, Object, Object, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1, arg2, arg3, arg4) } when handled |
| */ |
| static <A, B, C, D> Message obtainMessage( |
| QuadConsumer<? super A, ? super B, ? super C, ? super D> function, |
| A arg1, B arg2, C arg3, D arg4) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 4, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, null, null, null, null, |
| null); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5) } |
| */ |
| static <A, B, C, D, E> PooledRunnable obtainRunnable( |
| QuintConsumer<? super A, ? super B, ? super C, ? super D, ? super E> function, |
| A arg1, B arg2, C arg3, D arg4, E arg5) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 5, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, null, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5) } |
| */ |
| static <A, B, C, D, E, R> PooledSupplier<R> obtainSupplier( |
| QuintFunction<? super A, ? super B, ? super C, ? super D, ? super E, ? extends R> |
| function, A arg1, B arg2, C arg3, D arg4, E arg5) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 5, 0, ReturnType.OBJECT, arg1, arg2, arg3, arg4, arg5, null, null, null, |
| null); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(QuintConsumer, Object, Object, Object, Object, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1, arg2, arg3, arg4, arg5) } when |
| * handled |
| */ |
| static <A, B, C, D, E> Message obtainMessage( |
| QuintConsumer<? super A, ? super B, ? super C, ? super D, ? super E> function, |
| A arg1, B arg2, C arg3, D arg4, E arg5) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 5, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, null, null, null, |
| null); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5, arg6) } |
| */ |
| static <A, B, C, D, E, F> PooledRunnable obtainRunnable( |
| HexConsumer<? super A, ? super B, ? super C, ? super D, ? super E, ? super F> function, |
| A arg1, B arg2, C arg3, D arg4, E arg5, F arg6) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 6, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, null, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5, arg6) } |
| */ |
| static <A, B, C, D, E, F, R> PooledSupplier<R> obtainSupplier( |
| HexFunction<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, |
| ? extends R> function, A arg1, B arg2, C arg3, D arg4, E arg5, F arg6) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 6, 0, ReturnType.OBJECT, arg1, arg2, arg3, arg4, arg5, arg6, null, null, |
| null); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(QuintConsumer, Object, Object, Object, Object, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1, arg2, arg3, arg4, arg5, arg6) } |
| * when handled |
| */ |
| static <A, B, C, D, E, F> Message obtainMessage( |
| HexConsumer<? super A, ? super B, ? super C, ? super D, ? super E, ? super F> function, |
| A arg1, B arg2, C arg3, D arg4, E arg5, F arg6) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 6, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, null, null, |
| null); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } |
| */ |
| static <A, B, C, D, E, F, G> PooledRunnable obtainRunnable( |
| HeptConsumer<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, |
| ? super G> function, A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 7, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, null, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } |
| */ |
| static <A, B, C, D, E, F, G, R> PooledSupplier<R> obtainSupplier( |
| HeptFunction<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, |
| ? super G, ? extends R> function, |
| A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 7, 0, ReturnType.OBJECT, arg1, arg2, arg3, arg4, arg5, arg6, arg7, null, |
| null); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(QuintConsumer, Object, Object, Object, Object, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1, arg2, arg3, arg4, arg5, arg6, |
| * arg7) } when handled |
| */ |
| static <A, B, C, D, E, F, G> Message obtainMessage( |
| HeptConsumer<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, |
| ? super G> function, A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 7, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, null, |
| null); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @param arg8 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) } |
| */ |
| static <A, B, C, D, E, F, G, H> PooledRunnable obtainRunnable( |
| OctConsumer<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, |
| ? super H> function, A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7, |
| H arg8) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 8, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, |
| null); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @param arg8 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) } |
| */ |
| static <A, B, C, D, E, F, G, H, R> PooledSupplier<R> obtainSupplier( |
| OctFunction<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, |
| ? super G, ? super H, ? extends R> function, |
| A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7, H arg8) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 8, 0, ReturnType.OBJECT, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, |
| null); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(QuintConsumer, Object, Object, Object, Object, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @param arg8 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1, arg2, arg3, arg4, arg5, arg6, |
| * arg7, arg8) } when handled |
| */ |
| static <A, B, C, D, E, F, G, H> Message obtainMessage( |
| OctConsumer<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, ? super G, |
| ? super H> function, A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7, |
| H arg8) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 8, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, |
| null); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| |
| /** |
| * {@link PooledRunnable} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @param arg8 parameter supplied to {@code function} on call |
| * @param arg9 parameter supplied to {@code function} on call |
| * @return a {@link PooledRunnable}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) } |
| */ |
| static <A, B, C, D, E, F, G, H, I> PooledRunnable obtainRunnable( |
| NonaConsumer<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, |
| ? super G, ? super H, ? super I> function, A arg1, B arg2, C arg3, D arg4, |
| E arg5, F arg6, G arg7, H arg8, I arg9) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 9, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, |
| arg9); |
| } |
| |
| /** |
| * {@link PooledSupplier} factory |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @param arg8 parameter supplied to {@code function} on call |
| * @param arg9 parameter supplied to {@code function} on call |
| * @return a {@link PooledSupplier}, equivalent to lambda: |
| * {@code () -> function(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) } |
| */ |
| static <A, B, C, D, E, F, G, H, I, R> PooledSupplier<R> obtainSupplier( |
| NonaFunction<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, |
| ? super G, ? super H, ? super I, ? extends R> function, |
| A arg1, B arg2, C arg3, D arg4, E arg5, F arg6, G arg7, H arg8, I arg9) { |
| return acquire(PooledLambdaImpl.sPool, |
| function, 9, 0, ReturnType.OBJECT, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, |
| arg9); |
| } |
| |
| /** |
| * Factory of {@link Message}s that contain an |
| * ({@link PooledLambda#recycleOnUse auto-recycling}) {@link PooledRunnable} as its |
| * {@link Message#getCallback internal callback}. |
| * |
| * The callback is equivalent to one obtainable via |
| * {@link #obtainRunnable(QuintConsumer, Object, Object, Object, Object, Object)} |
| * |
| * Note that using this method with {@link android.os.Handler#handleMessage} |
| * is more efficient than the alternative of {@link android.os.Handler#post} |
| * with a {@link PooledRunnable} due to the lack of 2 separate synchronization points |
| * when obtaining {@link Message} and {@link PooledRunnable} from pools separately |
| * |
| * You may optionally set a {@link Message#what} for the message if you want to be |
| * able to cancel it via {@link android.os.Handler#removeMessages}, but otherwise |
| * there's no need to do so |
| * |
| * @param function non-capturing lambda(typically an unbounded method reference) |
| * to be invoked on call |
| * @param arg1 parameter supplied to {@code function} on call |
| * @param arg2 parameter supplied to {@code function} on call |
| * @param arg3 parameter supplied to {@code function} on call |
| * @param arg4 parameter supplied to {@code function} on call |
| * @param arg5 parameter supplied to {@code function} on call |
| * @param arg6 parameter supplied to {@code function} on call |
| * @param arg7 parameter supplied to {@code function} on call |
| * @param arg8 parameter supplied to {@code function} on call |
| * @param arg9 parameter supplied to {@code function} on call |
| * @return a {@link Message} invoking {@code function(arg1, arg2, arg3, arg4, arg5, arg6, |
| * arg7, arg8, arg9) } when handled |
| */ |
| static <A, B, C, D, E, F, G, H, I> Message obtainMessage( |
| NonaConsumer<? super A, ? super B, ? super C, ? super D, ? super E, ? super F, |
| ? super G, ? super H, ? super I> function, A arg1, B arg2, C arg3, D arg4, |
| E arg5, F arg6, G arg7, H arg8, I arg9) { |
| synchronized (Message.sPoolSync) { |
| PooledRunnable callback = acquire(PooledLambdaImpl.sMessageCallbacksPool, |
| function, 9, 0, ReturnType.VOID, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, |
| arg9); |
| return Message.obtain().setCallback(callback.recycleOnUse()); |
| } |
| } |
| } |
