/** * Create a new aggregating map expression using a backing TreeMap * * @param key * @param value * @return */ public static <K extends Comparable<? super K>, V, T extends Comparable<? super T>, U> AbstractGroupExpression<Pair<K, V>, SortedMap<T, U>> sortedMap(GroupExpression<K, T> key, GroupExpression<V, U> value) { return new GMap.Mixin<K, V, T, U, SortedMap<T, U>>(key, value, GMap.createSorted(QPair.create(key, value))); }
@SuppressWarnings({ "rawtypes", "unchecked" }) public Mixin(GroupExpression<K, T> keyExpression, GroupExpression<V, U> valueExpression, AbstractGroupExpression<Pair<T, U>, R> mixin) { super((Class) mixin.getType(), QPair.create(keyExpression.getExpression(), valueExpression.getExpression())); this.keyExpression = keyExpression; this.valueExpression = valueExpression; this.mixin = mixin; }
/** * Create a new aggregating map expression using a backing TreeMap using the given comparator * * @param key * @param value * @param comparator * @return */ public static <K, V> AbstractGroupExpression<Pair<K, V>, SortedMap<K, V>> sortedMap(Expression<K> key, Expression<V> value, Comparator<? super K> comparator) { return GMap.createSorted(QPair.create(key, value), comparator); }
/** * Create a new aggregating map expression using a backing LinkedHashMap * * @param key * @param value * @return */ public static <K, V, T, U> AbstractGroupExpression<Pair<K, V>, Map<T, U>> map(GroupExpression<K, T> key, GroupExpression<V, U> value) { return new GMap.Mixin<K, V, T, U, Map<T, U>>(key, value, GMap.createLinked(QPair.create(key, value))); }
/** * Create a new aggregating map expression using a backing TreeMap * * @param key * @param value * @return */ public static <K extends Comparable<? super K>, V, U> AbstractGroupExpression<Pair<K, V>, SortedMap<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value) { return sortedMap(new GOne<K>(key), value); }
/** * Create a new aggregating set expression using a backing TreeSet * * @param groupExpression * @return */ public static <E, F extends Comparable<? super F>> GroupExpression<E, SortedSet<F>> sortedSet(GroupExpression<E, F> groupExpression) { return new MixinGroupExpression<E, F, SortedSet<F>>(groupExpression, GSet.createSorted(groupExpression)); }
@SuppressWarnings({ "unchecked", "rawtypes" }) public MixinGroupExpression(GroupExpression<E, F> groupExpression, GroupExpression<F, R> mixin) { super((Class) mixin.getType(), groupExpression.getExpression()); this.mixin = mixin; this.groupExpression = groupExpression; }
public static <E, F> GroupExpression<E, Set<F>> set(GroupExpression<E, F> groupExpression) { return new MixinGroupExpression<E, F, Set<F>>(groupExpression, GSet.createLinked(groupExpression)); }
/** * Create a new aggregating set expression using a backing TreeSet * * @param expression * @return */ public static <E extends Comparable<? super E>> AbstractGroupExpression<E, SortedSet<E>> sortedSet(Expression<E> expression) { return GSet.createSorted(expression); }
/** * Create a new GroupByBuilder for the given key expression * * @param key * @return */ public static <K> GroupByBuilder<K> groupBy(Expression<K> key) { return new GroupByBuilder<K>(key); }
/** * Create a new aggregating sum expression * * @param expression * @return */ public static <E extends Number> AbstractGroupExpression<E, E> sum(Expression<E> expression) { return new GSum<E>(expression); }
/** * Create a new aggregating map expression using a backing TreeMap using the given comparator * * @param key * @param value * @param comparator * @return */ public static <K, V, T, U> AbstractGroupExpression<Pair<K, V>, SortedMap<T, U>> sortedMap(GroupExpression<K, T> key, GroupExpression<V, U> value, Comparator<? super T> comparator) { return new GMap.Mixin<K, V, T, U, SortedMap<T, U>>(key, value, GMap.createSorted(QPair.create(key, value), comparator)); }
/** * Create a new aggregating map expression using a backing TreeMap * * @param key * @param value * @return */ public static <K extends Comparable<? super K>, V> AbstractGroupExpression<Pair<K, V>, SortedMap<K, V>> sortedMap(Expression<K> key, Expression<V> value) { return GMap.createSorted(QPair.create(key, value)); }
/** * Create a new aggregating map expression using a backing TreeMap using the given comparator * * @param key * @param value * @param comparator * @return */ public static <K, V, U> AbstractGroupExpression<Pair<K, V>, SortedMap<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value, Comparator<? super U> comparator) { return sortedMap(new GOne<K>(key), value, comparator); }
/** * Create a new aggregating set expression using a backing TreeSet using the given comparator * * @param groupExpression * @param comparator * @return */ public static <E, F> GroupExpression<E, SortedSet<F>> sortedSet(GroupExpression<E, F> groupExpression, Comparator<? super F> comparator) { return new MixinGroupExpression<E, F, SortedSet<F>>(groupExpression, GSet.createSorted(groupExpression, comparator)); }
/** * Create a new aggregating set expression using a backing TreeSet using the given comparator * * @param expression * @param comparator * @return */ public static <E> AbstractGroupExpression<E, SortedSet<E>> sortedSet(Expression<E> expression, Comparator<? super E> comparator) { return GSet.createSorted(expression, comparator); }
/** * Create a new aggregating map expression using a backing TreeMap * * @param key * @param value * @return */ public static <K extends Comparable<? super K>, V, T extends Comparable<? super T>> AbstractGroupExpression<Pair<K, V>, SortedMap<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value) { return sortedMap(key, new GOne<V>(value)); }
/** * Create a new aggregating map expression using a backing TreeMap using the given comparator * * @param key * @param value * @param comparator * @return */ public static <K, V, T> AbstractGroupExpression<Pair<K, V>, SortedMap<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value, Comparator<? super K> comparator) { return sortedMap(key, new GOne<V>(value), comparator); }