All Downloads are FREE. Search and download functionalities are using the official Maven repository.

org.apache.calcite.linq4j.ExtendedEnumerable Maven / Gradle / Ivy

There is a newer version: 1.38.0
Show newest version
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you 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 org.apache.calcite.linq4j;

import org.apache.calcite.linq4j.function.BigDecimalFunction1;
import org.apache.calcite.linq4j.function.DoubleFunction1;
import org.apache.calcite.linq4j.function.EqualityComparer;
import org.apache.calcite.linq4j.function.FloatFunction1;
import org.apache.calcite.linq4j.function.Function0;
import org.apache.calcite.linq4j.function.Function1;
import org.apache.calcite.linq4j.function.Function2;
import org.apache.calcite.linq4j.function.IntegerFunction1;
import org.apache.calcite.linq4j.function.LongFunction1;
import org.apache.calcite.linq4j.function.NullableBigDecimalFunction1;
import org.apache.calcite.linq4j.function.NullableDoubleFunction1;
import org.apache.calcite.linq4j.function.NullableFloatFunction1;
import org.apache.calcite.linq4j.function.NullableIntegerFunction1;
import org.apache.calcite.linq4j.function.NullableLongFunction1;
import org.apache.calcite.linq4j.function.Predicate1;
import org.apache.calcite.linq4j.function.Predicate2;

import java.math.BigDecimal;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;

/**
 * Extension methods in {@link Enumerable}.
 *
 * @param  Element type
 */
public interface ExtendedEnumerable {

  /**
   * Performs an operation for each member of this enumeration.
   *
   * 

Returns the value returned by the function for the last element in * this enumeration, or null if this enumeration is empty.

* * @param func Operation * @param Return type */ R foreach(Function1 func); /** * Applies an accumulator function over a * sequence. */ TSource aggregate(Function2 func); /** * Applies an accumulator function over a * sequence. The specified seed value is used as the initial * accumulator value. */ TAccumulate aggregate(TAccumulate seed, Function2 func); /** * Applies an accumulator function over a * sequence. The specified seed value is used as the initial * accumulator value, and the specified function is used to select * the result value. */ TResult aggregate(TAccumulate seed, Function2 func, Function1 selector); /** * Determines whether all elements of a sequence * satisfy a condition. */ boolean all(Predicate1 predicate); /** * Determines whether a sequence contains any * elements. (Defined by Enumerable.) */ boolean any(); /** * Determines whether any element of a sequence * satisfies a condition. */ boolean any(Predicate1 predicate); /** * Returns the input typed as {@code Enumerable}. * *

This method has no effect * other than to change the compile-time type of source from a type that * implements {@code Enumerable} to {@code Enumerable} * itself. * *

{@code asEnumerable(Enumerable)} can be used to choose * between query implementations when a sequence implements * {@code Enumerable} but also has a different set of public query * methods available. For example, given a generic class Table that implements * {@code Enumerable} and has its own methods such as {@code where}, * {@code select}, and {@code selectMany}, a call to {@code where} would * invoke the public {@code where} method of {@code Table}. A {@code Table} * type that represents a database table could have a {@code where} method * that takes the predicate argument as an expression tree and converts the * tree to SQL for remote execution. If remote execution is not desired, for * example because the predicate invokes a local method, the * {@code asEnumerable} method can be used to hide the custom methods * and instead make the standard query operators available. */ Enumerable asEnumerable(); /** * Converts an Enumerable to a {@link Queryable}. * *

If the type of source implements {@code Queryable}, this method * returns it directly. Otherwise, it returns a {@code Queryable} that * executes queries by calling the equivalent query operator methods in * {@code Enumerable} instead of those in {@code Queryable}.

* *

Analogous to the LINQ's Enumerable.AsQueryable extension method.

* * @return A queryable */ Queryable asQueryable(); /** * Computes the average of a sequence of Decimal * values that are obtained by invoking a transform function on * each element of the input sequence. */ BigDecimal average(BigDecimalFunction1 selector); /** * Computes the average of a sequence of nullable * Decimal values that are obtained by invoking a transform * function on each element of the input sequence. */ BigDecimal average(NullableBigDecimalFunction1 selector); /** * Computes the average of a sequence of Double * values that are obtained by invoking a transform function on * each element of the input sequence. */ double average(DoubleFunction1 selector); /** * Computes the average of a sequence of nullable * Double values that are obtained by invoking a transform * function on each element of the input sequence. */ Double average(NullableDoubleFunction1 selector); /** * Computes the average of a sequence of int values * that are obtained by invoking a transform function on each * element of the input sequence. */ int average(IntegerFunction1 selector); /** * Computes the average of a sequence of nullable * int values that are obtained by invoking a transform function * on each element of the input sequence. */ Integer average(NullableIntegerFunction1 selector); /** * Computes the average of a sequence of long values * that are obtained by invoking a transform function on each * element of the input sequence. */ long average(LongFunction1 selector); /** * Computes the average of a sequence of nullable * long values that are obtained by invoking a transform function * on each element of the input sequence. */ Long average(NullableLongFunction1 selector); /** * Computes the average of a sequence of Float * values that are obtained by invoking a transform function on * each element of the input sequence. */ float average(FloatFunction1 selector); /** * Computes the average of a sequence of nullable * Float values that are obtained by invoking a transform * function on each element of the input sequence. */ Float average(NullableFloatFunction1 selector); /** * Converts the elements of this Enumerable to the specified type. * *

This method is implemented by using deferred execution. The immediate * return value is an object that stores all the information that is * required to perform the action. The query represented by this method is * not executed until the object is enumerated either by calling its * {@link Enumerable#enumerator} method directly or by using * {@code for (... in ...)}. * *

If an element cannot be cast to type TResult, the * {@link Enumerator#current()} method will throw a * {@link ClassCastException} a exception when the element it accessed. To * obtain only those elements that can be cast to type TResult, use the * {@link #ofType(Class)} method instead. * * @see EnumerableDefaults#cast * @see #ofType(Class) */ Enumerable cast(Class clazz); /** * Concatenates two sequences. */ Enumerable concat(Enumerable enumerable1); /** * Determines whether a sequence contains a specified * element by using the default equality comparer. */ boolean contains(TSource element); /** * Determines whether a sequence contains a specified * element by using a specified {@code EqualityComparer}. */ boolean contains(TSource element, EqualityComparer comparer); /** * Returns the number of elements in a * sequence. */ int count(); /** * Returns a number that represents how many elements * in the specified sequence satisfy a condition. */ int count(Predicate1 predicate); /** * Returns the elements of the specified sequence or * the type parameter's default value in a singleton collection if * the sequence is empty. */ Enumerable defaultIfEmpty(); /** * Returns the elements of the specified sequence or * the specified value in a singleton collection if the sequence * is empty. */ Enumerable defaultIfEmpty(TSource value); /** * Returns distinct elements from a sequence by using * the default equality comparer to compare values. */ Enumerable distinct(); /** * Returns distinct elements from a sequence by using * a specified {@code EqualityComparer} to compare values. */ Enumerable distinct(EqualityComparer comparer); /** * Returns the element at a specified index in a * sequence. */ TSource elementAt(int index); /** * Returns the element at a specified index in a * sequence or a default value if the index is out of * range. */ TSource elementAtOrDefault(int index); /** * Produces the set difference of two sequences by * using the default equality comparer to compare values, * eliminate duplicates. (Defined by Enumerable.) */ Enumerable except(Enumerable enumerable1); /** * Produces the set difference of two sequences by * using the default equality comparer to compare values, * using {@code all} to indicate whether to eliminate duplicates. * (Defined by Enumerable.) */ Enumerable except(Enumerable enumerable1, boolean all); /** * Produces the set difference of two sequences by * using the specified {@code EqualityComparer} to compare * values, eliminate duplicates. */ Enumerable except(Enumerable enumerable1, EqualityComparer comparer); /** * Produces the set difference of two sequences by * using the specified {@code EqualityComparer} to compare * values, using {@code all} to indicate whether to eliminate duplicates. */ Enumerable except(Enumerable enumerable1, EqualityComparer comparer, boolean all); /** * Returns the first element of a sequence. (Defined * by Enumerable.) */ TSource first(); /** * Returns the first element in a sequence that * satisfies a specified condition. */ TSource first(Predicate1 predicate); /** * Returns the first element of a sequence, or a * default value if the sequence contains no elements. */ TSource firstOrDefault(); /** * Returns the first element of the sequence that * satisfies a condition or a default value if no such element is * found. */ TSource firstOrDefault(Predicate1 predicate); /** * Groups the elements of a sequence according to a * specified key selector function. */ Enumerable> groupBy( Function1 keySelector); /** * Groups the elements of a sequence according to a * specified key selector function and compares the keys by using * a specified comparer. */ Enumerable> groupBy( Function1 keySelector, EqualityComparer comparer); /** * Groups the elements of a sequence according to a * specified key selector function and projects the elements for * each group by using a specified function. */ Enumerable> groupBy( Function1 keySelector, Function1 elementSelector); /** * Groups the elements of a sequence according to a * key selector function. The keys are compared by using a * comparer and each group's elements are projected by using a * specified function. */ Enumerable> groupBy( Function1 keySelector, Function1 elementSelector, EqualityComparer comparer); /** * Groups the elements of a sequence according to a * specified key selector function and creates a result value from * each group and its key. */ Enumerable groupBy( Function1 keySelector, Function2, TResult> resultSelector); /** * Groups the elements of a sequence according to a * specified key selector function and creates a result value from * each group and its key. The keys are compared by using a * specified comparer. */ Enumerable groupBy( Function1 keySelector, Function2, TResult> resultSelector, EqualityComparer comparer); /** * Groups the elements of a sequence according to a * specified key selector function and creates a result value from * each group and its key. The elements of each group are * projected by using a specified function. */ Enumerable groupBy( Function1 keySelector, Function1 elementSelector, Function2, TResult> resultSelector); /** * Groups the elements of a sequence according to a * specified key selector function and creates a result value from * each group and its key. Key values are compared by using a * specified comparer, and the elements of each group are * projected by using a specified function. */ Enumerable groupBy( Function1 keySelector, Function1 elementSelector, Function2, TResult> resultSelector, EqualityComparer comparer); /** * Groups the elements of a sequence according to a * specified key selector function, initializing an accumulator for each * group and adding to it each time an element with the same key is seen. * Creates a result value from each accumulator and its key using a * specified function. */ Enumerable groupBy( Function1 keySelector, Function0 accumulatorInitializer, Function2 accumulatorAdder, Function2 resultSelector); /** * Groups the elements of a sequence according to a * specified key selector function, initializing an accumulator for each * group and adding to it each time an element with the same key is seen. * Creates a result value from each accumulator and its key using a * specified function. Key values are compared by using a * specified comparer. */ Enumerable groupBy( Function1 keySelector, Function0 accumulatorInitializer, Function2 accumulatorAdder, Function2 resultSelector, EqualityComparer comparer); /** * Correlates the elements of two sequences based on * equality of keys and groups the results. The default equality * comparer is used to compare keys. */ Enumerable groupJoin( Enumerable inner, Function1 outerKeySelector, Function1 innerKeySelector, Function2, TResult> resultSelector); /** * Correlates the elements of two sequences based on * key equality and groups the results. A specified * {@code EqualityComparer} is used to compare keys. */ Enumerable groupJoin( Enumerable inner, Function1 outerKeySelector, Function1 innerKeySelector, Function2, TResult> resultSelector, EqualityComparer comparer); /** * Produces the set intersection of two sequences by * using the default equality comparer to compare values, * eliminate duplicates. (Defined by Enumerable.) */ Enumerable intersect(Enumerable enumerable1); /** * Produces the set intersection of two sequences by * using the default equality comparer to compare values, * using {@code all} to indicate whether to eliminate duplicates. * (Defined by Enumerable.) */ Enumerable intersect(Enumerable enumerable1, boolean all); /** * Produces the set intersection of two sequences by * using the specified {@code EqualityComparer} to compare * values, eliminate duplicates. */ Enumerable intersect(Enumerable enumerable1, EqualityComparer comparer); /** * Produces the set intersection of two sequences by * using the specified {@code EqualityComparer} to compare * values, using {@code all} to indicate whether to eliminate duplicates. */ Enumerable intersect(Enumerable enumerable1, EqualityComparer comparer, boolean all); /** * Copies the contents of this sequence into a collection. */ > C into(C sink); /** * Removes the contents of this sequence from a collection. */ > C removeAll(C sink); /** * Correlates the elements of two sequences based on * matching keys. The default equality comparer is used to compare * keys. */ Enumerable hashJoin(Enumerable inner, Function1 outerKeySelector, Function1 innerKeySelector, Function2 resultSelector); /** * Correlates the elements of two sequences based on * matching keys. A specified {@code EqualityComparer} is used to * compare keys. */ Enumerable hashJoin(Enumerable inner, Function1 outerKeySelector, Function1 innerKeySelector, Function2 resultSelector, EqualityComparer comparer); /** * Correlates the elements of two sequences based on matching keys, with * optional outer join semantics. A specified * {@code EqualityComparer} is used to compare keys. * *

A left join generates nulls on right, and vice versa:

* * * * * * * * * * * * *
Join types
Join typegenerateNullsOnLeftgenerateNullsOnRight
INNERfalsefalse
LEFTfalsetrue
RIGHTtruefalse
FULLtruetrue
*/ Enumerable hashJoin(Enumerable inner, Function1 outerKeySelector, Function1 innerKeySelector, Function2 resultSelector, EqualityComparer comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight); /** * Correlates the elements of two sequences based on matching keys, with * optional outer join semantics. A specified * {@code EqualityComparer} is used to compare keys. * *

A left join generates nulls on right, and vice versa:

* * * * * * * * * * * * *
Join types
Join typegenerateNullsOnLeftgenerateNullsOnRight
INNERfalsefalse
LEFTfalsetrue
RIGHTtruefalse
FULLtruetrue
* *

A predicate is used to filter the join result per-row

*/ Enumerable hashJoin(Enumerable inner, Function1 outerKeySelector, Function1 innerKeySelector, Function2 resultSelector, EqualityComparer comparer, boolean generateNullsOnLeft, boolean generateNullsOnRight, Predicate2 predicate); /** * For each row of the current enumerable returns the correlated rows * from the {@code inner} enumerable (nested loops join). * * @param joinType inner, left, semi or anti join type * @param inner generator of inner enumerable * @param resultSelector selector of the result. For semi/anti join * inner argument is always null. */ Enumerable correlateJoin( JoinType joinType, Function1> inner, Function2 resultSelector); /** * Returns the last element of a sequence. (Defined * by Enumerable.) */ TSource last(); /** * Returns the last element of a sequence that * satisfies a specified condition. */ TSource last(Predicate1 predicate); /** * Returns the last element of a sequence, or a * default value if the sequence contains no elements. */ TSource lastOrDefault(); /** * Returns the last element of a sequence that * satisfies a condition or a default value if no such element is * found. */ TSource lastOrDefault(Predicate1 predicate); /** * Returns an long that represents the total number * of elements in a sequence. */ long longCount(); /** * Returns an long that represents how many elements * in a sequence satisfy a condition. */ long longCount(Predicate1 predicate); /** * Returns the maximum value in a generic * sequence. */ TSource max(); /** * Invokes a transform function on each element of a * sequence and returns the maximum Decimal value. */ BigDecimal max(BigDecimalFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum nullable Decimal * value. */ BigDecimal max(NullableBigDecimalFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum Double value. */ double max(DoubleFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum nullable Double * value. */ Double max(NullableDoubleFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum int value. */ int max(IntegerFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum nullable int value. (Defined * by Enumerable.) */ Integer max(NullableIntegerFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum long value. */ long max(LongFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum nullable long value. (Defined * by Enumerable.) */ Long max(NullableLongFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum Float value. */ float max(FloatFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the maximum nullable Float * value. */ Float max(NullableFloatFunction1 selector); /** * Invokes a transform function on each element of a * generic sequence and returns the maximum resulting * value. */ > TResult max( Function1 selector); /** * Returns the minimum value in a generic * sequence. */ TSource min(); /** * Invokes a transform function on each element of a * sequence and returns the minimum Decimal value. */ BigDecimal min(BigDecimalFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum nullable Decimal * value. */ BigDecimal min(NullableBigDecimalFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum Double value. */ double min(DoubleFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum nullable Double * value. */ Double min(NullableDoubleFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum int value. */ int min(IntegerFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum nullable int value. (Defined * by Enumerable.) */ Integer min(NullableIntegerFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum long value. */ long min(LongFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum nullable long value. (Defined * by Enumerable.) */ Long min(NullableLongFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum Float value. */ float min(FloatFunction1 selector); /** * Invokes a transform function on each element of a * sequence and returns the minimum nullable Float * value. */ Float min(NullableFloatFunction1 selector); /** * Invokes a transform function on each element of a * generic sequence and returns the minimum resulting * value. */ > TResult min( Function1 selector); /** * Filters the elements of an Enumerable based on a * specified type. * *

Analogous to LINQ's Enumerable.OfType extension method.

* * @param clazz Target type * @param Target type * * @return Collection of T2 */ Enumerable ofType(Class clazz); /** * Sorts the elements of a sequence in ascending * order according to a key. */ Enumerable orderBy( Function1 keySelector); /** * Sorts the elements of a sequence in ascending * order by using a specified comparer. */ Enumerable orderBy(Function1 keySelector, Comparator comparator); /** * Sorts the elements of a sequence in descending * order according to a key. */ Enumerable orderByDescending( Function1 keySelector); /** * Sorts the elements of a sequence in descending * order by using a specified comparer. */ Enumerable orderByDescending( Function1 keySelector, Comparator comparator); /** * Inverts the order of the elements in a * sequence. */ Enumerable reverse(); /** * Projects each element of a sequence into a new * form. */ Enumerable select(Function1 selector); /** * Projects each element of a sequence into a new * form by incorporating the element's index. */ Enumerable select( Function2 selector); /** * Projects each element of a sequence to an * {@code Enumerable} and flattens the resulting sequences into one * sequence. */ Enumerable selectMany( Function1> selector); /** * Projects each element of a sequence to an * {@code Enumerable}, and flattens the resulting sequences into one * sequence. The index of each source element is used in the * projected form of that element. */ Enumerable selectMany( Function2> selector); /** * Projects each element of a sequence to an * {@code Enumerable}, flattens the resulting sequences into one * sequence, and invokes a result selector function on each * element therein. The index of each source element is used in * the intermediate projected form of that element. */ Enumerable selectMany( Function2> collectionSelector, Function2 resultSelector); /** * Projects each element of a sequence to an * {@code Enumerable}, flattens the resulting sequences into one * sequence, and invokes a result selector function on each * element therein. */ Enumerable selectMany( Function1> collectionSelector, Function2 resultSelector); /** * Determines whether two sequences are equal by * comparing the elements by using the default equality comparer * for their type. */ boolean sequenceEqual(Enumerable enumerable1); /** * Determines whether two sequences are equal by * comparing their elements by using a specified * {@code EqualityComparer}. */ boolean sequenceEqual(Enumerable enumerable1, EqualityComparer comparer); /** * Returns the only element of a sequence, and throws * an exception if there is not exactly one element in the * sequence. */ TSource single(); /** * Returns the only element of a sequence that * satisfies a specified condition, and throws an exception if * more than one such element exists. */ TSource single(Predicate1 predicate); /** * Returns the only element of a sequence, or a * default value if the sequence is empty; this method throws an * exception if there is more than one element in the * sequence. */ TSource singleOrDefault(); /** * Returns the only element of a sequence that * satisfies a specified condition or a default value if no such * element exists; this method throws an exception if more than * one element satisfies the condition. */ TSource singleOrDefault(Predicate1 predicate); /** * Bypasses a specified number of elements in a * sequence and then returns the remaining elements. */ Enumerable skip(int count); /** * Bypasses elements in a sequence as long as a * specified condition is true and then returns the remaining * elements. */ Enumerable skipWhile(Predicate1 predicate); /** * Bypasses elements in a sequence as long as a * specified condition is true and then returns the remaining * elements. The element's index is used in the logic of the * predicate function. */ Enumerable skipWhile(Predicate2 predicate); /** * Computes the sum of the sequence of Decimal values * that are obtained by invoking a transform function on each * element of the input sequence. */ BigDecimal sum(BigDecimalFunction1 selector); /** * Computes the sum of the sequence of nullable * Decimal values that are obtained by invoking a transform * function on each element of the input sequence. */ BigDecimal sum(NullableBigDecimalFunction1 selector); /** * Computes the sum of the sequence of Double values * that are obtained by invoking a transform function on each * element of the input sequence. */ double sum(DoubleFunction1 selector); /** * Computes the sum of the sequence of nullable * Double values that are obtained by invoking a transform * function on each element of the input sequence. */ Double sum(NullableDoubleFunction1 selector); /** * Computes the sum of the sequence of int values * that are obtained by invoking a transform function on each * element of the input sequence. */ int sum(IntegerFunction1 selector); /** * Computes the sum of the sequence of nullable int * values that are obtained by invoking a transform function on * each element of the input sequence. */ Integer sum(NullableIntegerFunction1 selector); /** * Computes the sum of the sequence of long values * that are obtained by invoking a transform function on each * element of the input sequence. */ long sum(LongFunction1 selector); /** * Computes the sum of the sequence of nullable long * values that are obtained by invoking a transform function on * each element of the input sequence. */ Long sum(NullableLongFunction1 selector); /** * Computes the sum of the sequence of Float values * that are obtained by invoking a transform function on each * element of the input sequence. */ float sum(FloatFunction1 selector); /** * Computes the sum of the sequence of nullable * Float values that are obtained by invoking a transform * function on each element of the input sequence. */ Float sum(NullableFloatFunction1 selector); /** * Returns a specified number of contiguous elements * from the start of a sequence. */ Enumerable take(int count); /** * Returns elements from a sequence as long as a * specified condition is true. */ Enumerable takeWhile(Predicate1 predicate); /** * Returns elements from a sequence as long as a * specified condition is true. The element's index is used in the * logic of the predicate function. */ Enumerable takeWhile(Predicate2 predicate); /** * Creates a {@code Map} from an * {@code Enumerable} according to a specified key selector * function. * *

NOTE: Called {@code toDictionary} in LINQ.NET.

*/ Map toMap(Function1 keySelector); /** * Creates a {@code Map} from an * {@code Enumerable} according to a specified key selector function * and key comparer. */ Map toMap(Function1 keySelector, EqualityComparer comparer); /** * Creates a {@code Map} from an * {@code Enumerable} according to specified key selector and element * selector functions. */ Map toMap( Function1 keySelector, Function1 elementSelector); /** * Creates a {@code Map} from an * {@code Enumerable} according to a specified key selector function, * a comparer, and an element selector function. */ Map toMap( Function1 keySelector, Function1 elementSelector, EqualityComparer comparer); /** * Creates a {@code List} from an {@code Enumerable}. */ List toList(); /** * Creates a {@code Lookup} from an * {@code Enumerable} according to a specified key selector * function. */ Lookup toLookup(Function1 keySelector); /** * Creates a {@code Lookup} from an * {@code Enumerable} according to a specified key selector function * and key comparer. */ Lookup toLookup(Function1 keySelector, EqualityComparer comparer); /** * Creates a {@code Lookup} from an * {@code Enumerable} according to specified key selector and element * selector functions. */ Lookup toLookup( Function1 keySelector, Function1 elementSelector); /** * Creates a {@code Lookup} from an * {@code Enumerable} according to a specified key selector function, * a comparer and an element selector function. */ Lookup toLookup( Function1 keySelector, Function1 elementSelector, EqualityComparer comparer); /** * Produces the set union of two sequences by using * the default equality comparer. */ Enumerable union(Enumerable source1); /** * Produces the set union of two sequences by using a * specified {@code EqualityComparer}. */ Enumerable union(Enumerable source1, EqualityComparer comparer); /** * Filters a sequence of values based on a * predicate. */ Enumerable where(Predicate1 predicate); /** * Filters a sequence of values based on a * predicate. Each element's index is used in the logic of the * predicate function. */ Enumerable where(Predicate2 predicate); /** * Applies a specified function to the corresponding * elements of two sequences, producing a sequence of the * results. */ Enumerable zip(Enumerable source1, Function2 resultSelector); }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy