From 9a6fd4e75a8262ece2810e27fc47acb7787efa7c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timo=20Westk=C3=A4mper?= <timo.westkamper@gmail.com>
Date: Fri, 6 Feb 2015 18:46:34 +0200
Subject: [PATCH] Improve generic type constraints Add sorted* variants with
 comparators Remove brdige annotations

---
 .../java/com/querydsl/core/group/GMap.java    | 16 +++++---
 .../java/com/querydsl/core/group/GSet.java    | 12 +++++-
 .../java/com/querydsl/core/group/GroupBy.java | 40 +++++++++++++++----
 3 files changed, 55 insertions(+), 13 deletions(-)

diff --git a/querydsl-core/src/main/java/com/querydsl/core/group/GMap.java b/querydsl-core/src/main/java/com/querydsl/core/group/GMap.java
index d8faf7f9e..787d31e4b 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/group/GMap.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/group/GMap.java
@@ -13,10 +13,7 @@
  */
 package com.querydsl.core.group;
 
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.TreeMap;
+import java.util.*;
 
 import com.mysema.commons.lang.Pair;
 
@@ -43,7 +40,7 @@ abstract class GMap<K, V> extends AbstractGroupExpression<Pair<K, V>, Map<K, V>>
         };
     }
 
-    public static <T, U> GMap<T, U> createSorted(QPair<T, U> expr) {
+    public static <T extends Comparable<? super T>, U> GMap<T, U> createSorted(QPair<T, U> expr) {
         return new GMap<T, U>(expr) {
             @Override
             protected Map<T, U> createMap() {
@@ -52,6 +49,15 @@ abstract class GMap<K, V> extends AbstractGroupExpression<Pair<K, V>, Map<K, V>>
         };
     }
 
+    public static <T, U> GMap<T, U> createSorted(QPair<T, U> expr, final Comparator<? super T> comparator) {
+        return new GMap<T, U>(expr) {
+            @Override
+            protected Map<T, U> createMap() {
+                return new TreeMap<T, U>(comparator);
+            }
+        };
+    }
+
     @Override
     public GroupCollector<Pair<K,V>, Map<K, V>> createGroupCollector() {
         return new GroupCollector<Pair<K,V>, Map<K, V>>() {
diff --git a/querydsl-core/src/main/java/com/querydsl/core/group/GSet.java b/querydsl-core/src/main/java/com/querydsl/core/group/GSet.java
index 4db50221a..57035dafd 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/group/GSet.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/group/GSet.java
@@ -13,6 +13,7 @@
  */
 package com.querydsl.core.group;
 
+import java.util.Comparator;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.TreeSet;
@@ -37,7 +38,7 @@ abstract class GSet<T> extends AbstractGroupExpression<T, Set<T>> {
         };
     }
 
-    public static <U> GSet<U> createSorted(Expression<U> expr) {
+    public static <U extends Comparable<? super U>> GSet<U> createSorted(Expression<U> expr) {
         return new GSet<U>(expr) {
             @Override
             protected Set<U> createSet() {
@@ -46,6 +47,15 @@ abstract class GSet<T> extends AbstractGroupExpression<T, Set<T>> {
         };
     }
 
+    public static <U> GSet<U> createSorted(Expression<U> expr, final Comparator<? super U> comparator) {
+        return new GSet<U>(expr) {
+            @Override
+            protected Set<U> createSet() {
+                return new TreeSet<U>(comparator);
+            }
+        };
+    }
+
     public GSet(Expression<T> expr) {
         super(Set.class, expr);
     }
diff --git a/querydsl-core/src/main/java/com/querydsl/core/group/GroupBy.java b/querydsl-core/src/main/java/com/querydsl/core/group/GroupBy.java
index 988345ebd..523efb13b 100644
--- a/querydsl-core/src/main/java/com/querydsl/core/group/GroupBy.java
+++ b/querydsl-core/src/main/java/com/querydsl/core/group/GroupBy.java
@@ -13,6 +13,7 @@
  */
 package com.querydsl.core.group;
 
+import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -125,14 +126,23 @@ public final class GroupBy {
      * @param expression
      * @return
      */
-    public static <E> AbstractGroupExpression<E, Set<E>> sortedSet(Expression<E> expression) {
+    public static <E extends Comparable<? super E>> AbstractGroupExpression<E, Set<E>> sortedSet(Expression<E> expression) {
         return GSet.createSorted(expression);
     }
 
-    public static <E, F> GroupExpression<E, Set<F>> sortedSet(GroupExpression<E, F> groupExpression) {
+    public static <E, F extends Comparable<? super F>> GroupExpression<E, Set<F>> sortedSet(GroupExpression<E, F> groupExpression) {
         return new MixinGroupExpression<E, F, Set<F>>(groupExpression, GSet.createSorted(groupExpression));
     }
 
+    public static <E> AbstractGroupExpression<E, Set<E>> sortedSet(Expression<E> expression, Comparator<? super E> comparator) {
+        return GSet.createSorted(expression, comparator);
+    }
+
+    public static <E, F> GroupExpression<E, Set<F>> sortedSet(GroupExpression<E, F> groupExpression, Comparator<? super F> comparator) {
+        return new MixinGroupExpression<E, F, Set<F>>(groupExpression, GSet.createSorted(groupExpression, comparator));
+    }
+
+
     /**
      * Create a new aggregating map expression using a backing LinkedHashMap
      *
@@ -164,23 +174,39 @@ public final class GroupBy {
      * @param value
      * @return
      */
-    @WithBridgeMethods(value=Expression.class,castRequired=true)
-    public static <K, V> AbstractGroupExpression<Pair<K, V>,Map<K, V>> sortedMap(Expression<K> key, Expression<V> value) {
+    public static <K extends Comparable<? super K>, V> AbstractGroupExpression<Pair<K, V>,Map<K, V>> sortedMap(Expression<K> key, Expression<V> value) {
         return GMap.createSorted(QPair.create(key, value));
     }
 
-    public static <K, V, T> AbstractGroupExpression<Pair<K, V>, Map<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value) {
+    public static <K extends Comparable<? super K>, V, T extends Comparable<? super T>> AbstractGroupExpression<Pair<K, V>, Map<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value) {
         return sortedMap(key, new GOne<V>(value));
     }
 
-    public static <K, V, U> AbstractGroupExpression<Pair<K, V>, Map<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value) {
+    public static <K extends Comparable<? super K>, V, U> AbstractGroupExpression<Pair<K, V>, Map<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value) {
         return sortedMap(new GOne<K>(key), value);
     }
 
-    public static <K, V, T, U> AbstractGroupExpression<Pair<K, V>, Map<T, U>> sortedMap(GroupExpression<K, T> key, GroupExpression<V, U> value) {
+    public static <K extends Comparable<? super K>, V, T extends Comparable<? super T>, U> AbstractGroupExpression<Pair<K, V>, Map<T, U>> sortedMap(GroupExpression<K, T> key, GroupExpression<V, U> value) {
         return new GMap.Mixin<K, V, T, U, Map<T, U>>(key, value, GMap.createSorted(QPair.create(key, value)));
     }
 
+    public static <K, V> AbstractGroupExpression<Pair<K, V>,Map<K, V>> sortedMap(Expression<K> key, Expression<V> value, Comparator<? super K> comparator) {
+        return GMap.createSorted(QPair.create(key, value), comparator);
+    }
+
+    public static <K, V, T> AbstractGroupExpression<Pair<K, V>, Map<T, V>> sortedMap(GroupExpression<K, T> key, Expression<V> value, Comparator<? super K> comparator) {
+        return sortedMap(key, new GOne<V>(value), comparator);
+    }
+
+    public static <K, V, U> AbstractGroupExpression<Pair<K, V>, Map<K, U>> sortedMap(Expression<K> key, GroupExpression<V, U> value, Comparator<? super U> comparator) {
+        return sortedMap(new GOne<K>(key), value, comparator);
+    }
+
+    public static <K, V, T, U> AbstractGroupExpression<Pair<K, V>, Map<T, U>> sortedMap(GroupExpression<K, T> key, GroupExpression<V, U> value, Comparator<? super T> comparator) {
+        return new GMap.Mixin<K, V, T, U, Map<T, U>>(key, value, GMap.createSorted(QPair.create(key, value), comparator));
+    }
+
+
     private GroupBy() {}
 
 }