@Override public void onCopy(RelNode rel, RelNode newRel) { onCopyHook.apply(rel, newRel); }
@Override public void onCopy(RelNode rel, RelNode newRel) { onCopyHook.apply(rel, newRel); }
public TResult next() { final Map.Entry<TKey, TAccumulate> entry = iterator.next(); return resultSelector.apply(entry.getKey(), entry.getValue()); }
public TResult current() { final List<Object> list = cartesians.current(); @SuppressWarnings("unchecked") final TSource left = (TSource) list.get(0); @SuppressWarnings("unchecked") final TInner right = (TInner) list.get(1); return resultSelector.apply(left, right); }
public Function2<TKey, LazySource<TSource>, TResult> resultSelector( Function2<TKey, TOrigAccumulate, TResult> resultSelector) { return (groupByKey, lazySource) -> { final TOrigAccumulate accumulator = accumulatorInitializer.apply(); for (SourceSorter<TOrigAccumulate, TSource, TSortKey> acc : sourceSorters) { acc.sortAndAccumulate(lazySource, accumulator); } return resultSelector.apply(groupByKey, accumulator); }; }
private Predicate2<DataAccessor, DataAccessor> predicate( Function2<DataAccessor, DataAccessor, DataAccessor> projection, StatementEvaluationContext context) { return (DataAccessor v0, DataAccessor v1) -> { DataAccessor currentRow = projection.apply(v0, v1); return SQLRecordPredicateFunctions.toBoolean(condition.evaluate(currentRow, context)); }; }
public void sortAndAccumulate(Iterable<TSource> sourceIterable, TAccumulate accumulator) { List<TSource> sorted = Linq4j.asEnumerable(sourceIterable) .orderBy(keySelector, comparator) .toList(); TAccumulate accumulator1 = accumulator; for (TSource source : sorted) { accumulator1 = accumulatorAdder.apply(accumulator1, source); } } }
/** * Groups the elements of a sequence according to a * specified key selector function and creates a result value from * each group and its key. */ public static <TSource, TKey, TResult> Enumerable<TResult> groupBy( Enumerable<TSource> enumerable, Function1<TSource, TKey> keySelector, final Function2<TKey, Enumerable<TSource>, TResult> resultSelector) { return enumerable.toLookup(keySelector) .select(group -> resultSelector.apply(group.getKey(), group)); }
/** * Groups the elements of a sequence according to a * specified key selector function and creates a result value from * each group and its key. Key values are compared by using a * specified comparer, and the elements of each group are * projected by using a specified function. */ public static <TSource, TKey, TElement, TResult> Enumerable<TResult> groupBy( Enumerable<TSource> enumerable, Function1<TSource, TKey> keySelector, Function1<TSource, TElement> elementSelector, final Function2<TKey, Enumerable<TElement>, TResult> resultSelector, EqualityComparer<TKey> comparer) { return enumerable.toLookup(keySelector, elementSelector, comparer) .select(group -> resultSelector.apply(group.getKey(), group)); }
/** * Groups the elements of a sequence according to a * specified key selector function and creates a result value from * each group and its key. The keys are compared by using a * specified comparer. */ public static <TSource, TKey, TResult> Enumerable<TResult> groupBy( Enumerable<TSource> enumerable, Function1<TSource, TKey> keySelector, final Function2<TKey, Enumerable<TSource>, TResult> resultSelector, EqualityComparer<TKey> comparer) { return enumerable.toLookup(keySelector, comparer) .select(group -> resultSelector.apply(group.getKey(), group)); }
/** * Groups the elements of a sequence according to a * specified key selector function and creates a result value from * each group and its key. The elements of each group are * projected by using a specified function. */ public static <TSource, TKey, TElement, TResult> Enumerable<TResult> groupBy( Enumerable<TSource> enumerable, Function1<TSource, TKey> keySelector, Function1<TSource, TElement> elementSelector, final Function2<TKey, Enumerable<TElement>, TResult> resultSelector) { return enumerable.toLookup(keySelector, elementSelector) .select(group -> resultSelector.apply(group.getKey(), group)); }
/** * Applies an accumulator function over a sequence. */ public static <TSource> TSource aggregate(Enumerable<TSource> source, Function2<TSource, TSource, TSource> func) { TSource result = null; try (Enumerator<TSource> os = source.enumerator()) { while (os.moveNext()) { TSource o = os.current(); result = func.apply(result, o); } return result; } }
private static <TSource, TKey, TAccumulate, TResult> Enumerable<TResult> groupBy_( final Map<TKey, TAccumulate> map, Enumerable<TSource> enumerable, Function1<TSource, TKey> keySelector, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate, TSource, TAccumulate> accumulatorAdder, final Function2<TKey, TAccumulate, TResult> resultSelector) { try (Enumerator<TSource> os = enumerable.enumerator()) { while (os.moveNext()) { TSource o = os.current(); TKey key = keySelector.apply(o); TAccumulate accumulator = map.get(key); if (accumulator == null) { accumulator = accumulatorInitializer.apply(); accumulator = accumulatorAdder.apply(accumulator, o); map.put(key, accumulator); } else { TAccumulate accumulator0 = accumulator; accumulator = accumulatorAdder.apply(accumulator, o); if (accumulator != accumulator0) { map.put(key, accumulator); } } } } return new LookupResultEnumerable<>(map, resultSelector); }
private static <TSource, TKey, TAccumulate, TResult> Enumerable<TResult> groupByMultiple_( final Map<TKey, TAccumulate> map, Enumerable<TSource> enumerable, List<Function1<TSource, TKey>> keySelectors, Function0<TAccumulate> accumulatorInitializer, Function2<TAccumulate, TSource, TAccumulate> accumulatorAdder, final Function2<TKey, TAccumulate, TResult> resultSelector) { try (Enumerator<TSource> os = enumerable.enumerator()) { while (os.moveNext()) { for (Function1<TSource, TKey> keySelector : keySelectors) { TSource o = os.current(); TKey key = keySelector.apply(o); TAccumulate accumulator = map.get(key); if (accumulator == null) { accumulator = accumulatorInitializer.apply(); accumulator = accumulatorAdder.apply(accumulator, o); map.put(key, accumulator); } else { TAccumulate accumulator0 = accumulator; accumulator = accumulatorAdder.apply(accumulator, o); if (accumulator != accumulator0) { map.put(key, accumulator); } } } } } return new LookupResultEnumerable<>(map, resultSelector); }
/** * Applies an accumulator function over a * sequence. The specified seed value is used as the initial * accumulator value. */ public static <TSource, TAccumulate> TAccumulate aggregate( Enumerable<TSource> source, TAccumulate seed, Function2<TAccumulate, TSource, TAccumulate> func) { TAccumulate result = seed; try (Enumerator<TSource> os = source.enumerator()) { while (os.moveNext()) { TSource o = os.current(); result = func.apply(result, o); } return result; } }
/** * Applies an accumulator function over a * sequence. The specified seed value is used as the initial * accumulator value, and the specified function is used to select * the result value. */ public static <TSource, TAccumulate, TResult> TResult aggregate( Enumerable<TSource> source, TAccumulate seed, Function2<TAccumulate, TSource, TAccumulate> func, Function1<TAccumulate, TResult> selector) { TAccumulate accumulate = seed; try (Enumerator<TSource> os = source.enumerator()) { while (os.moveNext()) { TSource o = os.current(); accumulate = func.apply(accumulate, o); } return selector.apply(accumulate); } }