Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.reactivex.rxjava3.internal.functions.Functions Maven / Gradle / Ivy
Go to download
Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC
/*
* Copyright (c) 2016-present, RxJava Contributors.
*
* 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 io.reactivex.rxjava3.internal.functions;
import java.util.*;
import java.util.concurrent.*;
import org.reactivestreams.Subscription;
import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.*;
import io.reactivex.rxjava3.exceptions.OnErrorNotImplementedException;
import io.reactivex.rxjava3.functions.*;
import io.reactivex.rxjava3.plugins.RxJavaPlugins;
import io.reactivex.rxjava3.schedulers.Timed;
/**
* Utility methods to convert the BiFunction, Function3..Function9 instances to Function of Object array.
*/
public final class Functions {
/** Utility class. */
private Functions() {
throw new IllegalStateException("No instances!");
}
@NonNull
public static Function toFunction(@NonNull BiFunction super T1, ? super T2, ? extends R> f) {
return new Array2Func<>(f);
}
@NonNull
public static Function toFunction(@NonNull Function3 f) {
return new Array3Func<>(f);
}
@NonNull
public static Function toFunction(@NonNull Function4 f) {
return new Array4Func<>(f);
}
@NonNull
public static Function toFunction(@NonNull Function5 f) {
return new Array5Func<>(f);
}
@NonNull
public static Function toFunction(
@NonNull Function6 f) {
return new Array6Func<>(f);
}
@NonNull
public static Function toFunction(
@NonNull Function7 f) {
return new Array7Func<>(f);
}
@NonNull
public static Function toFunction(
@NonNull Function8 f) {
return new Array8Func<>(f);
}
@NonNull
public static Function toFunction(
@NonNull Function9 f) {
return new Array9Func<>(f);
}
/** A singleton identity function. */
static final Function IDENTITY = new Identity();
/**
* Returns an identity function that simply returns its argument.
* @param the input and output value type
* @return the identity function
*/
@SuppressWarnings("unchecked")
@NonNull
public static Function identity() {
return (Function)IDENTITY;
}
public static final Runnable EMPTY_RUNNABLE = new EmptyRunnable();
public static final Action EMPTY_ACTION = new EmptyAction();
static final Consumer EMPTY_CONSUMER = new EmptyConsumer();
/**
* Returns an empty consumer that does nothing.
* @param the consumed value type, the value is ignored
* @return an empty consumer that does nothing.
*/
@SuppressWarnings("unchecked")
public static Consumer emptyConsumer() {
return (Consumer)EMPTY_CONSUMER;
}
public static final Consumer ERROR_CONSUMER = new ErrorConsumer();
/**
* Wraps the consumed Throwable into an OnErrorNotImplementedException and
* signals it to the plugin error handler.
*/
public static final Consumer ON_ERROR_MISSING = new OnErrorMissingConsumer();
public static final LongConsumer EMPTY_LONG_CONSUMER = new EmptyLongConsumer();
static final Predicate ALWAYS_TRUE = new TruePredicate();
static final Predicate ALWAYS_FALSE = new FalsePredicate();
static final Supplier NULL_SUPPLIER = new NullProvider();
@SuppressWarnings("unchecked")
@NonNull
public static Predicate alwaysTrue() {
return (Predicate)ALWAYS_TRUE;
}
@SuppressWarnings("unchecked")
@NonNull
public static Predicate alwaysFalse() {
return (Predicate)ALWAYS_FALSE;
}
@SuppressWarnings("unchecked")
@NonNull
public static Supplier nullSupplier() {
return (Supplier)NULL_SUPPLIER;
}
static final class FutureAction implements Action {
final Future> future;
FutureAction(Future> future) {
this.future = future;
}
@Override
public void run() throws Exception {
future.get();
}
}
/**
* Wraps the blocking get call of the Future into an Action.
* @param future the future to call get() on, not null
* @return the new Action instance
*/
@NonNull
public static Action futureAction(@NonNull Future> future) {
return new FutureAction(future);
}
static final class JustValue implements Callable, Supplier, Function {
final U value;
JustValue(U value) {
this.value = value;
}
@Override
public U call() {
return value;
}
@Override
public U apply(T t) {
return value;
}
@Override
public U get() {
return value;
}
}
/**
* Returns a Callable that returns the given value.
* @param the value type
* @param value the value to return
* @return the new Callable instance
*/
@NonNull
public static Callable justCallable(@NonNull T value) {
return new JustValue<>(value);
}
/**
* Returns a Supplier that returns the given value.
* @param the value type
* @param value the value to return
* @return the new Callable instance
*/
@NonNull
public static Supplier justSupplier(@NonNull T value) {
return new JustValue<>(value);
}
/**
* Returns a Function that ignores its parameter and returns the given value.
* @param the function's input type
* @param the value and return type of the function
* @param value the value to return
* @return the new Function instance
*/
@NonNull
public static Function justFunction(@NonNull U value) {
return new JustValue<>(value);
}
static final class CastToClass implements Function {
final Class clazz;
CastToClass(Class clazz) {
this.clazz = clazz;
}
@Override
public U apply(T t) {
return clazz.cast(t);
}
}
/**
* Returns a function that cast the incoming values via a Class object.
* @param the input value type
* @param the output and target type
* @param target the target class
* @return the new Function instance
*/
@NonNull
public static Function castFunction(@NonNull Class target) {
return new CastToClass<>(target);
}
static final class ArrayListCapacityCallable implements Supplier> {
final int capacity;
ArrayListCapacityCallable(int capacity) {
this.capacity = capacity;
}
@Override
public List get() {
return new ArrayList<>(capacity);
}
}
public static Supplier> createArrayList(int capacity) {
return new ArrayListCapacityCallable<>(capacity);
}
static final class EqualsPredicate implements Predicate {
final T value;
EqualsPredicate(T value) {
this.value = value;
}
@Override
public boolean test(T t) {
return Objects.equals(t, value);
}
}
public static Predicate equalsWith(T value) {
return new EqualsPredicate<>(value);
}
enum HashSetSupplier implements Supplier> {
INSTANCE;
@Override
public Set get() {
return new HashSet<>();
}
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public static Supplier> createHashSet() {
return (Supplier)HashSetSupplier.INSTANCE;
}
static final class NotificationOnNext implements Consumer {
final Consumer super Notification> onNotification;
NotificationOnNext(Consumer super Notification> onNotification) {
this.onNotification = onNotification;
}
@Override
public void accept(T v) throws Throwable {
onNotification.accept(Notification.createOnNext(v));
}
}
static final class NotificationOnError implements Consumer {
final Consumer super Notification> onNotification;
NotificationOnError(Consumer super Notification> onNotification) {
this.onNotification = onNotification;
}
@Override
public void accept(Throwable v) throws Throwable {
onNotification.accept(Notification.createOnError(v));
}
}
static final class NotificationOnComplete implements Action {
final Consumer super Notification> onNotification;
NotificationOnComplete(Consumer super Notification> onNotification) {
this.onNotification = onNotification;
}
@Override
public void run() throws Throwable {
onNotification.accept(Notification.createOnComplete());
}
}
public static Consumer notificationOnNext(Consumer super Notification> onNotification) {
return new NotificationOnNext<>(onNotification);
}
public static Consumer notificationOnError(Consumer super Notification> onNotification) {
return new NotificationOnError<>(onNotification);
}
public static Action notificationOnComplete(Consumer super Notification> onNotification) {
return new NotificationOnComplete<>(onNotification);
}
static final class ActionConsumer implements Consumer {
final Action action;
ActionConsumer(Action action) {
this.action = action;
}
@Override
public void accept(T t) throws Throwable {
action.run();
}
}
public static Consumer actionConsumer(Action action) {
return new ActionConsumer<>(action);
}
static final class ClassFilter implements Predicate {
final Class clazz;
ClassFilter(Class clazz) {
this.clazz = clazz;
}
@Override
public boolean test(T t) {
return clazz.isInstance(t);
}
}
public static Predicate isInstanceOf(Class clazz) {
return new ClassFilter<>(clazz);
}
static final class BooleanSupplierPredicateReverse implements Predicate {
final BooleanSupplier supplier;
BooleanSupplierPredicateReverse(BooleanSupplier supplier) {
this.supplier = supplier;
}
@Override
public boolean test(T t) throws Throwable {
return !supplier.getAsBoolean();
}
}
public static Predicate predicateReverseFor(BooleanSupplier supplier) {
return new BooleanSupplierPredicateReverse<>(supplier);
}
static final class TimestampFunction implements Function> {
final TimeUnit unit;
final Scheduler scheduler;
TimestampFunction(TimeUnit unit, Scheduler scheduler) {
this.unit = unit;
this.scheduler = scheduler;
}
@Override
public Timed apply(T t) {
return new Timed<>(t, scheduler.now(unit), unit);
}
}
public static Function> timestampWith(TimeUnit unit, Scheduler scheduler) {
return new TimestampFunction<>(unit, scheduler);
}
static final class ToMapKeySelector implements BiConsumer, T> {
private final Function super T, ? extends K> keySelector;
ToMapKeySelector(Function super T, ? extends K> keySelector) {
this.keySelector = keySelector;
}
@Override
public void accept(Map m, T t) throws Throwable {
K key = keySelector.apply(t);
m.put(key, t);
}
}
public static BiConsumer, T> toMapKeySelector(final Function super T, ? extends K> keySelector) {
return new ToMapKeySelector<>(keySelector);
}
static final class ToMapKeyValueSelector implements BiConsumer, T> {
private final Function super T, ? extends V> valueSelector;
private final Function super T, ? extends K> keySelector;
ToMapKeyValueSelector(Function super T, ? extends V> valueSelector,
Function super T, ? extends K> keySelector) {
this.valueSelector = valueSelector;
this.keySelector = keySelector;
}
@Override
public void accept(Map m, T t) throws Throwable {
K key = keySelector.apply(t);
V value = valueSelector.apply(t);
m.put(key, value);
}
}
public static BiConsumer, T> toMapKeyValueSelector(final Function super T, ? extends K> keySelector, final Function super T, ? extends V> valueSelector) {
return new ToMapKeyValueSelector<>(valueSelector, keySelector);
}
static final class ToMultimapKeyValueSelector implements BiConsumer>, T> {
private final Function super K, ? extends Collection super V>> collectionFactory;
private final Function super T, ? extends V> valueSelector;
private final Function super T, ? extends K> keySelector;
ToMultimapKeyValueSelector(Function super K, ? extends Collection super V>> collectionFactory,
Function super T, ? extends V> valueSelector, Function super T, ? extends K> keySelector) {
this.collectionFactory = collectionFactory;
this.valueSelector = valueSelector;
this.keySelector = keySelector;
}
@SuppressWarnings("unchecked")
@Override
public void accept(Map> m, T t) throws Throwable {
K key = keySelector.apply(t);
Collection coll = m.get(key);
if (coll == null) {
coll = (Collection)collectionFactory.apply(key);
m.put(key, coll);
}
V value = valueSelector.apply(t);
coll.add(value);
}
}
public static BiConsumer>, T> toMultimapKeyValueSelector(
final Function super T, ? extends K> keySelector, final Function super T, ? extends V> valueSelector,
final Function super K, ? extends Collection super V>> collectionFactory) {
return new ToMultimapKeyValueSelector<>(collectionFactory, valueSelector, keySelector);
}
enum NaturalComparator implements Comparator {
INSTANCE;
@SuppressWarnings("unchecked")
@Override
public int compare(Object o1, Object o2) {
return ((Comparable)o1).compareTo(o2);
}
}
@SuppressWarnings("unchecked")
public static Comparator naturalComparator() {
return (Comparator)NaturalComparator.INSTANCE;
}
static final class ListSorter implements Function, List> {
final Comparator super T> comparator;
ListSorter(Comparator super T> comparator) {
this.comparator = comparator;
}
@Override
public List apply(List v) {
Collections.sort(v, comparator);
return v;
}
}
public static Function, List> listSorter(final Comparator super T> comparator) {
return new ListSorter<>(comparator);
}
public static final Consumer REQUEST_MAX = new MaxRequestSubscription();
static final class Array2Func implements Function {
final BiFunction super T1, ? super T2, ? extends R> f;
Array2Func(BiFunction super T1, ? super T2, ? extends R> f) {
this.f = f;
}
@SuppressWarnings("unchecked")
@Override
public R apply(Object[] a) throws Throwable {
if (a.length != 2) {
throw new IllegalArgumentException("Array of size 2 expected but got " + a.length);
}
return f.apply((T1)a[0], (T2)a[1]);
}
}
static final class Array3Func implements Function {
final Function3 f;
Array3Func(Function3 f) {
this.f = f;
}
@SuppressWarnings("unchecked")
@Override
public R apply(Object[] a) throws Throwable {
if (a.length != 3) {
throw new IllegalArgumentException("Array of size 3 expected but got " + a.length);
}
return f.apply((T1)a[0], (T2)a[1], (T3)a[2]);
}
}
static final class Array4Func implements Function {
final Function4 f;
Array4Func(Function4 f) {
this.f = f;
}
@SuppressWarnings("unchecked")
@Override
public R apply(Object[] a) throws Throwable {
if (a.length != 4) {
throw new IllegalArgumentException("Array of size 4 expected but got " + a.length);
}
return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3]);
}
}
static final class Array5Func implements Function {
private final Function5 f;
Array5Func(Function5 f) {
this.f = f;
}
@SuppressWarnings("unchecked")
@Override
public R apply(Object[] a) throws Throwable {
if (a.length != 5) {
throw new IllegalArgumentException("Array of size 5 expected but got " + a.length);
}
return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4]);
}
}
static final class Array6Func implements Function {
final Function6 f;
Array6Func(Function6 f) {
this.f = f;
}
@SuppressWarnings("unchecked")
@Override
public R apply(Object[] a) throws Throwable {
if (a.length != 6) {
throw new IllegalArgumentException("Array of size 6 expected but got " + a.length);
}
return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5]);
}
}
static final class Array7Func implements Function {
final Function7 f;
Array7Func(Function7 f) {
this.f = f;
}
@SuppressWarnings("unchecked")
@Override
public R apply(Object[] a) throws Throwable {
if (a.length != 7) {
throw new IllegalArgumentException("Array of size 7 expected but got " + a.length);
}
return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6]);
}
}
static final class Array8Func implements Function {
final Function8 f;
Array8Func(Function8 f) {
this.f = f;
}
@SuppressWarnings("unchecked")
@Override
public R apply(Object[] a) throws Throwable {
if (a.length != 8) {
throw new IllegalArgumentException("Array of size 8 expected but got " + a.length);
}
return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6], (T8)a[7]);
}
}
static final class Array9Func implements Function {
final Function9 f;
Array9Func(Function9 f) {
this.f = f;
}
@SuppressWarnings("unchecked")
@Override
public R apply(Object[] a) throws Throwable {
if (a.length != 9) {
throw new IllegalArgumentException("Array of size 9 expected but got " + a.length);
}
return f.apply((T1)a[0], (T2)a[1], (T3)a[2], (T4)a[3], (T5)a[4], (T6)a[5], (T7)a[6], (T8)a[7], (T9)a[8]);
}
}
static final class Identity implements Function {
@Override
public Object apply(Object v) {
return v;
}
@Override
public String toString() {
return "IdentityFunction";
}
}
static final class EmptyRunnable implements Runnable {
@Override
public void run() { }
@Override
public String toString() {
return "EmptyRunnable";
}
}
static final class EmptyAction implements Action {
@Override
public void run() { }
@Override
public String toString() {
return "EmptyAction";
}
}
static final class EmptyConsumer implements Consumer {
@Override
public void accept(Object v) { }
@Override
public String toString() {
return "EmptyConsumer";
}
}
static final class ErrorConsumer implements Consumer {
@Override
public void accept(Throwable error) {
RxJavaPlugins.onError(error);
}
}
static final class OnErrorMissingConsumer implements Consumer {
@Override
public void accept(Throwable error) {
RxJavaPlugins.onError(new OnErrorNotImplementedException(error));
}
}
static final class EmptyLongConsumer implements LongConsumer {
@Override
public void accept(long v) { }
}
static final class TruePredicate implements Predicate {
@Override
public boolean test(Object o) {
return true;
}
}
static final class FalsePredicate implements Predicate {
@Override
public boolean test(Object o) {
return false;
}
}
static final class NullProvider implements Supplier {
@Override
public Object get() {
return null;
}
}
static final class MaxRequestSubscription implements Consumer {
@Override
public void accept(Subscription t) {
t.request(Long.MAX_VALUE);
}
}
@SuppressWarnings("unchecked")
public static Consumer boundedConsumer(int bufferSize) {
return (Consumer) new BoundedConsumer(bufferSize);
}
public static class BoundedConsumer implements Consumer {
final int bufferSize;
BoundedConsumer(int bufferSize) {
this.bufferSize = bufferSize;
}
@Override
public void accept(Subscription s) {
s.request(bufferSize);
}
}
}