Bump version and fix warnings

pom.xml

@@ -31,7 +31,7 @@
 
     <groupId>com.speedment</groupId>
     <artifactId>speedment</artifactId>
-    <version>2.1.1-SNAPSHOT</version>
+    <version>2.1.1</version>
     <packaging>jar</packaging>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

src/main/java/com/speedment/SpeedmentVersion.java

@@ -30,7 +30,7 @@ public final class SpeedmentVersion {
 
     private static final String IMPLEMENTATION_TITLE = "Speedment";
     private static final String IMPLEMENTATION_VENDOR = "Speedment Inc."; // "Speedment, Inc." difficult to enter into POM because of ','
-    private static final String IMPLEMENTATION_VERSION = "2.1.0";
+    private static final String IMPLEMENTATION_VERSION = "2.1.1";
     private static final boolean PRODUCTION_MODE = true;
 
 //    private static final String SPECIFICATION_TITLE = "Speedment";

src/main/java/com/speedment/internal/core/manager/memory/OnHeapStore.java

@@ -35,81 +35,80 @@
 import java.util.stream.Stream;
 
 /**
- * A store for a particular type of entity. The store can be used to retreive 
+ * A store for a particular type of entity. The store can be used to retreive
  * subsets of all entities based on a standard operator. For an example, the
- * subset of all entities that have a value 'id' greater than 100 or the
- * subset of all entities with the value 'date' lesser than '2015-01-01'.
+ * subset of all entities that have a value 'id' greater than 100 or the subset
+ * of all entities with the value 'date' lesser than '2015-01-01'.
  * <p>
  * Retreiving a subset is an O(1) operator and results in a {@code Stream}. The
  * stream can then be traversed in linear time. It is therefore recommended to
  * retreive the smallest subset first and apply less specific filters later on.
  * <p>
- * A store can be modified using the {@link #add(java.lang.Object)} and 
- * {@link #remove(java.lang.Object)} methods. The current implementation of 
+ * A store can be modified using the {@link #add(java.lang.Object)} and
+ * {@link #remove(java.lang.Object)} methods. The current implementation of
  * these methods <b>are not thread safe</b>!
- * 
+ *
  * @author Emil
- * @param <ENTITY>  the type of entity to store
+ * @param <ENTITY> the type of entity to store
  */
 public class OnHeapStore<ENTITY> {
-
-    private final Map<ReferenceComparableField<ENTITY, ? extends Comparable<?>>, 
-        SortedMap<? extends Comparable<?>, Set<ENTITY>>> stores;
-
+
+    private final Map<ReferenceComparableField<ENTITY, ? extends Comparable<?>>, SortedMap<? extends Comparable<?>, Set<ENTITY>>> stores;
+
     /**
      * Constructs the store and populates it with all the static fields of type
      * {@link ReferenceComparableField} found in the specified class.
-     * 
-     * @param entityClass  the entity class this store is for
+     *
+     * @param entityClass the entity class this store is for
      */
     public OnHeapStore(Class<ENTITY> entityClass) {
         requireNonNull(entityClass);
         stores = new ConcurrentHashMap<>();
         populateByReflection(entityClass);
     }
-    
+
     /**
      * Adds the specified entity to the store.
      * <p>
      * Observe that this method is currently <b>not threadsafe!</b>
-     * 
-     * @param entity  the entity to add 
+     *
+     * @param entity the entity to add
      */
     public void add(ENTITY entity) {
         requireNonNull(entity);
         MapStream.of(stores)
             .forEach((field, store) -> addEntity(field, store, entity));
     }
-    
+
     /**
      * Removed the specified entity from the store.
      * <p>
      * Observe that this method is currently <b>not threadsafe!</b>
-     * 
-     * @param entity  the entity to remove.
+     *
+     * @param entity the entity to remove.
      */
     public void remove(ENTITY entity) {
         requireNonNull(entity);
         MapStream.of(stores)
             .forEach((field, store) -> removeEntity(field, store, entity));
     }
-    
+
     /**
      * Returns a stream of subsets of this store based on the specified field,
      * operator and value. If no entities match, an empty stream will be
      * returned. None of the in parameters can be {@code null}.
-     * 
-     * @param <V>       the type of the value
+     *
+     * @param <V> the type of the value
      * @param predicate the predicate to use
-     * @return          a stream of matching entities
+     * @return a stream of matching entities
      */
     public <V extends Comparable<V>> Stream<ENTITY> where(
-        ComparablePredicateBuilder predicate) {
-        
-        final ReferenceComparableField field = predicate.getField();
-        final V value = (V) predicate.getOperand();
+        ComparablePredicateBuilder<ENTITY, V> predicate) {
+
+        final ReferenceComparableField<ENTITY, V> field = predicate.getField();
+        final V value = predicate.getOperand();
         final ComparableOperator operator = predicate.getComparableOperator();
-        
+
         if (operator instanceof StandardComparableOperator) {
             return where(field, (StandardComparableOperator) operator, value);
         } else {
@@ -123,68 +122,71 @@ public <V extends Comparable<V>> Stream<ENTITY> where(
      * Returns a stream of subsets of this store based on the specified field,
      * operator and value. If no entities match, an empty stream will be
      * returned. None of the in parameters can be {@code null}.
-     * 
-     * @param <V>       the type of the value
-     * @param field     the field to compare
-     * @param operator  the operator to use for comparing
-     * @param value     the value to compare with
-     * @return          a stream of matching entities
+     *
+     * @param <V> the type of the value
+     * @param field the field to compare
+     * @param operator the operator to use for comparing
+     * @param value the value to compare with
+     * @return a stream of matching entities
      */
     public <V extends Comparable<V>> Stream<ENTITY> where(
-        ReferenceComparableField<ENTITY, V> field, 
-        StandardComparableOperator operator, 
+        ReferenceComparableField<ENTITY, V> field,
+        StandardComparableOperator operator,
         V value) {
-        
+
         requireNonNulls(field, operator, value);
 
         // This cast should be safe as long as the map has not been manipulated 
         // outside this class. The store should not be null as long as the field
         // is a valid field retreived by reflection.
-        final SortedMap<V, Set<ENTITY>> store = 
-            (SortedMap<V, Set<ENTITY>>) stores.get(field);
+        @SuppressWarnings("unchecked")
+        final SortedMap<V, Set<ENTITY>> store
+            = (SortedMap<V, Set<ENTITY>>) stores.get(field);
 
         switch (operator) {
-            case EQUAL : 
+            case EQUAL:
                 return fromStore(store, value).stream();
-                
-            case NOT_EQUAL :
+
+            case NOT_EQUAL:
                 return MapStream.of(store)
                     .filter((k, v) -> !Objects.equals(k, value))
                     .flatMapValue((k, set) -> set.stream())
                     .values();
-                
-            case GREATER_THAN :
+
+            case GREATER_THAN:
                 return MapStream.of(store.tailMap(value))
                     .flatMapValue((k, set) -> set.stream())
                     .values();
-                
-            case GREATER_OR_EQUAL :
+
+            case GREATER_OR_EQUAL:
                 return Stream.concat(
-                    fromStore(store, value).stream(), 
+                    fromStore(store, value).stream(),
                     MapStream.of(store.tailMap(value))
-                        .flatMapValue((k, set) -> set.stream())
-                        .values()
+                    .flatMapValue((k, set) -> set.stream())
+                    .values()
                 );
-                
-            case LESS_THAN :
+
+            case LESS_THAN:
                 return MapStream.of(store.headMap(value))
                     .flatMapValue((k, set) -> set.stream())
                     .values();
-                
-            case LESS_OR_EQUAL :
+
+            case LESS_OR_EQUAL:
                 return Stream.concat(
-                    fromStore(store, value).stream(), 
+                    fromStore(store, value).stream(),
                     MapStream.of(store.headMap(value))
-                        .flatMapValue((k, set) -> set.stream())
-                        .values()
+                    .flatMapValue((k, set) -> set.stream())
+                    .values()
+                );
+
+            default:
+                throw new UnsupportedOperationException(
+                    "Unknown standard comparable operator '" + operator + "'."
                 );
-
-            default : throw new UnsupportedOperationException(
-                "Unknown standard comparable operator '" + operator + "'."
-            );
         }
     }
-
+
+    @SuppressWarnings("unchecked")
     private void populateByReflection(Class<ENTITY> entityClass) {
         Stream.of(entityClass.getDeclaredFields())
             .filter(f -> f.isAccessible())
@@ -201,39 +203,41 @@ private void populateByReflection(Class<ENTITY> entityClass) {
                     throw new SpeedmentException("Could not access field.", ex);
                 }
             })
-
             // Should be safe to throw as the following has been assured:
             //     (i)   f is a ReferenceComparableField
             //     (ii)  The declared class is ENTITY
             //     (iii) Only comparable values can be type params of 
             //           ReferenceComparableField
             .map(f -> (ReferenceComparableField<ENTITY, ? extends Comparable<?>>) f)
-
             .forEach(f -> stores.put(f, new ConcurrentSkipListMap<>()));
     }
-    
+
     private static <ENTITY, V extends Comparable<V>> void addEntity(
-        ReferenceComparableField<ENTITY, ? extends Comparable<?>> field, 
+        ReferenceComparableField<ENTITY, ? extends Comparable<?>> field,
         SortedMap<? extends Comparable<?>, Set<ENTITY>> store,
         ENTITY entity) {
-
+
+        @SuppressWarnings("unchecked")
         final V value = (V) field.get(entity);
+        @SuppressWarnings("unchecked")
         final SortedMap<V, Set<ENTITY>> typedStore = (SortedMap<V, Set<ENTITY>>) store;
-        
+
         fromStore(typedStore, value).add(entity);
     }
-    
+
     private static <ENTITY, V extends Comparable<V>> void removeEntity(
         ReferenceComparableField<ENTITY, ? extends Comparable<?>> field,
         SortedMap<? extends Comparable<?>, Set<ENTITY>> store,
         ENTITY entity) {
-
+
+        @SuppressWarnings("unchecked")
         final V value = (V) field.get(entity);
+        @SuppressWarnings("unchecked")
         final SortedMap<V, Set<ENTITY>> typedStore = (SortedMap<V, Set<ENTITY>>) store;
-        
+
         fromStore(typedStore, value).remove(entity);
     }
-    
+
     private static <ENTITY, V extends Comparable<V>> Set<ENTITY> fromStore(SortedMap<V, Set<ENTITY>> store, V value) {
         return store.computeIfAbsent(value, v -> new HashSet<>());
     }

src/main/java/com/speedment/internal/core/stream/MapStream.java

@@ -245,11 +245,13 @@ public MapStream<K, V> sorted(Comparator<? super Map.Entry<K, V>> comparator) {
         return this;
     }
 
-    public MapStream<K, V> sorted(ToIntBiFunction<? super K, ? super V> comparator) {
-        inner = inner.sorted((e1, e2)
-            -> comparator.applyAsInt(e1.getKey(), e1.getValue())
-            - comparator.applyAsInt(e2.getKey(), e2.getValue())
-        );
+    public MapStream<K, V> sortedByKey(Comparator<K> comparator) {
+        inner = inner.sorted(byKeyOnly(comparator));
+        return this;
+    }
+
+    public MapStream<K, V> sortedByValue(Comparator<V> comparator) {
+        inner = inner.sorted(byValueOnly(comparator));
         return this;
     }
 
@@ -338,24 +340,26 @@ public <K2> MapStream<K2, List<V>> groupBy(Function<V, K2> grouper) {
     public Optional<Map.Entry<K, V>> min(Comparator<? super Map.Entry<K, V>> comparator) {
         return inner.min(comparator);
     }
-
-    public Optional<Map.Entry<K, V>> min(ToIntBiFunction<? super K, ? super V> comparator) {
-        return inner.min((e1, e2)
-            -> comparator.applyAsInt(e1.getKey(), e1.getValue())
-            - comparator.applyAsInt(e2.getKey(), e2.getValue())
-        );
+
+    public Optional<Map.Entry<K, V>> minByKey(Comparator<K> comparator) {
+        return inner.min(byKeyOnly(comparator));
+    }
+
+    public Optional<Map.Entry<K, V>> minByValue(Comparator<V> comparator) {
+        return inner.min(byValueOnly(comparator));
     }
 
     @Override
     public Optional<Map.Entry<K, V>> max(Comparator<? super Map.Entry<K, V>> comparator) {
         return inner.max(comparator);
     }
 
-    public Optional<Map.Entry<K, V>> max(ToIntBiFunction<? super K, ? super V> comparator) {
-        return inner.max((e1, e2)
-            -> comparator.applyAsInt(e1.getKey(), e1.getValue())
-            - comparator.applyAsInt(e2.getKey(), e2.getValue())
-        );
+    public Optional<Map.Entry<K, V>> maxByKey(Comparator<K> comparator) {
+        return inner.max(byKeyOnly(comparator));
+    }
+
+    public Optional<Map.Entry<K, V>> maxByValue(Comparator<V> comparator) {
+        return inner.max(byValueOnly(comparator));
     }
 
     @Override
@@ -458,4 +462,12 @@ public List<Map.Entry<K, V>> toList() {
     private MapStream(Stream<Map.Entry<K, V>> inner) {
         this.inner = inner;
     }
+
+    private static <K, V> Comparator<Map.Entry<K, V>> byKeyOnly(Comparator<K> comparator) {
+        return (a, b) -> comparator.compare(a.getKey(), b.getKey());
+    }
+
+    private static <K, V> Comparator<Map.Entry<K, V>> byValueOnly(Comparator<V> comparator) {
+        return (a, b) -> comparator.compare(a.getValue(), b.getValue());
+    }
 }

src/main/java/com/speedment/internal/core/stream/autoclose/AbstractAutoClosingStream.java

@@ -208,8 +208,10 @@ public CloseImpl(Runnable r) {
         }
 
         @Override
-        public void close() throws Exception {
-            r.run();
+        public void close() {
+
+                r.run();
+
         }
 
     }

src/test/java/com/speedment/internal/core/runtime/SpeedmentVersionTest.java

@@ -34,7 +34,7 @@
  */
 public class SpeedmentVersionTest {
 
-    private static final String EXPECTED_IMPLEMENTATION_VERSION = "2.1.0";
+    private static final String EXPECTED_IMPLEMENTATION_VERSION = "2.1.1";
     private static final String EXPECTED_SPECIFICATION_VERSION = "2.1";
 
     public SpeedmentVersionTest() {