Package org.apache.calcite.linq4j.function

Class Functions

  • public abstract class Functions
extends java.lang.Object
    Utilities relating to functions.

    • Field Detail

      • FUNCTION_RESULT_TYPES

        public static final java.util.Map<java.lang.Class<? extends Function>,​java.lang.Class> FUNCTION_RESULT_TYPES

      • FUNCTION1_CLASSES

        private static final java.util.Map<java.lang.Class,​java.lang.Class<? extends Function>> FUNCTION1_CLASSES

      • NULLS_FIRST_COMPARATOR

        private static final java.util.Comparator NULLS_FIRST_COMPARATOR

      • NULLS_LAST_COMPARATOR

        private static final java.util.Comparator NULLS_LAST_COMPARATOR

      • NULLS_LAST_REVERSE_COMPARATOR

        private static final java.util.Comparator NULLS_LAST_REVERSE_COMPARATOR

      • NULLS_FIRST_REVERSE_COMPARATOR

        private static final java.util.Comparator NULLS_FIRST_REVERSE_COMPARATOR

      • IDENTITY_COMPARER

        private static final EqualityComparer<java.lang.Object> IDENTITY_COMPARER

      • ARRAY_COMPARER

        private static final EqualityComparer<java.lang.Object[]> ARRAY_COMPARER

      • CONSTANT_NULL_FUNCTION1

        private static final Function1 CONSTANT_NULL_FUNCTION1

      • TO_STRING_FUNCTION1

        private static final Function1 TO_STRING_FUNCTION1

    • Constructor Detail

      • Functions

        private Functions()

    • Method Detail

      • map

        private static <K,​V> java.util.Map<K,​V> map​(K k,
                                                        V v,
                                                        java.lang.Object... rest)

      • inverse

        private static <K,​V> java.util.Map<V,​K> inverse​(java.util.Map<K,​V> map)

      • constant

        public static <T,​R> Function1<T,​R> constant​(R r)
        Returns a 1-parameter function that always returns the same value.

      • constantNull

        public static <T,​R> Function1<T,​R> constantNull()
        Returns a 1-parameter function that always returns null.

      • truePredicate1

        public static <T> Predicate1<T> truePredicate1()
        A predicate with one parameter that always returns true.
        Type Parameters:
        T - First parameter type
        Returns:
        Predicate that always returns true

      • falsePredicate1

        public static <T> Predicate1<T> falsePredicate1()
        A predicate with one parameter that always returns true.
        Type Parameters:
        T - First parameter type
        Returns:
        Predicate that always returns true

      • truePredicate2

        public static <T1,​T2> Predicate2<T1,​T2> truePredicate2()
        A predicate with two parameters that always returns true.
        Type Parameters:
        T1 - First parameter type
        T2 - Second parameter type
        Returns:
        Predicate that always returns true

      • falsePredicate2

        public static <T1,​T2> Predicate2<T1,​T2> falsePredicate2()
        A predicate with two parameters that always returns false.
        Type Parameters:
        T1 - First parameter type
        T2 - Second parameter type
        Returns:
        Predicate that always returns false

      • identitySelector

        public static <TSource> Function1<TSource,​TSource> identitySelector()

      • toStringSelector

        public static <TSource> Function1<TSource,​java.lang.String> toStringSelector()
        Returns a selector that calls the Object.toString() method on each element.

      • ofTypePredicate

        public static <T,​T2> Predicate1<T> ofTypePredicate​(java.lang.Class<T2> clazz)
        Creates a predicate that returns whether an object is an instance of a particular type or is null.
        Type Parameters:
        T - Type of objects to test
        T2 - Desired type
        Parameters:
        clazz - Desired type
        Returns:
        Predicate that tests for desired type

      • toPredicate

        public static <T1,​T2> Predicate2<T1,​T2> toPredicate​(Function2<T1,​T2,​java.lang.Boolean> function)
        Converts a 2-parameter function to a predicate.

      • toPredicate

        private static <T> Predicate1<T> toPredicate​(Function1<T,​java.lang.Boolean> function)
        Converts a 1-parameter function to a predicate.

      • functionClass

        public static java.lang.Class<? extends Function> functionClass​(java.lang.reflect.Type aClass)
        Returns the appropriate interface for a lambda function with 1 argument and the given return type.

        For example:

        functionClass(Integer.TYPE) returns IntegerFunction1.class functionClass(String.class) returns Function1.class
        Parameters:
        aClass - Return type
        Returns:
        Function class

      • adapt

        @Deprecated
public static <T1,​R> java.util.List<R> adapt​(java.util.List<T1> list,
                                                   Function1<T1,​R> f)
        Deprecated.
        Use Lists.transform(java.util.List<F>, com.google.common.base.Function<? super F, ? extends T>)
        Creates a view of a list that applies a function to each element.

      • adapt

        @Deprecated
public static <T,​R> java.util.List<R> adapt​(T[] ts,
                                                  Function1<T,​R> f)
        Deprecated.
        Use Lists.transform(java.util.List<F>, com.google.common.base.Function<? super F, ? extends T>) and Arrays.asList(Object[])
        Creates a view of an array that applies a function to each element.

      • apply

        public static <T1,​R> java.util.List<R> apply​(java.util.List<T1> list,
                                                   Function1<T1,​R> f)
        Creates a copy of a list, applying a function to each element.

      • filter

        public static <E> java.util.List<E> filter​(java.util.List<E> list,
                                           Predicate1<E> predicate)
        Returns a list that contains only elements of list that match predicate. Avoids allocating a list if all elements match or no elements match.

      • exists

        public static <E> boolean exists​(java.util.List<? extends E> list,
                                 Predicate1<E> predicate)
        Returns whether there is an element in list for which predicate is true.

      • all

        public static <E> boolean all​(java.util.List<? extends E> list,
                              Predicate1<E> predicate)
        Returns whether predicate is true for all elements of list.

      • generate

        public static <E> java.util.List<E> generate​(int size,
                                             Function1<java.lang.Integer,​E> fn)
        Returns a list generated by applying a function to each index between 0 and size - 1.

      • ignore0

        public static <R> Function0<R> ignore0()
        Returns a function of arity 0 that does nothing.
        Type Parameters:
        R - Return type
        Returns:
        Function that does nothing.

      • ignore1

        public static <R,​T0> Function1<R,​T0> ignore1()
        Returns a function of arity 1 that does nothing.
        Type Parameters:
        R - Return type
        T0 - Type of parameter 0
        Returns:
        Function that does nothing.

      • ignore2

        public static <R,​T0,​T1> Function2<R,​T0,​T1> ignore2()
        Returns a function of arity 2 that does nothing.
        Type Parameters:
        R - Return type
        T0 - Type of parameter 0
        T1 - Type of parameter 1
        Returns:
        Function that does nothing.

      • nullsComparator

        public static <T extends java.lang.Comparable<T>> java.util.Comparator<T> nullsComparator​(boolean nullsFirst,
                                                                                          boolean reverse)
        Returns a Comparator that handles null values.
        Parameters:
        nullsFirst - Whether nulls come before all other values
        reverse - Whether to reverse the usual order of Comparables