Poke at it a bit more

Author: macchiati

tools/cldr-code/src/main/java/org/unicode/cldr/util/NestedMap.java

@@ -1,6 +1,8 @@
 package org.unicode.cldr.util;
 
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.Maps;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Deque;
@@ -22,7 +24,7 @@
  * ENGINE CLASS A generic, nested map structure that can handle a variable number of levels. This
  * class provides the core logic and is wrapped by the type-safe shims.
  *
- * <p>Various nested Multimaps can be created by using an extra layer with Boolean. Multimap2<K1,
+ * <p>Various nested Multisets can be created by using an extra layer with Boolean. Multimap2<K1,
  * K2, V> == NestedMap3<K1, K2, V, Boolean>
  */
 public class NestedMap {
@@ -97,6 +99,20 @@ public String toString() {
         return root.toString();
     }
 
+    @Override
+    public boolean equals(Object obj) {
+        return root.equals(((NestedMap) obj).root);
+    }
+
+    @Override
+    public int hashCode() {
+        return root.hashCode();
+    }
+
+    public MapDifference<Object, Object> difference(NestedMap other) {
+        return Maps.difference(root, other.root);
+    }
+
     // --- IMMUTABILITY ---
 
     /**
@@ -198,36 +214,43 @@ public boolean tryAdvance(Consumer<? super List<Object>> action) {
         }
     }
 
+    @SuppressWarnings("unchecked")
     public static class NestedMap2<K1, K2, V> {
         private final NestedMap engine;
 
         private NestedMap2(NestedMap engine) {
             this.engine = engine;
         }
 
-        public static <K1 extends Comparable<K1>, K2 extends Comparable<K2>, V>
-                NestedMap2<K1, K2, V> createWithTreeMaps() {
-            return new NestedMap2<>(new NestedMap(TreeMap::new));
+        /** Takes Treemap::new, HashMap::new, ConcurrentHashMap::new, and other suppliers */
+        public static <K1, K2, V> NestedMap2<K1, K2, V> create(
+                Supplier<Map<Object, Object>> supplier) {
+            return new NestedMap2<>(new NestedMap(supplier));
+        }
+
+        @Override
+        public String toString() {
+            return engine.toString();
         }
 
-        public static <K1, K2, V> NestedMap2<K1, K2, V> createWithHashMaps() {
-            return new NestedMap2<>(new NestedMap(HashMap::new));
+        @Override
+        public boolean equals(Object obj) {
+            return engine.equals(((NestedMap2) obj).engine);
         }
 
-        public static <K1, K2, V> NestedMap2<K1, K2, V> createWithConcurrentHashMaps() {
-            return new NestedMap2<>(new NestedMap(ConcurrentHashMap::new));
+        @Override
+        public int hashCode() {
+            return engine.hashCode();
         }
 
         public void put(K1 key1, K2 key2, V value) {
             engine.put(key1, key2, value);
         }
 
-        @SuppressWarnings("unchecked")
         public V get(K1 key1, K2 key2) {
             return (V) engine.get(key1, key2);
         }
 
-        @SuppressWarnings("unchecked")
         public V remove(K1 key1, K2 key2) {
             return (V) engine.remove(key1, key2);
         }
@@ -264,11 +287,6 @@ public Stream<Entry<K1, K2, V>> stream() {
         public ImmutableNestedMap2<K1, K2, V> createImmutable() {
             return new ImmutableNestedMap2<K1, K2, V>(engine);
         }
-
-        @Override
-        public String toString() {
-            return engine.toString();
-        }
     }
 
     public static class ImmutableNestedMap2<K1, K2, V> extends NestedMap2<K1, K2, V> {
@@ -291,22 +309,9 @@ private NestedMap3(NestedMap engine) {
             this.engine = engine;
         }
 
-        /**
-         * Takes Treemap::new, HashMap::new, ConcurrentHashMap::new
-         *
-         * @param <K1>
-         * @param <K2>
-         * @param <K3>
-         * @param <V>
-         * @param supplier
-         * @return
-         */
-        public static <
-                        K1 extends Comparable<K1>,
-                        K2 extends Comparable<K2>,
-                        K3 extends Comparable<K3>,
-                        V>
-                NestedMap3<K1, K2, K3, V> create(Supplier<Map<Object, Object>> supplier) {
+        /** Takes Treemap::new, HashMap::new, ConcurrentHashMap::new, and other suppliers */
+        public static <K1, K2, K3, V> NestedMap3<K1, K2, K3, V> create(
+                Supplier<Map<Object, Object>> supplier) {
             return new NestedMap3<>(new NestedMap(supplier));
         }
 
@@ -327,6 +332,16 @@ public String toString() {
             return engine.toString();
         }
 
+        @Override
+        public boolean equals(Object obj) {
+            return engine.equals(((NestedMap3) obj).engine);
+        }
+
+        @Override
+        public int hashCode() {
+            return engine.hashCode();
+        }
+
         public static class Entry<K1, K2, K3, V> { // With Java17 we could use records
             List<Object> list;
 
@@ -384,13 +399,7 @@ private NestedMap4(NestedMap engine) {
             this.engine = engine;
         }
 
-        public static <
-                        K1 extends Comparable<K1>,
-                        K2 extends Comparable<K2>,
-                        K3 extends Comparable<K3>,
-                        K4 extends Comparable<K4>,
-                        V>
-                NestedMap4<K1, K2, K3, K4, V> createWithTreeMaps() {
+        public static <K1, K2, K3, K4, V> NestedMap4<K1, K2, K3, K4, V> createWithTreeMaps() {
             return new NestedMap4<>(new NestedMap(TreeMap::new));
         }
 
@@ -421,6 +430,9 @@ public V remove(K1 key1, K2 key2, K3 key3, K4 key4) {
         public String toString() {
             return engine.toString();
         }
+        
+        // TODO finish up along the lines of NestedMap2
+
     }
 
     // --- SHIM FOR 5-LEVEL MAP ---
@@ -470,6 +482,8 @@ public V remove(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5) {
         public String toString() {
             return engine.toString();
         }
+
+        // TODO finish up along the lines of NestedMap2
     }
 
     // --- SHIM FOR 6-LEVEL MAP ---
@@ -480,14 +494,7 @@ private NestedMap6(NestedMap engine) {
             this.engine = engine;
         }
 
-        public static <
-                        K1 extends Comparable<K1>,
-                        K2 extends Comparable<K2>,
-                        K3 extends Comparable<K3>,
-                        K4 extends Comparable<K4>,
-                        K5 extends Comparable<K5>,
-                        K6 extends Comparable<K6>,
-                        V>
+        public static <K1, K2, K3, K4, K5, K6, V>
                 NestedMap6<K1, K2, K3, K4, K5, K6, V> createWithTreeMaps() {
             return new NestedMap6<>(new NestedMap(TreeMap::new));
         }
@@ -520,5 +527,8 @@ public V remove(K1 key1, K2 key2, K3 key3, K4 key4, K5 key5, K6 key6) {
         public String toString() {
             return engine.toString();
         }
+
+        // TODO finish up along the lines of NestedMap2
+
     }
 }

tools/cldr-code/src/test/java/org/unicode/cldr/unittest/TestNestedMaps.java

@@ -0,0 +1,74 @@
+package org.unicode.cldr.unittest;
+
+import com.google.common.collect.ImmutableMap;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.TreeMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import org.unicode.cldr.icu.dev.test.TestFmwk;
+import org.unicode.cldr.util.Joiners;
+import org.unicode.cldr.util.NestedMap.ImmutableNestedMap2;
+import org.unicode.cldr.util.NestedMap.NestedMap2;
+
+public class TestNestedMaps extends TestFmwk {
+    public static void main(String[] args) {
+        new TestNestedMaps().run(args);
+    }
+
+    public void testBasic() {
+        List<String> key1s = List.of("b", "a", "b");
+        List<Double> key2s = List.of(993.2d, 5.3d, 99d);
+        Boolean v1 = true;
+        List<String> actualParts = List.of("[b, 993.2, true]", "[a, 5.3, true]", "[b, 99.0, true]");
+        // tree order is 1,2,0
+
+        Map<Supplier<Map<Object, Object>>, List<Integer>> supplierAndOrders =
+                ImmutableMap.of(
+                        TreeMap::new,
+                        List.of(1, 2, 0),
+                        LinkedHashMap::new,
+                        List.of(0, 2, 1), // keys are ordered together
+                        HashMap::new,
+                        List.of(1, 0, 2),
+                        ConcurrentHashMap::new,
+                        List.of(1, 0, 2));
+        for (Entry<Supplier<Map<Object, Object>>, List<Integer>> supplierAndOrder :
+                supplierAndOrders.entrySet()) {
+            Supplier<Map<Object, Object>> supplier = supplierAndOrder.getKey();
+            List<Integer> order = supplierAndOrder.getValue();
+
+            NestedMap2<String, Double, Boolean> nm2 = NestedMap2.create(supplier);
+
+            for (int i = 0; i < key1s.size(); ++i) {
+                String key1 = key1s.get(i);
+                Double key2 = key2s.get(i);
+                String stringified = join(i, actualParts, order);
+                nm2.put(key1, key2, v1);
+                Boolean result = nm2.get(key1, key2);
+                assertEquals(String.valueOf(i), v1, result);
+
+                String actual = Joiners.VBAR.join(nm2.stream().collect(Collectors.toList()));
+                assertEquals(String.valueOf(i) + " " + order, stringified, actual);
+            }
+
+            ImmutableNestedMap2<String, Double, Boolean> nm2_immutable = nm2.createImmutable();
+            nm2.equals(nm2_immutable);
+            if (!assertEquals("immutable equals?", nm2, nm2_immutable)) {}
+        }
+    }
+
+    private String join(int i, List<String> actualParts, List<Integer> order) {
+        List<String> result = new ArrayList<>();
+        for (int j : order) {
+            if (j > i) continue;
+            result.add(actualParts.get(j));
+        }
+        return Joiners.VBAR.join(result);
+    }
+}