GroupBy2.java

package fr.openwide.core.jpa.querydsl.group;

import java.util.Comparator;

import org.javatuples.Triplet;

import com.google.common.collect.RowSortedTable;
import com.google.common.collect.Table;
import com.querydsl.core.ResultTransformer;
import com.querydsl.core.group.AbstractGroupExpression;
import com.querydsl.core.group.GroupExpression;
import com.querydsl.core.types.Expression;

public final class GroupBy2 {

	private GroupBy2() {
	}
	
	public static <T> ResultTransformer<T> transformer(GroupExpression<?, T> groupExpression) {
		return new GroupExpressionResultTransformer<>(groupExpression);
	}

	/**
	 * @see #table(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C, V> AbstractGroupExpression<Triplet<R, C, V>, Table<R, C, V>> table(
			Expression<R> row, Expression<C> column, Expression<V> value) {
		return GTable.createLinked(QTriplet.create(row, column, value));
	}

	/**
	 * @see #table(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C, V, R2> AbstractGroupExpression<Triplet<R, C, V>, Table<R2, C, V>> table(
			GroupExpression<R, R2> row, Expression<C> column, Expression<V> value) {
		return table(row, new GOne<C>(column), new GOne<V>(value));
	}

	/**
	 * @see #table(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C, V, C2> AbstractGroupExpression<Triplet<R, C, V>, Table<R, C2, V>> table(
			Expression<R> row, GroupExpression<C, C2> column, Expression<V> value) {
		return table(new GOne<R>(row), column, new GOne<V>(value));
	}

	/**
	 * @see #table(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C, V, R2, C2> AbstractGroupExpression<Triplet<R, C, V>, Table<R2, C2, V>> table(
			GroupExpression<R, R2> row, GroupExpression<C, C2> column, Expression<V> value) {
		return table(row, column, new GOne<V>(value));
	}

	/**
	 * @see #table(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C, V, V2> AbstractGroupExpression<Triplet<R, C, V>, Table<R, C, V2>> table(
			Expression<R> row, Expression<C> column, GroupExpression<V, V2> value) {
		return table(new GOne<R>(row), new GOne<C>(column), value);
	}

	/**
	 * @see #table(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C, V, R2, V2> AbstractGroupExpression<Triplet<R, C, V>, Table<R2, C, V2>> table(
			GroupExpression<R, R2> row, Expression<C> column, GroupExpression<V, V2> value) {
		return table(row, new GOne<C>(column), value);
	}

	/**
	 * @see #table(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C, V, C2, V2> AbstractGroupExpression<Triplet<R, C, V>, Table<R, C2, V2>> table(
			Expression<R> row, GroupExpression<C, C2> column, GroupExpression<V, V2> value) {
		return table(new GOne<R>(row), column, value);
	}

	/**
	 * Create a new aggregating table expression using a backing HashBasedTable
	 *
	 * @param row
	 *            row for the table entries
	 * @param column
	 *            column for the table entries
	 * @param value
	 *            value for the table entries
	 * @return wrapper expression
	 */
	public static <R, C, V, R2, C2, V2> AbstractGroupExpression<Triplet<R, C, V>, Table<R2, C2, V2>> table(
			GroupExpression<R, R2> row, GroupExpression<C, C2> column, GroupExpression<V, V2> value) {
		return new GTable.Mixin<R, C, V, R2, C2, V2, Table<R2, C2, V2>>(
				row, column, value,
				GTable.createLinked(QTriplet.create(row, column, value))
		);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R extends Comparable<? super R>, C extends Comparable<? super C>, V>
			AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R, C, V>> sortedTable(
			Expression<R> row, Expression<C> column, Expression<V> value) {
		return GTable.createSorted(QTriplet.create(row, column, value));
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C extends Comparable<? super C>, V, R2 extends Comparable<? super R2>>
			AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R2, C, V>> sortedTable(
			GroupExpression<R, R2> row, Expression<C> column, Expression<V> value) {
		return sortedTable(row, new GOne<C>(column), new GOne<V>(value));
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R extends Comparable<? super R>, C, V, C2 extends Comparable<? super C2>>
			AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R, C2, V>> sortedTable(
			Expression<R> row, GroupExpression<C, C2> column, Expression<V> value) {
		return sortedTable(new GOne<R>(row), column, new GOne<V>(value));
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C, V, R2 extends Comparable<? super R2>, C2 extends Comparable<? super C2>>
			AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R2, C2, V>> sortedTable(
			GroupExpression<R, R2> row, GroupExpression<C, C2> column, Expression<V> value) {
		return sortedTable(row, column, new GOne<V>(value));
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R extends Comparable<? super R>, C extends Comparable<? super C>, V, V2>
			AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R, C, V2>> sortedTable(
			Expression<R> row, Expression<C> column, GroupExpression<V, V2> value) {
		return sortedTable(new GOne<R>(row), new GOne<C>(column), value);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R, C extends Comparable<? super C>, V, R2 extends Comparable<? super R2>, V2>
			AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R2, C, V2>> sortedTable(
			GroupExpression<R, R2> row, Expression<C> column, GroupExpression<V, V2> value) {
		return sortedTable(row, new GOne<C>(column), value);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression)
	 */
	public static <R extends Comparable<? super R>, C, V, C2 extends Comparable<? super C2>, V2>
			AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R, C2, V2>> sortedTable(
			Expression<R> row, GroupExpression<C, C2> column, GroupExpression<V, V2> value) {
		return sortedTable(new GOne<R>(row), column, value);
	}

	/**
	 * Create a new aggregating table expression using a backing HashBasedRowSortedTable
	 *
	 * @param row
	 *            row for the sortedTable entries
	 * @param column
	 *            column for the sortedTable entries
	 * @param value
	 *            value for the sortedTable entries
	 * @return wrapper expression
	 */
	public static <R, C, V, R2 extends Comparable<? super R2>, C2 extends Comparable<? super C2>, V2>
			AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R2, C2, V2>> sortedTable(
			GroupExpression<R, R2> row, GroupExpression<C, C2> column, GroupExpression<V, V2> value) {
		return new GTable.Mixin<R, C, V, R2, C2, V2, RowSortedTable<R2, C2, V2>>(
				row, column, value,
				GTable.createSorted(QTriplet.create(row, column, value))
		);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression, Comparator, Comparator)
	 */
	public static <R, C, V> AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R, C, V>> sortedTable(
			Expression<R> row, Expression<C> column, Expression<V> value,
			Comparator<? super R> rowComparator, Comparator<? super C> columnComparator) {
		return GTable.createSorted(QTriplet.create(row, column, value), rowComparator, columnComparator);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression, Comparator, Comparator)
	 */
	public static <R, C, V, R2> AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R2, C, V>> sortedTable(
			GroupExpression<R, R2> row, Expression<C> column, Expression<V> value,
			Comparator<? super R2> rowComparator, Comparator<? super C> columnComparator) {
		return sortedTable(row, new GOne<C>(column), new GOne<V>(value),
				rowComparator, columnComparator);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression, Comparator, Comparator)
	 */
	public static <R, C, V, C2> AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R, C2, V>> sortedTable(
			Expression<R> row, GroupExpression<C, C2> column, Expression<V> value,
			Comparator<? super R> rowComparator, Comparator<? super C2> columnComparator) {
		return sortedTable(new GOne<R>(row), column, new GOne<V>(value),
				rowComparator, columnComparator);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression, Comparator, Comparator)
	 */
	public static <R, C, V, R2, C2> AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R2, C2, V>> sortedTable(
			GroupExpression<R, R2> row, GroupExpression<C, C2> column, Expression<V> value,
			Comparator<? super R2> rowComparator, Comparator<? super C2> columnComparator) {
		return sortedTable(row, column, new GOne<V>(value),
				rowComparator, columnComparator);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression, Comparator, Comparator)
	 */
	public static <R, C, V, V2> AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R, C, V2>> sortedTable(
			Expression<R> row, Expression<C> column, GroupExpression<V, V2> value,
			Comparator<? super R> rowComparator, Comparator<? super C> columnComparator) {
		return sortedTable(new GOne<R>(row), new GOne<C>(column), value,
				rowComparator, columnComparator);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression, Comparator, Comparator)
	 */
	public static <R, C, V, R2, V2> AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R2, C, V2>> sortedTable(
			GroupExpression<R, R2> row, Expression<C> column, GroupExpression<V, V2> value,
			Comparator<? super R2> rowComparator, Comparator<? super C> columnComparator) {
		return sortedTable(row, new GOne<C>(column), value,
				rowComparator, columnComparator);
	}

	/**
	 * @see #sortedTable(GroupExpression, GroupExpression, GroupExpression, Comparator, Comparator)
	 */
	public static <R, C, V, C2, V2> AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R, C2, V2>> sortedTable(
			Expression<R> row, GroupExpression<C, C2> column, GroupExpression<V, V2> value,
			Comparator<? super R> rowComparator, Comparator<? super C2> columnComparator) {
		return sortedTable(new GOne<R>(row), column, value,
				rowComparator, columnComparator);
	}

	/**
	 * Create a new aggregating table expression using a backing HashBasedRowSortedTable
	 *
	 * @param row
	 *            row for the sortedTable entries
	 * @param column
	 *            column for the sortedTable entries
	 * @param value
	 *            value for the sortedTable entries
	 * @return wrapper expression
	 */
	public static <R, C, V, R2, C2, V2> AbstractGroupExpression<Triplet<R, C, V>, RowSortedTable<R2, C2, V2>> sortedTable(
			GroupExpression<R, R2> row, GroupExpression<C, C2> column, GroupExpression<V, V2> value,
			Comparator<? super R2> rowComparator, Comparator<? super C2> columnComparator) {
		return new GTable.Mixin<R, C, V, R2, C2, V2, RowSortedTable<R2, C2, V2>>(
				row, column, value,
				GTable.createSorted(QTriplet.create(row, column, value), rowComparator, columnComparator)
		);
	}

}