Refactor BuildReferenceMapAdapter

Author: Dmytro Ukhlov

core/src/main/java/hudson/util/CopyOnWriteMap.java

@@ -38,6 +38,7 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.NavigableMap;
+import java.util.NavigableSet;
 import java.util.Set;
 import java.util.SortedMap;
 import java.util.TreeMap;
@@ -211,34 +212,38 @@ public boolean canConvert(Class type) {
 
             @Override
             public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
-                return new Hash((Map) super.unmarshal(reader, context));
+                return new Hash<>((Map<?, ?>) super.unmarshal(reader, context));
             }
 
             @Override
             public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
-                super.marshal(((Hash) source).core, writer, context);
+                super.marshal(((Hash<?, ?>) source).core, writer, context);
             }
         }
     }
 
     /**
      * {@link CopyOnWriteMap} backed by {@link TreeMap}.
      */
-    public static final class Tree<K, V> extends CopyOnWriteMap<K, V> implements SortedMap<K, V> {
-        private final Comparator<K> comparator;
+    public static final class Tree<K, V> extends CopyOnWriteMap<K, V> implements NavigableMap<K, V> {
+        private final Comparator<? super K> comparator;
 
-        public Tree(Map<K, V> core, Comparator<K> comparator) {
+        public Tree(Map<K, V> core, Comparator<? super K> comparator) {
             this(comparator);
             putAll(core);
         }
 
-        public Tree(Comparator<K> comparator) {
+        public Tree(NavigableMap<K, V> m) {
+            this(m, m.comparator());
+        }
+
+        public Tree(Comparator<? super K> comparator) {
             super(new TreeMap<>(comparator));
             this.comparator = comparator;
         }
 
         public Tree() {
-            this(null);
+            this(Collections.emptyNavigableMap());
         }
 
         @Override
@@ -263,10 +268,96 @@ public NavigableMap<K, V> getView() {
             return (NavigableMap<K, V>) super.getView();
         }
 
+        @Override
+        public Entry<K, V> lowerEntry(K key) {
+            return getView().lowerEntry(key);
+        }
+
+        @Override
+        public K lowerKey(K key) {
+            return getView().lowerKey(key);
+        }
+
+        @Override
+        public Entry<K, V> floorEntry(K key) {
+            return getView().floorEntry(key);
+        }
+
+        @Override
+        public K floorKey(K key) {
+            return getView().floorKey(key);
+        }
+
+        @Override
+        public Entry<K, V> ceilingEntry(K key) {
+            return getView().ceilingEntry(key);
+        }
+
+        @Override
+        public K ceilingKey(K key) {
+            return getView().ceilingKey(key);
+        }
+
+        @Override
+        public Entry<K, V> higherEntry(K key) {
+            return getView().higherEntry(key);
+        }
+
+        @Override
+        public K higherKey(K key) {
+            return getView().higherKey(key);
+        }
+
+        @Override
+        public Entry<K, V> firstEntry() {
+            return getView().firstEntry();
+        }
+
+        @Override
+        public Entry<K, V> lastEntry() {
+            return getView().lastEntry();
+        }
+
+        @Override
+        public Entry<K, V> pollFirstEntry() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public Entry<K, V> pollLastEntry() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
         public NavigableMap<K, V> descendingMap() {
             return getView().descendingMap();
         }
 
+        @Override
+        public NavigableSet<K> navigableKeySet() {
+            return getView().navigableKeySet();
+        }
+
+        @Override
+        public NavigableSet<K> descendingKeySet() {
+            return getView().descendingKeySet();
+        }
+
+        @Override
+        public NavigableMap<K, V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
+            return getView().subMap(fromKey, fromInclusive, toKey, toInclusive);
+        }
+
+        @Override
+        public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
+            return getView().headMap(toKey, inclusive);
+        }
+
+        @Override
+        public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
+            return getView().tailMap(fromKey, inclusive);
+        }
+
         @Override
         public Comparator<? super K> comparator() {
             return getView().comparator();
@@ -309,13 +400,12 @@ public boolean canConvert(Class type) {
 
             @Override
             public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
-                TreeMap tm = (TreeMap) super.unmarshal(reader, context);
-                return new Tree(tm, tm.comparator());
+                return new Tree<>((TreeMap<?, ?>) super.unmarshal(reader, context));
             }
 
             @Override
             public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
-                super.marshal(((Tree) source).core, writer, context);
+                super.marshal(((Tree<?, ?>) source).core, writer, context);
             }
         }
     }