| Package | Description |
|---|---|
| org.apache.calcite.linq4j |
Language-integrated query for Java (linq4j) main package.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
ExtendedOrderedEnumerable<T>
Extension methods for
OrderedEnumerable. |
interface |
ExtendedOrderedQueryable<T>
Extension methods for
OrderedQueryable. |
interface |
Grouping<K,V>
Represents a collection of objects that have a common key.
|
interface |
Lookup<K,V>
Represents a collection of keys each mapped to one or more values.
|
interface |
OrderedEnumerable<T>
Represents the result of applying a sorting operation to an
Enumerable. |
interface |
OrderedQueryable<T>
Represents the result of applying a sorting operation to a
Queryable. |
interface |
Queryable<T>
Provides functionality to evaluate queries against a specific data source
wherein the type of the data is known.
|
static interface |
QueryableDefaults.Replayable<T>
Replayable.
|
interface |
RawQueryable<T>
Core methods that define a
Queryable. |
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractEnumerable<T>
Abstract implementation of the
Enumerable interface that
implements the extension methods. |
class |
AbstractEnumerable2<T>
Abstract implementation of the
Enumerable
interface that implements the extension methods. |
class |
AbstractQueryable<T>
Abstract implementation of the
Queryable interface that implements
the extension methods. |
class |
BaseQueryable<TSource>
Skeleton implementation of
Queryable. |
class |
DefaultEnumerable<T>
Implementation of the
Enumerable interface
that implements the extension methods by calling into the Extensions
class. |
(package private) class |
DefaultQueryable<T>
Implementation of the
Queryable interface that
implements the extension methods by calling into the Extensions
class. |
private static class |
EnumerableDefaults.LookupResultEnumerable<TResult,TKey,TAccumulate>
Reads a populated map, applying a selector function.
|
(package private) class |
EnumerableOrderedQueryable<T>
Implementation of
OrderedQueryable by an
Enumerable. |
(package private) class |
EnumerableQueryable<T>
Implementation of
Queryable by a Enumerable. |
(package private) class |
GroupingImpl<K,V>
Implementation of
Grouping. |
(package private) static class |
Linq4j.CollectionEnumerable<T>
Collection enumerable.
|
(package private) static class |
Linq4j.CompositeEnumerable<E>
Composite enumerable.
|
(package private) static class |
Linq4j.IterableEnumerable<T>
Iterable enumerable.
|
(package private) static class |
Linq4j.ListEnumerable<T>
List enumerable.
|
(package private) class |
LookupImpl<K,V>
Implementation of
Lookup that uses an underlying map. |
class |
MemoryEnumerable<E>
Enumerable that has a (limited) memory for n past and m future steps.
|
static class |
QueryableDefaults.NonLeafReplayableQueryable<T>
Non-leaf replayable queryable.
|
static class |
QueryableDefaults.ReplayableQueryable<T>
Replayable queryable.
|
static class |
QueryProviderImpl.QueryableImpl<T>
Binds an expression to this query provider.
|
| Modifier and Type | Field and Description |
|---|---|
static Enumerable<?> |
Linq4j.EMPTY_ENUMERABLE |
private Enumerable<T> |
EnumerableQueryable.enumerable |
private Enumerable<E> |
MemoryEnumerable.input |
| Modifier and Type | Field and Description |
|---|---|
private Enumerator<Enumerable<E>> |
Linq4j.CompositeEnumerable.enumerableEnumerator |
| Modifier and Type | Method and Description |
|---|---|
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector)
Returns elements of
outer for which there is NOT a member of
inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
Predicate2<TSource,TInner> nonEquiPredicate) |
<TResult> Enumerable<TResult> |
Lookup.applyResultSelector(Function2<K,Enumerable<V>,TResult> resultSelector)
Applies a transform function to each key and its associated values and
returns the results.
|
<TResult> Enumerable<TResult> |
LookupImpl.applyResultSelector(Function2<K,Enumerable<V>,TResult> resultSelector) |
Enumerable<T> |
DefaultQueryable.asEnumerable() |
Enumerable<TSource> |
ExtendedEnumerable.asEnumerable()
Returns the input typed as
Enumerable<TSource>. |
Enumerable<T> |
DefaultEnumerable.asEnumerable() |
static <T> Enumerable<T> |
Linq4j.asEnumerable(Collection<T> collection)
Adapter that converts an
Collection into an Enumerable. |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.asEnumerable(Enumerable<TSource> enumerable)
Returns the input typed as
Enumerable<TSource>. |
static <T> Enumerable<T> |
Linq4j.asEnumerable(Iterable<T> iterable)
Adapter that converts an
Iterable into an Enumerable. |
static <T> Enumerable<T> |
Linq4j.asEnumerable(List<T> list)
Adapter that converts an
List into an Enumerable. |
static <T> Enumerable<T> |
Linq4j.asEnumerable(T[] ts)
Adapter that converts an array into an enumerable.
|
<T2> Enumerable<T2> |
ExtendedEnumerable.cast(Class<T2> clazz)
Converts the elements of this Enumerable to the specified type.
|
<T2> Enumerable<T2> |
DefaultEnumerable.cast(Class<T2> clazz) |
static <TSource,T2> |
EnumerableDefaults.cast(Enumerable<TSource> source,
Class<T2> clazz)
Analogous to LINQ's Enumerable.Cast extension method.
|
static <TSource,TResult> |
Linq4j.cast(Iterable<TSource> source,
Class<TResult> clazz)
Converts the elements of a given Iterable to the specified type.
|
Enumerable<T> |
DefaultEnumerable.concat(Enumerable<T> enumerable1) |
Enumerable<TSource> |
ExtendedEnumerable.concat(Enumerable<TSource> enumerable1)
Concatenates two sequences.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.concat(Enumerable<TSource> enumerable0,
Enumerable<TSource> enumerable1)
Concatenates two sequences.
|
static <E> Enumerable<E> |
Linq4j.concat(List<Enumerable<E>> enumerableList)
Concatenates two or more
Enumerables to form a composite
enumerable that contains the union of their elements. |
static <TSource,TInner,TResult> |
EnumerableDefaults.correlateBatchJoin(JoinType joinType,
Enumerable<TSource> outer,
Function1<List<TSource>,Enumerable<TInner>> inner,
Function2<TSource,TInner,TResult> resultSelector,
Predicate2<TSource,TInner> predicate,
int batchSize)
Fetches blocks of size
batchSize from outer,
storing each block into a list (outerValues). |
static <TSource,TInner,TResult> |
EnumerableDefaults.correlateJoin(JoinType joinType,
Enumerable<TSource> outer,
Function1<TSource,Enumerable<TInner>> inner,
Function2<TSource,TInner,TResult> resultSelector)
For each row of the
outer enumerable returns the correlated rows
from the inner enumerable. |
<TInner,TResult> |
DefaultEnumerable.correlateJoin(JoinType joinType,
Function1<T,Enumerable<TInner>> inner,
Function2<T,TInner,TResult> resultSelector) |
<TInner,TResult> |
ExtendedEnumerable.correlateJoin(JoinType joinType,
Function1<TSource,Enumerable<TInner>> inner,
Function2<TSource,TInner,TResult> resultSelector)
For each row of the current enumerable returns the correlated rows
from the
inner enumerable (nested loops join). |
Enumerable<TSource> |
ExtendedEnumerable.defaultIfEmpty()
Returns the elements of the specified sequence or
the type parameter's default value in a singleton collection if
the sequence is empty.
|
Enumerable<T> |
DefaultEnumerable.defaultIfEmpty() |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.defaultIfEmpty(Enumerable<TSource> enumerable)
Returns the elements of the specified sequence or
the type parameter's default value in a singleton collection if
the sequence is empty.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.defaultIfEmpty(Enumerable<TSource> enumerable,
TSource value)
Returns the elements of the specified sequence or
the specified value in a singleton collection if the sequence
is empty.
|
Enumerable<T> |
DefaultEnumerable.defaultIfEmpty(T value) |
Enumerable<TSource> |
ExtendedEnumerable.defaultIfEmpty(TSource value)
Returns the elements of the specified sequence or
the specified value in a singleton collection if the sequence
is empty.
|
Enumerable<TSource> |
ExtendedEnumerable.distinct()
Returns distinct elements from a sequence by using
the default equality comparer to compare values.
|
Enumerable<T> |
DefaultEnumerable.distinct() |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.distinct(Enumerable<TSource> enumerable)
Returns distinct elements from a sequence by using
the default
EqualityComparer to compare values. |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.distinct(Enumerable<TSource> enumerable,
EqualityComparer<TSource> comparer)
Returns distinct elements from a sequence by using
a specified
EqualityComparer to compare values. |
Enumerable<T> |
DefaultEnumerable.distinct(EqualityComparer<T> comparer) |
Enumerable<TSource> |
ExtendedEnumerable.distinct(EqualityComparer<TSource> comparer)
Returns distinct elements from a sequence by using
a specified
EqualityComparer<TSource> to compare values. |
static <T> Enumerable<T> |
Linq4j.emptyEnumerable()
Returns an
Enumerable that has no elements. |
Enumerable<T> |
DefaultEnumerable.except(Enumerable<T> enumerable1) |
Enumerable<T> |
DefaultEnumerable.except(Enumerable<T> enumerable1,
EqualityComparer<T> comparer) |
Enumerable<TSource> |
ExtendedEnumerable.except(Enumerable<TSource> enumerable1)
Produces the set difference of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.except(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set difference of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.except(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set difference of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Enumerable<TSource> |
ExtendedEnumerable.except(Enumerable<TSource> enumerable1,
EqualityComparer<TSource> comparer)
Produces the set difference of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Enumerable<V> |
LookupImpl.get(Object key) |
protected Enumerable<T> |
DefaultEnumerable.getThis()
Derived classes might wish to override this method to return the "outer"
enumerable.
|
protected Enumerable<T> |
EnumerableQueryable.getThis() |
Enumerable<V> |
GroupingImpl.getValue() |
private static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupBy_(Map<TKey,TAccumulate> map,
Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector) |
private static <TSource,TKey,TResult> |
EnumerableDefaults.groupBy_(Set<TKey> map,
Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TKey,TResult> resultSelector) |
static <TSource,TKey> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector)
Groups the elements of a sequence according to a
specified key selector function.
|
static <TSource,TKey> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
EqualityComparer<TKey> comparer)
Groups the elements of a sequence according to a
specified key selector function and compares the keys by using
a specified comparer.
|
static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> 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.
|
static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
static <TSource,TKey,TElement> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector)
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.
|
static <TSource,TKey,TElement> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
EqualityComparer<TKey> comparer)
Groups the elements of a sequence according to a
key selector function.
|
static <TSource,TKey,TElement,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,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.
|
static <TSource,TKey,TElement,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
static <TSource,TKey,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,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.
|
static <TSource,TKey,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey> Enumerable<Grouping<TKey,TSource>> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector)
Groups the elements of a sequence according to a
specified key selector function.
|
<TKey> Enumerable<Grouping<TKey,TSource>> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
EqualityComparer<TKey> comparer)
Groups the elements of a sequence according to a
specified key selector function and compares the keys by using
a specified comparer.
|
<TKey,TAccumulate,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> 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.
|
<TKey,TAccumulate,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TElement> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector)
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.
|
<TKey,TElement> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
EqualityComparer<TKey> comparer)
Groups the elements of a sequence according to a
key selector function.
|
<TKey,TElement,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,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.
|
<TKey,TElement,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,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.
|
<TKey,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey> Enumerable<Grouping<TKey,T>> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector) |
<TKey> Enumerable<Grouping<TKey,T>> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
EqualityComparer<TKey> comparer) |
<TKey,TAccumulate,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,T,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector) |
<TKey,TAccumulate,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,T,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector,
EqualityComparer<TKey> comparer) |
<TKey,TElement> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function1<T,TElement> elementSelector) |
<TKey,TElement> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function1<T,TElement> elementSelector,
EqualityComparer<TKey> comparer) |
<TKey,TElement,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function1<T,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector) |
<TKey,TElement,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function1<T,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector,
EqualityComparer<TKey> comparer) |
<TKey,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function2<TKey,Enumerable<T>,TResult> resultSelector) |
<TKey,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function2<TKey,Enumerable<T>,TResult> elementSelector,
EqualityComparer<TKey> comparer) |
private static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupByMultiple_(Map<TKey,TAccumulate> map,
Enumerable<TSource> enumerable,
List<Function1<TSource,TKey>> keySelectors,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector) |
static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupByMultiple(Enumerable<TSource> enumerable,
List<Function1<TSource,TKey>> keySelectors,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector)
Groups the elements of a sequence according to a list of
specified key selector functions, initializing an accumulator for each
group and adding to it each time an element with the same key is seen.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector)
Correlates the elements of two sequences based on
equality of keys and groups the results.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
DefaultEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,Enumerable<TInner>,TResult> resultSelector) |
<TInner,TKey,TResult> |
DefaultEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.groupJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector)
Correlates the elements of two sequences based on
equality of keys and groups the results.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.groupJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
static <TOuter,TInner,TKey,TResult> |
QueryableDefaults.groupJoin(Queryable<TOuter> outer,
Enumerable<TInner> inner,
FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
private static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashEquiJoin_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Implementation of join that builds the right input and probes with the
left.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector)
Correlates the elements of two sequences based on
matching keys.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
matching keys.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Correlates the elements of two sequences based on matching keys, with
optional outer join semantics.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<TSource,TInner> predicate)
Correlates the elements of two sequences based on matching keys, with
optional outer join semantics.
|
<TInner,TKey,TResult> |
DefaultEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,TInner,TResult> resultSelector) |
<TInner,TKey,TResult> |
DefaultEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
DefaultEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight) |
<TInner,TKey,TResult> |
DefaultEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<T,TInner> predicate) |
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<TSource,TInner> predicate)
Correlates the elements of two sequences based on
matching keys.
|
private static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoinWithPredicate_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<TSource,TInner> predicate)
Implementation of join that builds the right input and probes with the
left
|
Enumerable<T> |
DefaultEnumerable.intersect(Enumerable<T> enumerable1) |
Enumerable<T> |
DefaultEnumerable.intersect(Enumerable<T> enumerable1,
EqualityComparer<T> comparer) |
Enumerable<TSource> |
ExtendedEnumerable.intersect(Enumerable<TSource> enumerable1)
Produces the set intersection of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.intersect(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set intersection of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.intersect(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set intersection of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Enumerable<TSource> |
ExtendedEnumerable.intersect(Enumerable<TSource> enumerable1,
EqualityComparer<TSource> comparer)
Produces the set intersection of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.lazyCollectionSpool(Collection<TSource> outputCollection,
Enumerable<TSource> input)
Lazy read and lazy write spool that stores data into a collection
|
static <TSource,TInner,TKey extends Comparable<TKey>,TResult> |
EnumerableDefaults.mergeJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Joins two inputs that are sorted on the key.
|
static <TSource,TInner,TResult> |
EnumerableDefaults.nestedLoopJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Predicate2<TSource,TInner> predicate,
Function2<TSource,TInner,TResult> resultSelector,
JoinType joinType)
Correlates the elements of two sequences based on a predicate.
|
<TResult> Enumerable<TResult> |
ExtendedEnumerable.ofType(Class<TResult> clazz)
Filters the elements of an Enumerable based on a
specified type.
|
<TResult> Enumerable<TResult> |
DefaultEnumerable.ofType(Class<TResult> clazz) |
static <TSource,TResult> |
EnumerableDefaults.ofType(Enumerable<TSource> enumerable,
Class<TResult> clazz)
Filters the elements of an Enumerable based on a
specified type.
|
static <TSource,TResult> |
Linq4j.ofType(Iterable<TSource> source,
Class<TResult> clazz)
Returns elements of a given
Iterable that are of the specified
type. |
static <TSource,TKey extends Comparable> |
EnumerableDefaults.orderBy(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector)
Sorts the elements of a sequence in ascending
order according to a key.
|
static <TSource,TKey> |
EnumerableDefaults.orderBy(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Comparator<TKey> comparator)
Sorts the elements of a sequence in ascending
order by using a specified comparer.
|
<TKey extends Comparable> |
ExtendedEnumerable.orderBy(Function1<TSource,TKey> keySelector)
Sorts the elements of a sequence in ascending
order according to a key.
|
<TKey> Enumerable<TSource> |
ExtendedEnumerable.orderBy(Function1<TSource,TKey> keySelector,
Comparator<TKey> comparator)
Sorts the elements of a sequence in ascending
order by using a specified comparer.
|
<TKey extends Comparable> |
DefaultEnumerable.orderBy(Function1<T,TKey> keySelector) |
<TKey> Enumerable<T> |
DefaultEnumerable.orderBy(Function1<T,TKey> keySelector,
Comparator<TKey> comparator) |
static <TSource,TKey extends Comparable> |
EnumerableDefaults.orderByDescending(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector)
Sorts the elements of a sequence in descending
order according to a key.
|
static <TSource,TKey> |
EnumerableDefaults.orderByDescending(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Comparator<TKey> comparator)
Sorts the elements of a sequence in descending
order by using a specified comparer.
|
<TKey extends Comparable> |
ExtendedEnumerable.orderByDescending(Function1<TSource,TKey> keySelector)
Sorts the elements of a sequence in descending
order according to a key.
|
<TKey> Enumerable<TSource> |
ExtendedEnumerable.orderByDescending(Function1<TSource,TKey> keySelector,
Comparator<TKey> comparator)
Sorts the elements of a sequence in descending
order by using a specified comparer.
|
<TKey extends Comparable> |
DefaultEnumerable.orderByDescending(Function1<T,TKey> keySelector) |
<TKey> Enumerable<T> |
DefaultEnumerable.orderByDescending(Function1<T,TKey> keySelector,
Comparator<TKey> comparator) |
Enumerable<V> |
LookupImpl.put(K key,
Enumerable<V> value) |
Enumerable<V> |
LookupImpl.remove(Object key) |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.repeatUnionAll(Enumerable<TSource> seed,
Enumerable<TSource> iteration,
int iterationLimit)
Repeat Union All enumerable: it will evaluate the seed enumerable once, and then
it will start to evaluate the iteration enumerable over and over until either it returns
no results, or an optional maximum numbers of iterations is reached
|
Enumerable<TSource> |
ExtendedEnumerable.reverse()
Inverts the order of the elements in a
sequence.
|
Enumerable<T> |
DefaultEnumerable.reverse() |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.reverse(Enumerable<TSource> source)
Inverts the order of the elements in a
sequence.
|
static <TSource,TResult> |
EnumerableDefaults.select(Enumerable<TSource> source,
Function1<TSource,TResult> selector)
Projects each element of a sequence into a new form.
|
static <TSource,TResult> |
EnumerableDefaults.select(Enumerable<TSource> source,
Function2<TSource,Integer,TResult> selector)
Projects each element of a sequence into a new
form by incorporating the element's index.
|
<TResult> Enumerable<TResult> |
ExtendedEnumerable.select(Function1<TSource,TResult> selector)
Projects each element of a sequence into a new
form.
|
<TResult> Enumerable<TResult> |
DefaultEnumerable.select(Function1<T,TResult> selector) |
<TResult> Enumerable<TResult> |
DefaultEnumerable.select(Function2<T,Integer,TResult> selector) |
<TResult> Enumerable<TResult> |
ExtendedEnumerable.select(Function2<TSource,Integer,TResult> selector)
Projects each element of a sequence into a new
form by incorporating the element's index.
|
static <TSource,TCollection,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function1<TSource,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
static <TSource,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function1<TSource,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource> and flattens the resulting sequences into one
sequence. |
static <TSource,TCollection,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
static <TSource,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function2<TSource,Integer,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource>, and flattens the resulting sequences into one
sequence. |
<TCollection,TResult> |
DefaultEnumerable.selectMany(Function1<T,Enumerable<TCollection>> collectionSelector,
Function2<T,TCollection,TResult> resultSelector) |
<TResult> Enumerable<TResult> |
DefaultEnumerable.selectMany(Function1<T,Enumerable<TResult>> selector) |
<TCollection,TResult> |
ExtendedEnumerable.selectMany(Function1<TSource,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
<TResult> Enumerable<TResult> |
ExtendedEnumerable.selectMany(Function1<TSource,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource> and flattens the resulting sequences into one
sequence. |
<TCollection,TResult> |
DefaultEnumerable.selectMany(Function2<T,Integer,Enumerable<TCollection>> collectionSelector,
Function2<T,TCollection,TResult> resultSelector) |
<TResult> Enumerable<TResult> |
DefaultEnumerable.selectMany(Function2<T,Integer,Enumerable<TResult>> selector) |
<TCollection,TResult> |
ExtendedEnumerable.selectMany(Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
<TResult> Enumerable<TResult> |
ExtendedEnumerable.selectMany(Function2<TSource,Integer,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource>, and flattens the resulting sequences into one
sequence. |
private static <TSource,TInner,TKey> |
EnumerableDefaults.semiEquiJoin_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti)
Returns elements of
outer for which there is (semi-join) / is not (anti-semi-join)
a member of inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector)
Returns elements of
outer for which there is a member of
inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti,
Predicate2<TSource,TInner> nonEquiPredicate)
Returns elements of
outer for which there is (semi-join) / is not (anti-semi-join)
a member of inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
Predicate2<TSource,TInner> nonEquiPredicate) |
private static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoinWithPredicate_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti,
Predicate2<TSource,TInner> nonEquiPredicate) |
Enumerable<V> |
GroupingImpl.setValue(Enumerable<V> value) |
static <T> Enumerable<T> |
Linq4j.singletonEnumerable(T element)
Returns an
Enumerable that has one element. |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.skip(Enumerable<TSource> source,
int count)
Bypasses a specified number of elements in a
sequence and then returns the remaining elements.
|
Enumerable<TSource> |
ExtendedEnumerable.skip(int count)
Bypasses a specified number of elements in a
sequence and then returns the remaining elements.
|
Enumerable<T> |
Linq4j.ListEnumerable.skip(int count) |
Enumerable<T> |
DefaultEnumerable.skip(int count) |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.skipWhile(Enumerable<TSource> source,
Predicate1<TSource> predicate)
Bypasses elements in a sequence as long as a
specified condition is true and then returns the remaining
elements.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.skipWhile(Enumerable<TSource> source,
Predicate2<TSource,Integer> predicate)
Bypasses elements in a sequence as long as a
specified condition is true and then returns the remaining
elements.
|
Enumerable<T> |
DefaultEnumerable.skipWhile(Predicate1<T> predicate) |
Enumerable<TSource> |
ExtendedEnumerable.skipWhile(Predicate1<TSource> predicate)
Bypasses elements in a sequence as long as a
specified condition is true and then returns the remaining
elements.
|
Enumerable<T> |
DefaultEnumerable.skipWhile(Predicate2<T,Integer> predicate) |
Enumerable<TSource> |
ExtendedEnumerable.skipWhile(Predicate2<TSource,Integer> predicate)
Bypasses elements in a sequence as long as a
specified condition is true and then returns the remaining
elements.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.take(Enumerable<TSource> source,
int count)
Returns a specified number of contiguous elements
from the start of a sequence.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.take(Enumerable<TSource> source,
long count)
Returns a specified number of contiguous elements
from the start of a sequence.
|
Enumerable<TSource> |
ExtendedEnumerable.take(int count)
Returns a specified number of contiguous elements
from the start of a sequence.
|
Enumerable<T> |
Linq4j.ListEnumerable.take(int count) |
Enumerable<T> |
DefaultEnumerable.take(int count) |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.takeWhile(Enumerable<TSource> source,
Predicate1<TSource> predicate)
Returns elements from a sequence as long as a
specified condition is true.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.takeWhile(Enumerable<TSource> source,
Predicate2<TSource,Integer> predicate)
Returns elements from a sequence as long as a
specified condition is true.
|
Enumerable<T> |
DefaultEnumerable.takeWhile(Predicate1<T> predicate) |
Enumerable<TSource> |
ExtendedEnumerable.takeWhile(Predicate1<TSource> predicate)
Returns elements from a sequence as long as a
specified condition is true.
|
Enumerable<T> |
DefaultEnumerable.takeWhile(Predicate2<T,Integer> predicate) |
Enumerable<TSource> |
ExtendedEnumerable.takeWhile(Predicate2<TSource,Integer> predicate)
Returns elements from a sequence as long as a
specified condition is true.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.takeWhileLong(Enumerable<TSource> source,
Predicate2<TSource,Long> predicate)
Returns elements from a sequence as long as a
specified condition is true.
|
Enumerable<T> |
DefaultEnumerable.union(Enumerable<T> source1) |
Enumerable<T> |
DefaultEnumerable.union(Enumerable<T> source1,
EqualityComparer<T> comparer) |
Enumerable<TSource> |
ExtendedEnumerable.union(Enumerable<TSource> source1)
Produces the set union of two sequences by using
the default equality comparer.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.union(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set union of two sequences by using
the default equality comparer.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.union(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set union of two sequences by using a
specified EqualityComparer<TSource>.
|
Enumerable<TSource> |
ExtendedEnumerable.union(Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set union of two sequences by using a
specified
EqualityComparer<TSource>. |
Enumerable<V> |
LookupImpl.valuesEnumerable()
Returns an enumerable over the values in this lookup, in map order.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.where(Enumerable<TSource> source,
Predicate1<TSource> predicate)
Filters a sequence of values based on a
predicate.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.where(Enumerable<TSource> source,
Predicate2<TSource,Integer> predicate)
Filters a sequence of values based on a
predicate.
|
Enumerable<T> |
DefaultEnumerable.where(Predicate1<T> predicate) |
Enumerable<TSource> |
ExtendedEnumerable.where(Predicate1<TSource> predicate)
Filters a sequence of values based on a
predicate.
|
Enumerable<T> |
DefaultEnumerable.where(Predicate2<T,Integer> predicate) |
Enumerable<TSource> |
ExtendedEnumerable.where(Predicate2<TSource,Integer> predicate)
Filters a sequence of values based on a
predicate.
|
static <T0,T1,TResult> |
EnumerableDefaults.zip(Enumerable<T0> first,
Enumerable<T1> second,
Function2<T0,T1,TResult> resultSelector)
Applies a specified function to the corresponding
elements of two sequences, producing a sequence of the
results.
|
<T1,TResult> |
ExtendedEnumerable.zip(Enumerable<T1> source1,
Function2<TSource,T1,TResult> resultSelector)
Applies a specified function to the corresponding
elements of two sequences, producing a sequence of the
results.
|
<T1,TResult> |
DefaultEnumerable.zip(Enumerable<T1> source1,
Function2<T,T1,TResult> resultSelector) |
| Modifier and Type | Method and Description |
|---|---|
Set<Map.Entry<K,Enumerable<V>>> |
LookupImpl.entrySet() |
Collection<Enumerable<V>> |
LookupImpl.values() |
| Modifier and Type | Method and Description |
|---|---|
static <TSource> TSource |
EnumerableDefaults.aggregate(Enumerable<TSource> source,
Function2<TSource,TSource,TSource> func)
Applies an accumulator function over a sequence.
|
static <TSource,TAccumulate> |
EnumerableDefaults.aggregate(Enumerable<TSource> source,
TAccumulate seed,
Function2<TAccumulate,TSource,TAccumulate> func)
Applies an accumulator function over a
sequence.
|
static <TSource,TAccumulate,TResult> |
EnumerableDefaults.aggregate(Enumerable<TSource> source,
TAccumulate seed,
Function2<TAccumulate,TSource,TAccumulate> func,
Function1<TAccumulate,TResult> selector)
Applies an accumulator function over a
sequence.
|
static <TSource> boolean |
EnumerableDefaults.all(Enumerable<TSource> enumerable,
Predicate1<TSource> predicate)
Determines whether all elements of a sequence
satisfy a condition.
|
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector)
Returns elements of
outer for which there is NOT a member of
inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector)
Returns elements of
outer for which there is NOT a member of
inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
Predicate2<TSource,TInner> nonEquiPredicate) |
static <TSource,TInner,TKey> |
EnumerableDefaults.antiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
Predicate2<TSource,TInner> nonEquiPredicate) |
static boolean |
EnumerableDefaults.any(Enumerable enumerable)
Determines whether a sequence contains any
elements.
|
static <TSource> boolean |
EnumerableDefaults.any(Enumerable<TSource> enumerable,
Predicate1<TSource> predicate)
Determines whether any element of a sequence
satisfies a condition.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.asEnumerable(Enumerable<TSource> enumerable)
Returns the input typed as
Enumerable<TSource>. |
static <T> OrderedQueryable<T> |
EnumerableDefaults.asOrderedQueryable(Enumerable<T> source) |
static <TSource> Queryable<TSource> |
EnumerableDefaults.asQueryable(Enumerable<TSource> enumerable)
Converts an Enumerable to an IQueryable.
|
static <TSource> BigDecimal |
EnumerableDefaults.average(Enumerable<TSource> source,
BigDecimalFunction1<TSource> selector)
Computes the average of a sequence of Decimal
values that are obtained by invoking a transform function on
each element of the input sequence.
|
static <TSource> double |
EnumerableDefaults.average(Enumerable<TSource> source,
DoubleFunction1<TSource> 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.
|
static <TSource> float |
EnumerableDefaults.average(Enumerable<TSource> source,
FloatFunction1<TSource> 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.
|
static <TSource> int |
EnumerableDefaults.average(Enumerable<TSource> source,
IntegerFunction1<TSource> 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.
|
static <TSource> long |
EnumerableDefaults.average(Enumerable<TSource> source,
LongFunction1<TSource> 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.
|
static <TSource> BigDecimal |
EnumerableDefaults.average(Enumerable<TSource> source,
NullableBigDecimalFunction1<TSource> 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.
|
static <TSource> Double |
EnumerableDefaults.average(Enumerable<TSource> source,
NullableDoubleFunction1<TSource> 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.
|
static <TSource> Float |
EnumerableDefaults.average(Enumerable<TSource> source,
NullableFloatFunction1<TSource> 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.
|
static <TSource> Integer |
EnumerableDefaults.average(Enumerable<TSource> source,
NullableIntegerFunction1<TSource> 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.
|
static <TSource> Long |
EnumerableDefaults.average(Enumerable<TSource> source,
NullableLongFunction1<TSource> 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.
|
static <TSource,T2> |
EnumerableDefaults.cast(Enumerable<TSource> source,
Class<T2> clazz)
Analogous to LINQ's Enumerable.Cast extension method.
|
Queryable<T> |
DefaultQueryable.concat(Enumerable<T> source2) |
Enumerable<T> |
DefaultEnumerable.concat(Enumerable<T> enumerable1) |
Queryable<T> |
EnumerableQueryable.concat(Enumerable<T> source2) |
Enumerable<TSource> |
ExtendedEnumerable.concat(Enumerable<TSource> enumerable1)
Concatenates two sequences.
|
Queryable<TSource> |
ExtendedQueryable.concat(Enumerable<TSource> source2)
Concatenates two sequences.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.concat(Enumerable<TSource> enumerable0,
Enumerable<TSource> enumerable1)
Concatenates two sequences.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.concat(Enumerable<TSource> enumerable0,
Enumerable<TSource> enumerable1)
Concatenates two sequences.
|
Queryable<T> |
QueryableFactory.concat(Queryable<T> source,
Enumerable<T> source2)
Concatenates two sequences.
|
Queryable<T> |
QueryableRecorder.concat(Queryable<T> source,
Enumerable<T> source2) |
static <T> Queryable<T> |
QueryableDefaults.concat(Queryable<T> queryable0,
Enumerable<T> source2)
Concatenates two sequences.
|
static <TSource> boolean |
EnumerableDefaults.contains(Enumerable<TSource> enumerable,
TSource element)
Determines whether a sequence contains a specified
element by using the default equality comparer.
|
static <TSource> boolean |
EnumerableDefaults.contains(Enumerable<TSource> enumerable,
TSource element,
EqualityComparer<TSource> comparer)
Determines whether a sequence contains a specified
element by using a specified
EqualityComparer<TSource>. |
static <TSource,TInner,TResult> |
EnumerableDefaults.correlateBatchJoin(JoinType joinType,
Enumerable<TSource> outer,
Function1<List<TSource>,Enumerable<TInner>> inner,
Function2<TSource,TInner,TResult> resultSelector,
Predicate2<TSource,TInner> predicate,
int batchSize)
Fetches blocks of size
batchSize from outer,
storing each block into a list (outerValues). |
static <TSource,TInner,TResult> |
EnumerableDefaults.correlateJoin(JoinType joinType,
Enumerable<TSource> outer,
Function1<TSource,Enumerable<TInner>> inner,
Function2<TSource,TInner,TResult> resultSelector)
For each row of the
outer enumerable returns the correlated rows
from the inner enumerable. |
static <TSource> int |
EnumerableDefaults.count(Enumerable<TSource> enumerable)
Returns the number of elements in a
sequence.
|
static <TSource> int |
EnumerableDefaults.count(Enumerable<TSource> enumerable,
Predicate1<TSource> predicate)
Returns a number that represents how many elements
in the specified sequence satisfy a condition.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.defaultIfEmpty(Enumerable<TSource> enumerable)
Returns the elements of the specified sequence or
the type parameter's default value in a singleton collection if
the sequence is empty.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.defaultIfEmpty(Enumerable<TSource> enumerable,
TSource value)
Returns the elements of the specified sequence or
the specified value in a singleton collection if the sequence
is empty.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.distinct(Enumerable<TSource> enumerable)
Returns distinct elements from a sequence by using
the default
EqualityComparer to compare values. |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.distinct(Enumerable<TSource> enumerable,
EqualityComparer<TSource> comparer)
Returns distinct elements from a sequence by using
a specified
EqualityComparer to compare values. |
static <TSource> TSource |
EnumerableDefaults.elementAt(Enumerable<TSource> enumerable,
int index)
Returns the element at a specified index in a
sequence.
|
static <TSource> TSource |
EnumerableDefaults.elementAtOrDefault(Enumerable<TSource> enumerable,
int index)
Returns the element at a specified index in a
sequence or a default value if the index is out of
range.
|
Queryable<T> |
DefaultQueryable.except(Enumerable<T> enumerable1) |
Enumerable<T> |
DefaultEnumerable.except(Enumerable<T> enumerable1) |
Queryable<T> |
EnumerableQueryable.except(Enumerable<T> enumerable1) |
Queryable<T> |
DefaultQueryable.except(Enumerable<T> enumerable1,
EqualityComparer<T> comparer) |
Enumerable<T> |
DefaultEnumerable.except(Enumerable<T> enumerable1,
EqualityComparer<T> comparer) |
Queryable<T> |
EnumerableQueryable.except(Enumerable<T> enumerable1,
EqualityComparer<T> comparer) |
Enumerable<TSource> |
ExtendedEnumerable.except(Enumerable<TSource> enumerable1)
Produces the set difference of two sequences by
using the default equality comparer to compare values.
|
Queryable<TSource> |
ExtendedQueryable.except(Enumerable<TSource> enumerable)
Produces the set difference of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.except(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set difference of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.except(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set difference of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.except(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set difference of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.except(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set difference of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Enumerable<TSource> |
ExtendedEnumerable.except(Enumerable<TSource> enumerable1,
EqualityComparer<TSource> comparer)
Produces the set difference of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Queryable<TSource> |
ExtendedQueryable.except(Enumerable<TSource> enumerable,
EqualityComparer<TSource> comparer)
Produces the set difference of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Queryable<T> |
QueryableFactory.except(Queryable<T> source,
Enumerable<T> enumerable)
Produces the set difference of two sequences by
using the default equality comparer to compare values.
|
Queryable<T> |
QueryableRecorder.except(Queryable<T> source,
Enumerable<T> enumerable) |
static <T> Queryable<T> |
QueryableDefaults.except(Queryable<T> queryable,
Enumerable<T> enumerable)
Produces the set difference of two sequences by
using the default equality comparer to compare values.
|
Queryable<T> |
QueryableFactory.except(Queryable<T> source,
Enumerable<T> enumerable,
EqualityComparer<T> comparer)
Produces the set difference of two sequences by
using the specified
EqualityComparer<T> to compare
values. |
Queryable<T> |
QueryableRecorder.except(Queryable<T> source,
Enumerable<T> enumerable,
EqualityComparer<T> comparer) |
static <T> Queryable<T> |
QueryableDefaults.except(Queryable<T> queryable,
Enumerable<T> enumerable,
EqualityComparer<T> comparer)
Produces the set difference of two sequences by
using the specified
EqualityComparer<T> to compare
values. |
static <TSource> TSource |
EnumerableDefaults.first(Enumerable<TSource> enumerable)
Returns the first element of a sequence.
|
static <TSource> TSource |
EnumerableDefaults.first(Enumerable<TSource> enumerable,
Predicate1<TSource> predicate)
Returns the first element in a sequence that
satisfies a specified condition.
|
static <TSource> TSource |
EnumerableDefaults.firstOrDefault(Enumerable<TSource> enumerable)
Returns the first element of a sequence, or a
default value if the sequence contains no elements.
|
static <TSource> TSource |
EnumerableDefaults.firstOrDefault(Enumerable<TSource> enumerable,
Predicate1<TSource> predicate)
Returns the first element of the sequence that
satisfies a condition or a default value if no such element is
found.
|
private static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupBy_(Map<TKey,TAccumulate> map,
Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector) |
private static <TSource,TKey,TResult> |
EnumerableDefaults.groupBy_(Set<TKey> map,
Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TKey,TResult> resultSelector) |
static <TSource,TKey> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector)
Groups the elements of a sequence according to a
specified key selector function.
|
static <TSource,TKey> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
EqualityComparer<TKey> comparer)
Groups the elements of a sequence according to a
specified key selector function and compares the keys by using
a specified comparer.
|
static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> 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.
|
static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
static <TSource,TKey,TElement> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector)
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.
|
static <TSource,TKey,TElement> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
EqualityComparer<TKey> comparer)
Groups the elements of a sequence according to a
key selector function.
|
static <TSource,TKey,TElement,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,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.
|
static <TSource,TKey,TElement,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
static <TSource,TKey,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,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.
|
static <TSource,TKey,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
private static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupByMultiple_(Map<TKey,TAccumulate> map,
Enumerable<TSource> enumerable,
List<Function1<TSource,TKey>> keySelectors,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector) |
static <TSource,TKey,TAccumulate,TResult> |
EnumerableDefaults.groupByMultiple(Enumerable<TSource> enumerable,
List<Function1<TSource,TKey>> keySelectors,
Function0<TAccumulate> accumulatorInitializer,
Function2<TAccumulate,TSource,TAccumulate> accumulatorAdder,
Function2<TKey,TAccumulate,TResult> resultSelector)
Groups the elements of a sequence according to a list of
specified key selector functions, initializing an accumulator for each
group and adding to it each time an element with the same key is seen.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector)
Correlates the elements of two sequences based on
equality of keys and groups the results.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
DefaultEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,Enumerable<TInner>,TResult> resultSelector) |
<TInner,TKey,TResult> |
DefaultEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
ExtendedQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
ExtendedQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
DefaultQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector) |
<TInner,TKey,TResult> |
EnumerableQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector) |
<TInner,TKey,TResult> |
DefaultQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
EnumerableQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.groupJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector)
Correlates the elements of two sequences based on
equality of keys and groups the results.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.groupJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector)
Correlates the elements of two sequences based on
equality of keys and groups the results.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.groupJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.groupJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
QueryableFactory.groupJoin(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
QueryableRecorder.groupJoin(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector) |
<TInner,TKey,TResult> |
QueryableFactory.groupJoin(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
QueryableRecorder.groupJoin(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
static <TOuter,TInner,TKey,TResult> |
QueryableDefaults.groupJoin(Queryable<TOuter> outer,
Enumerable<TInner> inner,
FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector)
Correlates the elements of two sequences based on
key equality and groups the results.
|
static <TOuter,TInner,TKey,TResult> |
QueryableDefaults.groupJoin(Queryable<TOuter> outer,
Enumerable<TInner> inner,
FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
private static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashEquiJoin_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Implementation of join that builds the right input and probes with the
left.
|
private static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashEquiJoin_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Implementation of join that builds the right input and probes with the
left.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector)
Correlates the elements of two sequences based on
matching keys.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
matching keys.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Correlates the elements of two sequences based on matching keys, with
optional outer join semantics.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<TSource,TInner> predicate)
Correlates the elements of two sequences based on matching keys, with
optional outer join semantics.
|
<TInner,TKey,TResult> |
DefaultEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,TInner,TResult> resultSelector) |
<TInner,TKey,TResult> |
DefaultEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
DefaultEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight) |
<TInner,TKey,TResult> |
DefaultEnumerable.hashJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<T,TInner> predicate) |
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<TSource,TInner> predicate)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<TSource,TInner> predicate)
Correlates the elements of two sequences based on
matching keys.
|
private static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoinWithPredicate_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<TSource,TInner> predicate)
Implementation of join that builds the right input and probes with the
left
|
private static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.hashJoinWithPredicate_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
EqualityComparer<TKey> comparer,
boolean generateNullsOnLeft,
boolean generateNullsOnRight,
Predicate2<TSource,TInner> predicate)
Implementation of join that builds the right input and probes with the
left
|
Queryable<T> |
DefaultQueryable.intersect(Enumerable<T> source1) |
Enumerable<T> |
DefaultEnumerable.intersect(Enumerable<T> enumerable1) |
Queryable<T> |
EnumerableQueryable.intersect(Enumerable<T> source1) |
Queryable<T> |
DefaultQueryable.intersect(Enumerable<T> source1,
EqualityComparer<T> comparer) |
Enumerable<T> |
DefaultEnumerable.intersect(Enumerable<T> enumerable1,
EqualityComparer<T> comparer) |
Queryable<T> |
EnumerableQueryable.intersect(Enumerable<T> source1,
EqualityComparer<T> comparer) |
Enumerable<TSource> |
ExtendedEnumerable.intersect(Enumerable<TSource> enumerable1)
Produces the set intersection of two sequences by
using the default equality comparer to compare values.
|
Queryable<TSource> |
ExtendedQueryable.intersect(Enumerable<TSource> enumerable)
Produces the set intersection of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.intersect(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set intersection of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.intersect(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set intersection of two sequences by
using the default equality comparer to compare values.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.intersect(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set intersection of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.intersect(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set intersection of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Enumerable<TSource> |
ExtendedEnumerable.intersect(Enumerable<TSource> enumerable1,
EqualityComparer<TSource> comparer)
Produces the set intersection of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Queryable<TSource> |
ExtendedQueryable.intersect(Enumerable<TSource> enumerable,
EqualityComparer<TSource> comparer)
Produces the set intersection of two sequences by
using the specified
EqualityComparer<TSource> to compare
values. |
Queryable<T> |
QueryableFactory.intersect(Queryable<T> source,
Enumerable<T> enumerable)
Produces the set intersection of two sequences by
using the default equality comparer to compare values.
|
Queryable<T> |
QueryableRecorder.intersect(Queryable<T> source,
Enumerable<T> enumerable) |
static <T> Queryable<T> |
QueryableDefaults.intersect(Queryable<T> queryable,
Enumerable<T> enumerable)
Produces the set intersection of two sequences by
using the default equality comparer to compare values.
|
Queryable<T> |
QueryableFactory.intersect(Queryable<T> source,
Enumerable<T> enumerable,
EqualityComparer<T> comparer)
Produces the set intersection of two sequences by
using the specified EqualityComparer to compare
values.
|
Queryable<T> |
QueryableRecorder.intersect(Queryable<T> source,
Enumerable<T> enumerable,
EqualityComparer<T> comparer) |
static <T> Queryable<T> |
QueryableDefaults.intersect(Queryable<T> queryable,
Enumerable<T> enumerable,
EqualityComparer<T> comparer)
Produces the set intersection of two sequences by
using the specified
EqualityComparer<T> to compare
values. |
static <T,C extends Collection<? super T>> |
EnumerableDefaults.into(Enumerable<T> source,
C sink)
Default implementation of
ExtendedEnumerable.into(Collection). |
<TInner,TKey,TResult> |
ExtendedQueryable.join(Enumerable<TInner> inner,
FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TSource,TInner,TResult>> resultSelector)
Correlates the elements of two sequences based on
matching keys.
|
<TInner,TKey,TResult> |
ExtendedQueryable.join(Enumerable<TInner> inner,
FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TSource,TInner,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
matching keys.
|
<TInner,TKey,TResult> |
DefaultQueryable.join(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,TInner,TResult>> resultSelector) |
<TInner,TKey,TResult> |
EnumerableQueryable.join(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,TInner,TResult>> resultSelector) |
<TInner,TKey,TResult> |
DefaultQueryable.join(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,TInner,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
EnumerableQueryable.join(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,TInner,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
QueryableFactory.join(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,TInner,TResult>> resultSelector)
Correlates the elements of two sequences based on
matching keys.
|
<TInner,TKey,TResult> |
QueryableRecorder.join(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,TInner,TResult>> resultSelector) |
<TInner,TKey,TResult> |
QueryableFactory.join(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,TInner,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
matching keys.
|
<TInner,TKey,TResult> |
QueryableRecorder.join(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,TInner,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
static <TOuter,TInner,TKey,TResult> |
QueryableDefaults.join(Queryable<TOuter> outer,
Enumerable<TInner> inner,
FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TOuter,TInner,TResult>> resultSelector)
Correlates the elements of two sequences based on
matching keys.
|
static <TOuter,TInner,TKey,TResult> |
QueryableDefaults.join(Queryable<TOuter> outer,
Enumerable<TInner> inner,
FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TOuter,TInner,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
matching keys.
|
static <TSource> TSource |
EnumerableDefaults.last(Enumerable<TSource> enumerable)
Returns the last element of a sequence.
|
static <TSource> TSource |
EnumerableDefaults.last(Enumerable<TSource> enumerable,
Predicate1<TSource> predicate)
Returns the last element of a sequence that
satisfies a specified condition.
|
static <TSource> TSource |
EnumerableDefaults.lastOrDefault(Enumerable<TSource> enumerable)
Returns the last element of a sequence, or a
default value if the sequence contains no elements.
|
static <TSource> TSource |
EnumerableDefaults.lastOrDefault(Enumerable<TSource> enumerable,
Predicate1<TSource> predicate)
Returns the last element of a sequence that
satisfies a condition or a default value if no such element is
found.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.lazyCollectionSpool(Collection<TSource> outputCollection,
Enumerable<TSource> input)
Lazy read and lazy write spool that stores data into a collection
|
static <TSource> long |
EnumerableDefaults.longCount(Enumerable<TSource> source)
Returns an long that represents the total number
of elements in a sequence.
|
static <TSource> long |
EnumerableDefaults.longCount(Enumerable<TSource> enumerable,
Predicate1<TSource> predicate)
Returns an long that represents how many elements
in a sequence satisfy a condition.
|
static <TSource extends Comparable<TSource>> |
EnumerableDefaults.max(Enumerable<TSource> source)
Returns the maximum value in a generic
sequence.
|
static <TSource> BigDecimal |
EnumerableDefaults.max(Enumerable<TSource> source,
BigDecimalFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum Decimal value.
|
static <TSource> double |
EnumerableDefaults.max(Enumerable<TSource> source,
DoubleFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum Double value.
|
static <TSource> float |
EnumerableDefaults.max(Enumerable<TSource> source,
FloatFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum Float value.
|
static <TSource,TResult extends Comparable<TResult>> |
EnumerableDefaults.max(Enumerable<TSource> source,
Function1<TSource,TResult> selector)
Invokes a transform function on each element of a
generic sequence and returns the maximum resulting
value.
|
static <TSource> int |
EnumerableDefaults.max(Enumerable<TSource> source,
IntegerFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum int value.
|
static <TSource> long |
EnumerableDefaults.max(Enumerable<TSource> source,
LongFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum long value.
|
static <TSource> BigDecimal |
EnumerableDefaults.max(Enumerable<TSource> source,
NullableBigDecimalFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum nullable Decimal
value.
|
static <TSource> Double |
EnumerableDefaults.max(Enumerable<TSource> source,
NullableDoubleFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum nullable Double
value.
|
static <TSource> Float |
EnumerableDefaults.max(Enumerable<TSource> source,
NullableFloatFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum nullable Float
value.
|
static <TSource> Integer |
EnumerableDefaults.max(Enumerable<TSource> source,
NullableIntegerFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum nullable int value.
|
static <TSource> Long |
EnumerableDefaults.max(Enumerable<TSource> source,
NullableLongFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the maximum nullable long value.
|
static <TSource,TInner,TKey extends Comparable<TKey>,TResult> |
EnumerableDefaults.mergeJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Joins two inputs that are sorted on the key.
|
static <TSource,TInner,TKey extends Comparable<TKey>,TResult> |
EnumerableDefaults.mergeJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,TInner,TResult> resultSelector,
boolean generateNullsOnLeft,
boolean generateNullsOnRight)
Joins two inputs that are sorted on the key.
|
static <TSource extends Comparable<TSource>> |
EnumerableDefaults.min(Enumerable<TSource> source)
Returns the minimum value in a generic
sequence.
|
static <TSource> BigDecimal |
EnumerableDefaults.min(Enumerable<TSource> source,
BigDecimalFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum Decimal value.
|
static <TSource> double |
EnumerableDefaults.min(Enumerable<TSource> source,
DoubleFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum Double value.
|
static <TSource> float |
EnumerableDefaults.min(Enumerable<TSource> source,
FloatFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum Float value.
|
static <TSource,TResult extends Comparable<TResult>> |
EnumerableDefaults.min(Enumerable<TSource> source,
Function1<TSource,TResult> selector)
Invokes a transform function on each element of a
generic sequence and returns the minimum resulting
value.
|
static <TSource> int |
EnumerableDefaults.min(Enumerable<TSource> source,
IntegerFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum int value.
|
static <TSource> long |
EnumerableDefaults.min(Enumerable<TSource> source,
LongFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum long value.
|
static <TSource> BigDecimal |
EnumerableDefaults.min(Enumerable<TSource> source,
NullableBigDecimalFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum nullable Decimal
value.
|
static <TSource> Double |
EnumerableDefaults.min(Enumerable<TSource> source,
NullableDoubleFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum nullable Double
value.
|
static <TSource> Float |
EnumerableDefaults.min(Enumerable<TSource> source,
NullableFloatFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum nullable Float
value.
|
static <TSource> Integer |
EnumerableDefaults.min(Enumerable<TSource> source,
NullableIntegerFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum nullable int value.
|
static <TSource> Long |
EnumerableDefaults.min(Enumerable<TSource> source,
NullableLongFunction1<TSource> selector)
Invokes a transform function on each element of a
sequence and returns the minimum nullable long value.
|
static <TSource,TInner,TResult> |
EnumerableDefaults.nestedLoopJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Predicate2<TSource,TInner> predicate,
Function2<TSource,TInner,TResult> resultSelector,
JoinType joinType)
Correlates the elements of two sequences based on a predicate.
|
static <TSource,TInner,TResult> |
EnumerableDefaults.nestedLoopJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Predicate2<TSource,TInner> predicate,
Function2<TSource,TInner,TResult> resultSelector,
JoinType joinType)
Correlates the elements of two sequences based on a predicate.
|
static <TSource,TResult> |
EnumerableDefaults.ofType(Enumerable<TSource> enumerable,
Class<TResult> clazz)
Filters the elements of an Enumerable based on a
specified type.
|
static <TSource,TKey extends Comparable> |
EnumerableDefaults.orderBy(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector)
Sorts the elements of a sequence in ascending
order according to a key.
|
static <TSource,TKey> |
EnumerableDefaults.orderBy(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Comparator<TKey> comparator)
Sorts the elements of a sequence in ascending
order by using a specified comparer.
|
static <TSource,TKey extends Comparable> |
EnumerableDefaults.orderByDescending(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector)
Sorts the elements of a sequence in descending
order according to a key.
|
static <TSource,TKey> |
EnumerableDefaults.orderByDescending(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Comparator<TKey> comparator)
Sorts the elements of a sequence in descending
order by using a specified comparer.
|
Enumerable<V> |
LookupImpl.put(K key,
Enumerable<V> value) |
static <T,C extends Collection<? super T>> |
EnumerableDefaults.remove(Enumerable<T> source,
C sink)
Default implementation of
ExtendedEnumerable.removeAll(Collection). |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.repeatUnionAll(Enumerable<TSource> seed,
Enumerable<TSource> iteration,
int iterationLimit)
Repeat Union All enumerable: it will evaluate the seed enumerable once, and then
it will start to evaluate the iteration enumerable over and over until either it returns
no results, or an optional maximum numbers of iterations is reached
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.repeatUnionAll(Enumerable<TSource> seed,
Enumerable<TSource> iteration,
int iterationLimit)
Repeat Union All enumerable: it will evaluate the seed enumerable once, and then
it will start to evaluate the iteration enumerable over and over until either it returns
no results, or an optional maximum numbers of iterations is reached
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.reverse(Enumerable<TSource> source)
Inverts the order of the elements in a
sequence.
|
static <TSource,TResult> |
EnumerableDefaults.select(Enumerable<TSource> source,
Function1<TSource,TResult> selector)
Projects each element of a sequence into a new form.
|
static <TSource,TResult> |
EnumerableDefaults.select(Enumerable<TSource> source,
Function2<TSource,Integer,TResult> selector)
Projects each element of a sequence into a new
form by incorporating the element's index.
|
static <TSource,TCollection,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function1<TSource,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
static <TSource,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function1<TSource,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource> and flattens the resulting sequences into one
sequence. |
static <TSource,TCollection,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
static <TSource,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function2<TSource,Integer,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource>, and flattens the resulting sequences into one
sequence. |
private static <TSource,TInner,TKey> |
EnumerableDefaults.semiEquiJoin_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti)
Returns elements of
outer for which there is (semi-join) / is not (anti-semi-join)
a member of inner with a matching key. |
private static <TSource,TInner,TKey> |
EnumerableDefaults.semiEquiJoin_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti)
Returns elements of
outer for which there is (semi-join) / is not (anti-semi-join)
a member of inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector)
Returns elements of
outer for which there is a member of
inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector)
Returns elements of
outer for which there is a member of
inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti,
Predicate2<TSource,TInner> nonEquiPredicate)
Returns elements of
outer for which there is (semi-join) / is not (anti-semi-join)
a member of inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti,
Predicate2<TSource,TInner> nonEquiPredicate)
Returns elements of
outer for which there is (semi-join) / is not (anti-semi-join)
a member of inner with a matching key. |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
Predicate2<TSource,TInner> nonEquiPredicate) |
static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
Predicate2<TSource,TInner> nonEquiPredicate) |
private static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoinWithPredicate_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti,
Predicate2<TSource,TInner> nonEquiPredicate) |
private static <TSource,TInner,TKey> |
EnumerableDefaults.semiJoinWithPredicate_(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
EqualityComparer<TKey> comparer,
boolean anti,
Predicate2<TSource,TInner> nonEquiPredicate) |
boolean |
DefaultEnumerable.sequenceEqual(Enumerable<T> enumerable1) |
boolean |
DefaultEnumerable.sequenceEqual(Enumerable<T> enumerable1,
EqualityComparer<T> comparer) |
boolean |
ExtendedEnumerable.sequenceEqual(Enumerable<TSource> enumerable1)
Determines whether two sequences are equal by
comparing the elements by using the default equality comparer
for their type.
|
static <TSource> boolean |
EnumerableDefaults.sequenceEqual(Enumerable<TSource> first,
Enumerable<TSource> second)
Determines whether two sequences are equal by
comparing the elements by using the default equality comparer
for their type.
|
static <TSource> boolean |
EnumerableDefaults.sequenceEqual(Enumerable<TSource> first,
Enumerable<TSource> second)
Determines whether two sequences are equal by
comparing the elements by using the default equality comparer
for their type.
|
static <TSource> boolean |
EnumerableDefaults.sequenceEqual(Enumerable<TSource> first,
Enumerable<TSource> second,
EqualityComparer<TSource> comparer)
Determines whether two sequences are equal by
comparing their elements by using a specified
EqualityComparer<TSource>. |
static <TSource> boolean |
EnumerableDefaults.sequenceEqual(Enumerable<TSource> first,
Enumerable<TSource> second,
EqualityComparer<TSource> comparer)
Determines whether two sequences are equal by
comparing their elements by using a specified
EqualityComparer<TSource>. |
boolean |
ExtendedEnumerable.sequenceEqual(Enumerable<TSource> enumerable1,
EqualityComparer<TSource> comparer)
Determines whether two sequences are equal by
comparing their elements by using a specified
EqualityComparer<TSource>. |
boolean |
QueryableFactory.sequenceEqual(Queryable<T> source,
Enumerable<T> enumerable)
Determines whether two sequences are equal by
using the default equality comparer to compare
elements.
|
boolean |
QueryableRecorder.sequenceEqual(Queryable<T> source,
Enumerable<T> enumerable) |
static <T> boolean |
QueryableDefaults.sequenceEqual(Queryable<T> queryable,
Enumerable<T> enumerable)
Determines whether two sequences are equal by
using the default equality comparer to compare
elements.
|
boolean |
QueryableFactory.sequenceEqual(Queryable<T> source,
Enumerable<T> enumerable,
EqualityComparer<T> comparer)
Determines whether two sequences are equal by
using a specified EqualityComparer to compare
elements.
|
boolean |
QueryableRecorder.sequenceEqual(Queryable<T> source,
Enumerable<T> enumerable,
EqualityComparer<T> comparer) |
static <T> boolean |
QueryableDefaults.sequenceEqual(Queryable<T> queryable,
Enumerable<T> enumerable,
EqualityComparer<T> comparer)
Determines whether two sequences are equal by
using a specified
EqualityComparer<T> to compare
elements. |
Enumerable<V> |
GroupingImpl.setValue(Enumerable<V> value) |
static <TSource> TSource |
EnumerableDefaults.single(Enumerable<TSource> source)
Returns the only element of a sequence, and throws
an exception if there is not exactly one element in the
sequence.
|
static <TSource> TSource |
EnumerableDefaults.single(Enumerable<TSource> source,
Predicate1<TSource> predicate)
Returns the only element of a sequence that
satisfies a specified condition, and throws an exception if
more than one such element exists.
|
static <TSource> TSource |
EnumerableDefaults.singleOrDefault(Enumerable<TSource> source)
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.
|
static <TSource> TSource |
EnumerableDefaults.singleOrDefault(Enumerable<TSource> source,
Predicate1<TSource> predicate)
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.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.skip(Enumerable<TSource> source,
int count)
Bypasses a specified number of elements in a
sequence and then returns the remaining elements.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.skipWhile(Enumerable<TSource> source,
Predicate1<TSource> predicate)
Bypasses elements in a sequence as long as a
specified condition is true and then returns the remaining
elements.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.skipWhile(Enumerable<TSource> source,
Predicate2<TSource,Integer> predicate)
Bypasses elements in a sequence as long as a
specified condition is true and then returns the remaining
elements.
|
static <TSource> BigDecimal |
EnumerableDefaults.sum(Enumerable<TSource> source,
BigDecimalFunction1<TSource> selector)
Computes the sum of the sequence of Decimal values
that are obtained by invoking a transform function on each
element of the input sequence.
|
static <TSource> double |
EnumerableDefaults.sum(Enumerable<TSource> source,
DoubleFunction1<TSource> 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.
|
static <TSource> float |
EnumerableDefaults.sum(Enumerable<TSource> source,
FloatFunction1<TSource> 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.
|
static <TSource> int |
EnumerableDefaults.sum(Enumerable<TSource> source,
IntegerFunction1<TSource> 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.
|
static <TSource> long |
EnumerableDefaults.sum(Enumerable<TSource> source,
LongFunction1<TSource> 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.
|
static <TSource> BigDecimal |
EnumerableDefaults.sum(Enumerable<TSource> source,
NullableBigDecimalFunction1<TSource> 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.
|
static <TSource> Double |
EnumerableDefaults.sum(Enumerable<TSource> source,
NullableDoubleFunction1<TSource> 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.
|
static <TSource> Float |
EnumerableDefaults.sum(Enumerable<TSource> source,
NullableFloatFunction1<TSource> 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.
|
static <TSource> Integer |
EnumerableDefaults.sum(Enumerable<TSource> source,
NullableIntegerFunction1<TSource> 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.
|
static <TSource> Long |
EnumerableDefaults.sum(Enumerable<TSource> source,
NullableLongFunction1<TSource> 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.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.take(Enumerable<TSource> source,
int count)
Returns a specified number of contiguous elements
from the start of a sequence.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.take(Enumerable<TSource> source,
long count)
Returns a specified number of contiguous elements
from the start of a sequence.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.takeWhile(Enumerable<TSource> source,
Predicate1<TSource> predicate)
Returns elements from a sequence as long as a
specified condition is true.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.takeWhile(Enumerable<TSource> source,
Predicate2<TSource,Integer> predicate)
Returns elements from a sequence as long as a
specified condition is true.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.takeWhileLong(Enumerable<TSource> source,
Predicate2<TSource,Long> predicate)
Returns elements from a sequence as long as a
specified condition is true.
|
static <TSource> List<TSource> |
EnumerableDefaults.toList(Enumerable<TSource> source)
Creates a
List<TSource> from an Enumerable<TSource>. |
(package private) static <TSource,TKey,TElement> |
EnumerableDefaults.toLookup_(Map<TKey,List<TElement>> map,
Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector) |
static <TSource,TKey> |
EnumerableDefaults.toLookup(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector)
Creates a Lookup<TKey, TElement> from an
Enumerable<TSource> according to a specified key selector
function.
|
static <TSource,TKey> |
EnumerableDefaults.toLookup(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
EqualityComparer<TKey> comparer)
Creates a
Lookup<TKey, TElement> from an
Enumerable<TSource> according to a specified key selector function
and key comparer. |
static <TSource,TKey,TElement> |
EnumerableDefaults.toLookup(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector)
Creates a
Lookup<TKey, TElement> from an
Enumerable<TSource> according to specified key selector and element
selector functions. |
static <TSource,TKey,TElement> |
EnumerableDefaults.toLookup(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
EqualityComparer<TKey> comparer)
Creates a
Lookup<TKey, TElement> from an
Enumerable<TSource> according to a specified key selector function,
a comparer and an element selector function. |
static <TSource,TKey> |
EnumerableDefaults.toMap(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector)
Creates a Map<TKey, TValue> from an
Enumerable<TSource> according to a specified key selector
function.
|
static <TSource,TKey> |
EnumerableDefaults.toMap(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
EqualityComparer<TKey> comparer)
Creates a
Map<TKey, TValue> from an
Enumerable<TSource> according to a specified key selector function
and key comparer. |
static <TSource,TKey,TElement> |
EnumerableDefaults.toMap(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector)
Creates a
Map<TKey, TValue> from an
Enumerable<TSource> according to specified key selector and element
selector functions. |
static <TSource,TKey,TElement> |
EnumerableDefaults.toMap(Enumerable<TSource> source,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
EqualityComparer<TKey> comparer)
Creates a
Map<TKey, TValue> from an
Enumerable<TSource> according to a specified key selector function,
a comparer, and an element selector function. |
Queryable<T> |
DefaultQueryable.union(Enumerable<T> source1) |
Enumerable<T> |
DefaultEnumerable.union(Enumerable<T> source1) |
Queryable<T> |
EnumerableQueryable.union(Enumerable<T> source1) |
Queryable<T> |
DefaultQueryable.union(Enumerable<T> source1,
EqualityComparer<T> comparer) |
Enumerable<T> |
DefaultEnumerable.union(Enumerable<T> source1,
EqualityComparer<T> comparer) |
Queryable<T> |
EnumerableQueryable.union(Enumerable<T> source1,
EqualityComparer<T> comparer) |
Enumerable<TSource> |
ExtendedEnumerable.union(Enumerable<TSource> source1)
Produces the set union of two sequences by using
the default equality comparer.
|
Queryable<TSource> |
ExtendedQueryable.union(Enumerable<TSource> source1)
Produces the set union of two sequences by using
the default equality comparer.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.union(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set union of two sequences by using
the default equality comparer.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.union(Enumerable<TSource> source0,
Enumerable<TSource> source1)
Produces the set union of two sequences by using
the default equality comparer.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.union(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set union of two sequences by using a
specified EqualityComparer<TSource>.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.union(Enumerable<TSource> source0,
Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set union of two sequences by using a
specified EqualityComparer<TSource>.
|
Enumerable<TSource> |
ExtendedEnumerable.union(Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set union of two sequences by using a
specified
EqualityComparer<TSource>. |
Queryable<TSource> |
ExtendedQueryable.union(Enumerable<TSource> source1,
EqualityComparer<TSource> comparer)
Produces the set union of two sequences by using a
specified
EqualityComparer<TSource>. |
Queryable<T> |
QueryableFactory.union(Queryable<T> source,
Enumerable<T> source1)
Produces the set union of two sequences by using
the default equality comparer.
|
Queryable<T> |
QueryableRecorder.union(Queryable<T> source,
Enumerable<T> source1) |
static <T> Queryable<T> |
QueryableDefaults.union(Queryable<T> source0,
Enumerable<T> source1)
Produces the set union of two sequences by using
the default equality comparer.
|
Queryable<T> |
QueryableFactory.union(Queryable<T> source,
Enumerable<T> source1,
EqualityComparer<T> comparer)
Produces the set union of two sequences by using a
specified
EqualityComparer<T>. |
Queryable<T> |
QueryableRecorder.union(Queryable<T> source,
Enumerable<T> source1,
EqualityComparer<T> comparer) |
static <T> Queryable<T> |
QueryableDefaults.union(Queryable<T> source0,
Enumerable<T> source1,
EqualityComparer<T> comparer)
Produces the set union of two sequences by using a
specified
EqualityComparer<T>. |
static <TSource> Enumerable<TSource> |
EnumerableDefaults.where(Enumerable<TSource> source,
Predicate1<TSource> predicate)
Filters a sequence of values based on a
predicate.
|
static <TSource> Enumerable<TSource> |
EnumerableDefaults.where(Enumerable<TSource> source,
Predicate2<TSource,Integer> predicate)
Filters a sequence of values based on a
predicate.
|
static <T0,T1,TResult> |
EnumerableDefaults.zip(Enumerable<T0> first,
Enumerable<T1> second,
Function2<T0,T1,TResult> resultSelector)
Applies a specified function to the corresponding
elements of two sequences, producing a sequence of the
results.
|
static <T0,T1,TResult> |
EnumerableDefaults.zip(Enumerable<T0> first,
Enumerable<T1> second,
Function2<T0,T1,TResult> resultSelector)
Applies a specified function to the corresponding
elements of two sequences, producing a sequence of the
results.
|
<T1,TResult> |
ExtendedEnumerable.zip(Enumerable<T1> source1,
Function2<TSource,T1,TResult> resultSelector)
Applies a specified function to the corresponding
elements of two sequences, producing a sequence of the
results.
|
<T1,TResult> |
DefaultEnumerable.zip(Enumerable<T1> source1,
Function2<T,T1,TResult> resultSelector) |
<T1,TResult> |
ExtendedQueryable.zip(Enumerable<T1> source1,
FunctionExpression<Function2<TSource,T1,TResult>> resultSelector)
Merges two sequences by using the specified
predicate function.
|
<T1,TResult> |
DefaultQueryable.zip(Enumerable<T1> source1,
FunctionExpression<Function2<T,T1,TResult>> resultSelector) |
<T1,TResult> |
EnumerableQueryable.zip(Enumerable<T1> source1,
FunctionExpression<Function2<T,T1,TResult>> resultSelector) |
<T1,TResult> |
QueryableFactory.zip(Queryable<T> source,
Enumerable<T1> source1,
FunctionExpression<Function2<T,T1,TResult>> resultSelector)
Merges two sequences by using the specified
predicate function.
|
<T1,TResult> |
QueryableRecorder.zip(Queryable<T> source,
Enumerable<T1> source1,
FunctionExpression<Function2<T,T1,TResult>> resultSelector) |
static <T0,T1,TResult> |
QueryableDefaults.zip(Queryable<T0> source0,
Enumerable<T1> source1,
FunctionExpression<Function2<T0,T1,TResult>> resultSelector)
Merges two sequences by using the specified
predicate function.
|
| Modifier and Type | Method and Description |
|---|---|
<TResult> Enumerable<TResult> |
Lookup.applyResultSelector(Function2<K,Enumerable<V>,TResult> resultSelector)
Applies a transform function to each key and its associated values and
returns the results.
|
<TResult> Enumerable<TResult> |
LookupImpl.applyResultSelector(Function2<K,Enumerable<V>,TResult> resultSelector) |
static <E> Enumerable<E> |
Linq4j.concat(List<Enumerable<E>> enumerableList)
Concatenates two or more
Enumerables to form a composite
enumerable that contains the union of their elements. |
static <TSource,TInner,TResult> |
EnumerableDefaults.correlateBatchJoin(JoinType joinType,
Enumerable<TSource> outer,
Function1<List<TSource>,Enumerable<TInner>> inner,
Function2<TSource,TInner,TResult> resultSelector,
Predicate2<TSource,TInner> predicate,
int batchSize)
Fetches blocks of size
batchSize from outer,
storing each block into a list (outerValues). |
static <TSource,TInner,TResult> |
EnumerableDefaults.correlateJoin(JoinType joinType,
Enumerable<TSource> outer,
Function1<TSource,Enumerable<TInner>> inner,
Function2<TSource,TInner,TResult> resultSelector)
For each row of the
outer enumerable returns the correlated rows
from the inner enumerable. |
<TInner,TResult> |
DefaultEnumerable.correlateJoin(JoinType joinType,
Function1<T,Enumerable<TInner>> inner,
Function2<T,TInner,TResult> resultSelector) |
<TInner,TResult> |
ExtendedEnumerable.correlateJoin(JoinType joinType,
Function1<TSource,Enumerable<TInner>> inner,
Function2<TSource,TInner,TResult> resultSelector)
For each row of the current enumerable returns the correlated rows
from the
inner enumerable (nested loops join). |
static <TSource,TKey,TElement,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,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.
|
static <TSource,TKey,TElement,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
static <TSource,TKey,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,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.
|
static <TSource,TKey,TResult> |
EnumerableDefaults.groupBy(Enumerable<TSource> enumerable,
Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TElement,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,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.
|
<TKey,TElement,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function1<TSource,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,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.
|
<TKey,TResult> |
ExtendedEnumerable.groupBy(Function1<TSource,TKey> keySelector,
Function2<TKey,Enumerable<TSource>,TResult> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TElement,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function1<T,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector) |
<TKey,TElement,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function1<T,TElement> elementSelector,
Function2<TKey,Enumerable<TElement>,TResult> resultSelector,
EqualityComparer<TKey> comparer) |
<TKey,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function2<TKey,Enumerable<T>,TResult> resultSelector) |
<TKey,TResult> |
DefaultEnumerable.groupBy(Function1<T,TKey> keySelector,
Function2<TKey,Enumerable<T>,TResult> elementSelector,
EqualityComparer<TKey> comparer) |
<TKey,TElement,TResult> |
ExtendedQueryable.groupBy(FunctionExpression<Function1<TSource,TKey>> keySelector,
FunctionExpression<Function1<TSource,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,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.
|
<TKey,TElement,TResult> |
ExtendedQueryable.groupBy(FunctionExpression<Function1<TSource,TKey>> keySelector,
FunctionExpression<Function1<TSource,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TElement,TResult> |
DefaultQueryable.groupBy(FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector) |
<TKey,TElement,TResult> |
EnumerableQueryable.groupBy(FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector) |
<TKey,TElement,TResult> |
DefaultQueryable.groupBy(FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TKey,TElement,TResult> |
EnumerableQueryable.groupBy(FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TKey,TElement,TResult> |
QueryableFactory.groupBy(Queryable<T> source,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,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.
|
<TKey,TElement,TResult> |
QueryableRecorder.groupBy(Queryable<T> source,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector) |
static <T,TKey,TElement,TResult> |
QueryableDefaults.groupBy(Queryable<T> queryable,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,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.
|
<TKey,TElement,TResult> |
QueryableFactory.groupBy(Queryable<T> source,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TElement,TResult> |
QueryableRecorder.groupBy(Queryable<T> source,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
static <T,TKey,TElement,TResult> |
QueryableDefaults.groupBy(Queryable<T> queryable,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function1<T,TElement>> elementSelector,
FunctionExpression<Function2<TKey,Enumerable<TElement>,TResult>> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TResult> |
ExtendedQueryable.groupByK(FunctionExpression<Function1<TSource,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<TSource>,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.
|
<TKey,TResult> |
ExtendedQueryable.groupByK(FunctionExpression<Function1<TSource,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<TSource>,TResult>> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TResult> |
DefaultQueryable.groupByK(FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector) |
<TKey,TResult> |
EnumerableQueryable.groupByK(FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector) |
<TKey,TResult> |
DefaultQueryable.groupByK(FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TKey,TResult> |
EnumerableQueryable.groupByK(FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TKey,TResult> |
QueryableFactory.groupByK(Queryable<T> source,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,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.
|
<TKey,TResult> |
QueryableRecorder.groupByK(Queryable<T> source,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector) |
static <T,TKey,TResult> |
QueryableDefaults.groupByK(Queryable<T> queryable,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> elementSelector)
Groups the elements of a sequence according to a
specified key selector function and creates a result value from
each group and its key.
|
static <T,TKey,TResult> |
QueryableDefaults.groupByK(Queryable<T> queryable,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> 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.
|
<TKey,TResult> |
QueryableFactory.groupByK(Queryable<T> source,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector,
EqualityComparer<TKey> 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.
|
<TKey,TResult> |
QueryableRecorder.groupByK(Queryable<T> source,
FunctionExpression<Function1<T,TKey>> keySelector,
FunctionExpression<Function2<TKey,Enumerable<T>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
ExtendedEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector)
Correlates the elements of two sequences based on
equality of keys and groups the results.
|
<TInner,TKey,TResult> |
ExtendedEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
DefaultEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,Enumerable<TInner>,TResult> resultSelector) |
<TInner,TKey,TResult> |
DefaultEnumerable.groupJoin(Enumerable<TInner> inner,
Function1<T,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<T,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
ExtendedQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
ExtendedQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<TSource,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TSource,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
DefaultQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector) |
<TInner,TKey,TResult> |
EnumerableQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector) |
<TInner,TKey,TResult> |
DefaultQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
<TInner,TKey,TResult> |
EnumerableQueryable.groupJoin(Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.groupJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector)
Correlates the elements of two sequences based on
equality of keys and groups the results.
|
static <TSource,TInner,TKey,TResult> |
EnumerableDefaults.groupJoin(Enumerable<TSource> outer,
Enumerable<TInner> inner,
Function1<TSource,TKey> outerKeySelector,
Function1<TInner,TKey> innerKeySelector,
Function2<TSource,Enumerable<TInner>,TResult> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
QueryableFactory.groupJoin(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
QueryableRecorder.groupJoin(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector) |
<TInner,TKey,TResult> |
QueryableFactory.groupJoin(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
<TInner,TKey,TResult> |
QueryableRecorder.groupJoin(Queryable<T> source,
Enumerable<TInner> inner,
FunctionExpression<Function1<T,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<T,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer) |
static <TOuter,TInner,TKey,TResult> |
QueryableDefaults.groupJoin(Queryable<TOuter> outer,
Enumerable<TInner> inner,
FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector)
Correlates the elements of two sequences based on
key equality and groups the results.
|
static <TOuter,TInner,TKey,TResult> |
QueryableDefaults.groupJoin(Queryable<TOuter> outer,
Enumerable<TInner> inner,
FunctionExpression<Function1<TOuter,TKey>> outerKeySelector,
FunctionExpression<Function1<TInner,TKey>> innerKeySelector,
FunctionExpression<Function2<TOuter,Enumerable<TInner>,TResult>> resultSelector,
EqualityComparer<TKey> comparer)
Correlates the elements of two sequences based on
key equality and groups the results.
|
void |
LookupImpl.putAll(Map<? extends K,? extends Enumerable<V>> m) |
static <TSource,TCollection,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function1<TSource,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
static <TSource,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function1<TSource,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource> and flattens the resulting sequences into one
sequence. |
static <TSource,TCollection,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
static <TSource,TResult> |
EnumerableDefaults.selectMany(Enumerable<TSource> source,
Function2<TSource,Integer,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource>, and flattens the resulting sequences into one
sequence. |
<TCollection,TResult> |
DefaultEnumerable.selectMany(Function1<T,Enumerable<TCollection>> collectionSelector,
Function2<T,TCollection,TResult> resultSelector) |
<TResult> Enumerable<TResult> |
DefaultEnumerable.selectMany(Function1<T,Enumerable<TResult>> selector) |
<TCollection,TResult> |
ExtendedEnumerable.selectMany(Function1<TSource,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
<TResult> Enumerable<TResult> |
ExtendedEnumerable.selectMany(Function1<TSource,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource> and flattens the resulting sequences into one
sequence. |
<TCollection,TResult> |
DefaultEnumerable.selectMany(Function2<T,Integer,Enumerable<TCollection>> collectionSelector,
Function2<T,TCollection,TResult> resultSelector) |
<TResult> Enumerable<TResult> |
DefaultEnumerable.selectMany(Function2<T,Integer,Enumerable<TResult>> selector) |
<TCollection,TResult> |
ExtendedEnumerable.selectMany(Function2<TSource,Integer,Enumerable<TCollection>> collectionSelector,
Function2<TSource,TCollection,TResult> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource>, flattens the resulting sequences into one
sequence, and invokes a result selector function on each
element therein. |
<TResult> Enumerable<TResult> |
ExtendedEnumerable.selectMany(Function2<TSource,Integer,Enumerable<TResult>> selector)
Projects each element of a sequence to an
Enumerable<TSource>, and flattens the resulting sequences into one
sequence. |
<TResult> Queryable<TResult> |
DefaultQueryable.selectMany(FunctionExpression<Function1<T,Enumerable<TResult>>> selector) |
<TResult> Queryable<TResult> |
EnumerableQueryable.selectMany(FunctionExpression<Function1<T,Enumerable<TResult>>> selector) |
<TResult> Queryable<TResult> |
ExtendedQueryable.selectMany(FunctionExpression<Function1<TSource,Enumerable<TResult>>> selector)
Projects each element of a sequence to an
Enumerable<TSource> and combines the resulting sequences into one
sequence. |
<TCollection,TResult> |
DefaultQueryable.selectMany(FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector) |
<TCollection,TResult> |
EnumerableQueryable.selectMany(FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector) |
<TCollection,TResult> |
ExtendedQueryable.selectMany(FunctionExpression<Function2<TSource,Integer,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<TSource,TCollection,TResult>> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource> that incorporates the index of the source
element that produced it. |
<TResult> Queryable<TResult> |
QueryableFactory.selectMany(Queryable<T> source,
FunctionExpression<Function1<T,Enumerable<TResult>>> selector)
Projects each element of a sequence to an
Enumerable<T> and combines the resulting sequences into one
sequence. |
<TResult> Queryable<TResult> |
QueryableRecorder.selectMany(Queryable<T> source,
FunctionExpression<Function1<T,Enumerable<TResult>>> selector) |
static <T,TResult> |
QueryableDefaults.selectMany(Queryable<T> source,
FunctionExpression<Function1<T,Enumerable<TResult>>> selector)
Projects each element of a sequence to an
Enumerable<T> and combines the resulting sequences into one
sequence. |
<TCollection,TResult> |
QueryableFactory.selectMany(Queryable<T> source,
FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)
Projects each element of a sequence to an
Enumerable<T> that incorporates the index of the source
element that produced it. |
<TCollection,TResult> |
QueryableRecorder.selectMany(Queryable<T> source,
FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector) |
static <T,TCollection,TResult> |
QueryableDefaults.selectMany(Queryable<T> source,
FunctionExpression<Function2<T,Integer,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)
Projects each element of a sequence to an
Enumerable<T> that incorporates the index of the source
element that produced it. |
<TCollection,TResult> |
DefaultQueryable.selectManyN(FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector) |
<TCollection,TResult> |
EnumerableQueryable.selectManyN(FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector) |
<TCollection,TResult> |
ExtendedQueryable.selectManyN(FunctionExpression<Function1<TSource,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<TSource,TCollection,TResult>> resultSelector)
Projects each element of a sequence to an
Enumerable<TSource> and invokes a result selector function on each
element therein. |
<TResult> Queryable<TResult> |
DefaultQueryable.selectManyN(FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector) |
<TResult> Queryable<TResult> |
EnumerableQueryable.selectManyN(FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector) |
<TResult> Queryable<TResult> |
ExtendedQueryable.selectManyN(FunctionExpression<Function2<TSource,Integer,Enumerable<TResult>>> selector)
Projects each element of a sequence to an
Enumerable<TSource> and combines the resulting sequences into one
sequence. |
<TCollection,TResult> |
QueryableFactory.selectManyN(Queryable<T> source,
FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)
Projects each element of a sequence to an
Enumerable<T> and invokes a result selector function on each
element therein. |
<TCollection,TResult> |
QueryableRecorder.selectManyN(Queryable<T> source,
FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector) |
static <T,TCollection,TResult> |
QueryableDefaults.selectManyN(Queryable<T> source,
FunctionExpression<Function1<T,Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T,TCollection,TResult>> resultSelector)
Projects each element of a sequence to an
Enumerable<T> and invokes a result selector function on each
element therein. |
<TResult> Queryable<TResult> |
QueryableFactory.selectManyN(Queryable<T> source,
FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)
Projects each element of a sequence to an
Enumerable<T> and combines the resulting sequences into one
sequence. |
<TResult> Queryable<TResult> |
QueryableRecorder.selectManyN(Queryable<T> source,
FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector) |
static <T,TResult> |
QueryableDefaults.selectManyN(Queryable<T> source,
FunctionExpression<Function2<T,Integer,Enumerable<TResult>>> selector)
Projects each element of a sequence to an
Enumerable<T> and combines the resulting sequences into one
sequence. |
| Constructor and Description |
|---|
EnumerableOrderedQueryable(Enumerable<T> enumerable,
Class<T> rowType,
QueryProvider provider,
Expression expression) |
EnumerableQueryable(QueryProvider provider,
Class<T> elementType,
Expression expression,
Enumerable<T> enumerable) |
MemoryEnumerable(Enumerable<E> input,
int history,
int future)
Creates a MemoryEnumerable.
|
| Constructor and Description |
|---|
CompositeEnumerable(List<Enumerable<E>> enumerableList) |
Copyright © 2012–2021 The Apache Software Foundation. All rights reserved.