public <TInner, TKey, TResult> Queryable<TResult> join(
Enumerable<TInner> inner,
FunctionExpression<Function1<T, TKey>> outerKeySelector,
FunctionExpression<Function1<TInner, TKey>> innerKeySelector,
FunctionExpression<Function2<T, TInner, TResult>> resultSelector) {
return factory.join(getThis(), inner, outerKeySelector, innerKeySelector, resultSelector);
}
public <TKey, TElement, TResult> Queryable<TResult> groupBy(
FunctionExpression<Function1<T, TKey>> keySelector,
FunctionExpression<Function1<T, TElement>> elementSelector,
FunctionExpression<Function2<TKey, Enumerable<TElement>, TResult>> resultSelector,
EqualityComparer<TKey> comparer) {
return factory.groupBy(getThis(), keySelector, elementSelector, resultSelector, comparer);
}
public <TInner, TKey, TResult> Queryable<TResult> groupJoin(
Enumerable<TInner> inner,
FunctionExpression<Function1<T, TKey>> outerKeySelector,
FunctionExpression<Function1<TInner, TKey>> innerKeySelector,
FunctionExpression<Function2<T, Enumerable<TInner>, TResult>> resultSelector,
EqualityComparer<TKey> comparer) {
return factory.groupJoin(
getThis(), inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
}
@Override
public Queryable<T> except(Enumerable<T> enumerable1) {
return factory.except(getThis(), enumerable1);
}
@Override
public Queryable<T> intersect(Enumerable<T> source1, EqualityComparer<T> comparer) {
return factory.intersect(getThis(), source1, comparer);
}
@Override
public Queryable<T> union(Enumerable<T> source1, EqualityComparer<T> comparer) {
return factory.union(getThis(), source1, comparer);
}
public <T1, TResult> Queryable<TResult> zip(
Enumerable<T1> source1, FunctionExpression<Function2<T, T1, TResult>> resultSelector) {
return factory.zip(getThis(), source1, resultSelector);
}
public Queryable<T> where(FunctionExpression<? extends Predicate1<T>> predicate) {
return factory.where(getThis(), predicate);
}
public <TKey extends Comparable<TKey>> OrderedQueryable<T> thenBy(
FunctionExpression<Function1<T, TKey>> keySelector) {
return factory.thenBy(getThisOrderedQueryable(), keySelector);
}
public double sumDouble(FunctionExpression<DoubleFunction1<T>> selector) {
return factory.sumDouble(getThis(), selector);
}
public BigDecimal sumNullableBigDecimal(
FunctionExpression<NullableBigDecimalFunction1<T>> selector) {
return factory.sumNullableBigDecimal(getThis(), selector);
}
public T singleOrDefault(FunctionExpression<Predicate1<T>> predicate) {
return factory.singleOrDefault(getThis(), predicate);
}
public <TCollection, TResult> Queryable<TResult> selectManyN(
FunctionExpression<Function1<T, Enumerable<TCollection>>> collectionSelector,
FunctionExpression<Function2<T, TCollection, TResult>> resultSelector) {
return factory.selectManyN(getThis(), collectionSelector, resultSelector);
}
public <TResult> Queryable<TResult> selectManyN(
FunctionExpression<Function2<T, Integer, Enumerable<TResult>>> selector) {
return factory.selectManyN(getThis(), selector);
}
public <TResult> Queryable<TResult> select(FunctionExpression<Function1<T, TResult>> selector) {
return factory.select(getThis(), selector);
}
public Queryable<T> takeWhile(FunctionExpression<Predicate1<T>> predicate) {
return factory.takeWhile(getThis(), predicate);
}
public Queryable<T> takeWhileN(FunctionExpression<Predicate2<T, Integer>> predicate) {
return factory.takeWhileN(getThis(), predicate);
}
public Double sumNullableDouble(FunctionExpression<NullableDoubleFunction1<T>> selector) {
return factory.sumNullableDouble(getThis(), selector);
}
public <TKey> OrderedQueryable<T> thenByDescending(
FunctionExpression<Function1<T, TKey>> keySelector, Comparator<TKey> comparator) {
return factory.thenBy(getThisOrderedQueryable(), keySelector, comparator);
}
public int sumInteger(FunctionExpression<IntegerFunction1<T>> selector) {
return factory.sumInteger(getThis(), selector);
}
public Queryable<T> whereN(FunctionExpression<? extends Predicate2<T, Integer>> predicate) {
return factory.whereN(getThis(), predicate);
}
public Integer sumNullableInteger(FunctionExpression<NullableIntegerFunction1<T>> selector) {
return factory.sumNullableInteger(getThis(), selector);
}
@Override
public Queryable<T> union(Enumerable<T> source1) {
return factory.union(getThis(), source1);
}
public long sumLong(FunctionExpression<LongFunction1<T>> selector) {
return factory.sumLong(getThis(), selector);
}
@Override
public Queryable<T> intersect(Enumerable<T> source1) {
return factory.intersect(getThis(), source1);
}
public Long sumNullableLong(FunctionExpression<NullableLongFunction1<T>> selector) {
return factory.sumNullableLong(getThis(), selector);
}
@Override
public Queryable<T> except(Enumerable<T> enumerable1, EqualityComparer<T> comparer) {
return factory.except(getThis(), enumerable1, comparer);
}
public float sumFloat(FunctionExpression<FloatFunction1<T>> selector) {
return factory.sumFloat(getThis(), selector);
}
@Override
public Queryable<T> take(int count) {
return factory.take(getThis(), count);
}
public Float sumNullableFloat(FunctionExpression<NullableFloatFunction1<T>> selector) {
return factory.sumNullableFloat(getThis(), selector);
}