fix: new util method added in Collectsions, UniqueIdGenerator added

Collections
- isCollectionEqual
- getCardinalityMap
- CardinalityHelper.java

UniqueIdGenerator
- UniqueIdGenerator: similar to firebase pushIds

Author: javaquery

build.gradle

@@ -5,7 +5,7 @@ plugins {
 }
 
 group 'com.javaquery'
-version '1.0.1'
+version '1.0.3'
 
 repositories {
     mavenCentral()

src/main/java/com/javaquery/util/UniqueIdGenerator.java

@@ -0,0 +1,67 @@
+package com.javaquery.util;
+
+/**
+ * @author vicky.thakor
+ * @see https://gist.githubusercontent.com/swftvsn/438b4ed68619ad1f5d1c251dc3a5af6f/raw/d29e0fb3ecab2702bf1b856c2ae217d5a43442fa/FirebasePushIdGenerator.java
+ * @since 1.0.3
+ */
+public class UniqueIdGenerator {
+
+    // Modeled after base64 web-safe chars, but ordered by ASCII.
+    private final static String PUSH_CHARS = "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz";
+    // We generate 72-bits of randomness which get turned into 12 characters and
+    // appended to the timestamp to prevent collisions with other clients. We store the last
+    // characters we generated because in the event of a collision, we'll use those same
+    // characters except "incremented" by one.
+    private static final int[] LAST_RAND_CHARS = new int[72];
+    // Timestamp of last push, used to prevent local collisions if you push twice in one ms.
+    private static long LAST_PUSH_TIME = 0L;
+
+    private UniqueIdGenerator() {
+    }
+
+    public static synchronized String generate() {
+        long now = System.currentTimeMillis();
+        boolean duplicateTime = now == LAST_PUSH_TIME;
+        LAST_PUSH_TIME = now;
+
+        char[] timeStampChars = new char[8];
+        for (int i = 7; i >= 0; i--) {
+            timeStampChars[i] = PUSH_CHARS.charAt((int) (now % 64));
+            now = (long) Math.floor((double) (now / 64));
+        }
+
+        if (now != 0) {
+            throw new AssertionError("We should have converted the entire timestamp.");
+        }
+
+        StringBuilder id = new StringBuilder(20);
+        for (char c : timeStampChars) {
+            id.append(c);
+        }
+
+        if (!duplicateTime) {
+            for (int i = 0; i < 12; i++) {
+                LAST_RAND_CHARS[i] = (int) Math.floor(Double.valueOf(Math.random() * 64).intValue());
+            }
+        } else {
+            // If the timestamp hasn't changed since last push, use the same random number,
+            //except incremented by 1.
+            int i;
+            for (i = 11; i >= 0 && LAST_RAND_CHARS[i] == 63; i--) {
+                LAST_RAND_CHARS[i] = 0;
+            }
+            LAST_RAND_CHARS[i]++;
+        }
+
+        for (int i = 0; i < 12; i++) {
+            id.append(PUSH_CHARS.charAt(LAST_RAND_CHARS[i]));
+        }
+
+        if (id.length() != 20) {
+            throw new AssertionError("Length should be 20.");
+        }
+
+        return id.substring(1);
+    }
+}

src/main/java/com/javaquery/util/collection/Collections.java

@@ -1,8 +1,10 @@
 package com.javaquery.util.collection;
 
+import com.javaquery.util.Assert;
 import com.javaquery.util.Objects;
 
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.IntStream;
@@ -91,4 +93,145 @@ public static <T> Stream<List<T>> batches(List<T> source, int batchSize) {
                 .range(0, fullChunks + 1)
                 .mapToObj(n -> source.subList(n * batchSize, n == fullChunks ? size : (n + 1) * batchSize));
     }
+
+    /**
+     * Note: Code imported from apache commons collection
+     * <p>
+     * Returns {@code true} iff the given {@link Collection}s contain
+     * exactly the same elements with exactly the same cardinalities.
+     * <p>
+     * That is, iff the cardinality of <i>e</i> in <i>a</i> is
+     * equal to the cardinality of <i>e</i> in <i>b</i>,
+     * for each element <i>e</i> in <i>a</i> or <i>b</i>.
+     * </p>
+     *
+     * @param collectionOne the first collection, must not be null
+     * @param collectionTwo the second collection, must not be null
+     * @return {@code true} iff the collections contain the same elements with the same cardinalities.
+     * @throws NullPointerException if either collection is null
+     * @since 1.0.3
+     */
+    public static <E> boolean isCollectionEqual(final Collection<E> collectionOne, final Collection<E> collectionTwo) {
+        Assert.nonNull(collectionOne, NullPointerException::new);
+        Assert.nonNull(collectionTwo, NullPointerException::new);
+
+        if (collectionOne.size() != collectionTwo.size()) {
+            return false;
+        }
+
+        final CardinalityHelper<Object> helper = new CardinalityHelper<>(collectionOne, collectionTwo);
+        if (helper.cardinalityA.size() != helper.cardinalityB.size()) {
+            return false;
+        }
+        for (final Object obj : helper.cardinalityA.keySet()) {
+            if (helper.freqA(obj) != helper.freqB(obj)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Note: Code imported from apache commons collection
+     * Returns a {@link Map} mapping each unique element in the given
+     * {@link Collection} to an {@link Integer} representing the number
+     * of occurrences of that element in the {@link Collection}.
+     * <p>
+     * Only those elements present in the collection will appear as
+     * keys in the map.
+     * </p>
+     *
+     * @param <O>      the type of object in the returned {@link Map}. This is a super type of &lt;I&gt;.
+     * @param iterable the collection to get the cardinality map for, must not be null
+     * @return the populated cardinality map
+     * @throws NullPointerException if coll is null
+     * @since 1.0.3
+     */
+    public static <O> Map<O, Integer> getCardinalityMap(final Iterable<? extends O> iterable) {
+        Assert.nonNull(iterable, NullPointerException::new);
+        final Map<O, Integer> count = new HashMap<>();
+        for (final O obj : iterable) {
+            count.merge(obj, 1, Integer::sum);
+        }
+        return count;
+    }
+
+    /**
+     * Note: Code imported from apache commons collection
+     * Helper class to easily access cardinality properties of two collections.
+     *
+     * @param <O> the element type
+     * @since 1.0.3
+     */
+    private static class CardinalityHelper<O> {
+
+        /**
+         * Contains the cardinality for each object in collection A.
+         */
+        final Map<O, Integer> cardinalityA;
+
+        /**
+         * Contains the cardinality for each object in collection B.
+         */
+        final Map<O, Integer> cardinalityB;
+
+        /**
+         * Create a new CardinalityHelper for two collections.
+         *
+         * @param a the first collection
+         * @param b the second collection
+         */
+        CardinalityHelper(final Iterable<? extends O> a, final Iterable<? extends O> b) {
+            cardinalityA = Collections.getCardinalityMap(a);
+            cardinalityB = Collections.getCardinalityMap(b);
+        }
+
+        /**
+         * Returns the maximum frequency of an object.
+         *
+         * @param obj the object
+         * @return the maximum frequency of the object
+         */
+        public final int max(final Object obj) {
+            return Math.max(freqA(obj), freqB(obj));
+        }
+
+        /**
+         * Returns the minimum frequency of an object.
+         *
+         * @param obj the object
+         * @return the minimum frequency of the object
+         */
+        public final int min(final Object obj) {
+            return Math.min(freqA(obj), freqB(obj));
+        }
+
+        /**
+         * Returns the frequency of this object in collection A.
+         *
+         * @param obj the object
+         * @return the frequency of the object in collection A
+         */
+        public int freqA(final Object obj) {
+            return getFreq(obj, cardinalityA);
+        }
+
+        /**
+         * Returns the frequency of this object in collection B.
+         *
+         * @param obj the object
+         * @return the frequency of the object in collection B
+         */
+        public int freqB(final Object obj) {
+            return getFreq(obj, cardinalityB);
+        }
+
+        private int getFreq(final Object obj, final Map<?, Integer> freqMap) {
+            final Integer count = freqMap.get(obj);
+            if (count != null) {
+                return count;
+            }
+            return 0;
+        }
+    }
 }

src/test/java/com/javaquery/util/TestUniqueIdGenerator.java

@@ -0,0 +1,16 @@
+package com.javaquery.util;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author vicky.thakor
+ * @since 1.0.3
+ */
+public class TestUniqueIdGenerator {
+
+    @Test
+    public void test_generate(){
+        Assertions.assertNotNull(UniqueIdGenerator.generate());
+    }
+}