bugfix for MMap with List value usage.(also performance related)

Author: XenoAmess

maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/AbstractDependencyManager.java

@@ -151,23 +151,23 @@ public DependencyManager deriveChildManager(DependencyCollectionContext context)
             String version = artifact.getVersion();
             if (!version.isEmpty() && !managedVersions.containsKey(key)) {
                 if (managedVersions == this.managedVersions) {
-                    managedVersions = MMap.copy(this.managedVersions);
+                    managedVersions = MMap.append(this.managedVersions);
                 }
                 managedVersions.put(key, new Holder<>(depth, version));
             }
 
             String scope = managedDependency.getScope();
             if (!scope.isEmpty() && !managedScopes.containsKey(key)) {
                 if (managedScopes == this.managedScopes) {
-                    managedScopes = MMap.copy(this.managedScopes);
+                    managedScopes = MMap.append(this.managedScopes);
                 }
                 managedScopes.put(key, new Holder<>(depth, scope));
             }
 
             Boolean optional = managedDependency.getOptional();
             if (optional != null && !managedOptionals.containsKey(key)) {
                 if (managedOptionals == this.managedOptionals) {
-                    managedOptionals = MMap.copy(this.managedOptionals);
+                    managedOptionals = MMap.append(this.managedOptionals);
                 }
                 managedOptionals.put(key, new Holder<>(depth, optional));
             }
@@ -177,15 +177,15 @@ public DependencyManager deriveChildManager(DependencyCollectionContext context)
                     : systemDependencyScope.getSystemPath(managedDependency.getArtifact());
             if (localPath != null && !managedLocalPaths.containsKey(key)) {
                 if (managedLocalPaths == this.managedLocalPaths) {
-                    managedLocalPaths = MMap.copy(this.managedLocalPaths);
+                    managedLocalPaths = MMap.append(this.managedLocalPaths);
                 }
                 managedLocalPaths.put(key, new Holder<>(depth, localPath));
             }
 
             Collection<Exclusion> exclusions = managedDependency.getExclusions();
             if (!exclusions.isEmpty()) {
                 if (managedExclusions == this.managedExclusions) {
-                    managedExclusions = MMap.copy(this.managedExclusions);
+                    managedExclusions = MMap.copyWithListValue(this.managedExclusions);
                 }
                 Collection<Holder<Collection<Exclusion>>> managed = managedExclusions.get(key);
                 if (managed == null) {

maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/MMap.java

@@ -18,7 +18,11 @@
  */
 package org.eclipse.aether.util.graph.manager;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
 
 /**
  * Warning: this is a special map-like construct that suits only and should be used only in this package!
@@ -47,6 +51,18 @@ public static <K, V> MMap<K, V> copy(MMap<K, V> orig) {
         return new MMap<>(new HashMap<>(orig.delegate));
     }
 
+    public static <K, V> MMap<K, Collection<V>> copyWithListValue(MMap<K, Collection<V>> orig) {
+        HashMap<K, Collection<V>> newMap = new HashMap<>((int) Math.ceil(orig.size() / 0.75D));
+        for (Map.Entry<K, Collection<V>> entry : orig.delegate.entrySet()) {
+            newMap.put(entry.getKey(), entry.getValue() == null ? null : new ArrayList<>(entry.getValue()));
+        }
+        return new MMap<>(newMap);
+    }
+
+    public static <K, V> MMap<K, V> append(MMap<K, V> orig) {
+        return new AppendMMap<>(orig);
+    }
+
     protected final HashMap<K, V> delegate;
 
     private MMap(HashMap<K, V> delegate) {
@@ -69,6 +85,10 @@ public MMap<K, V> done() {
         return new DoneMMap<>(delegate);
     }
 
+    public MMap<K, V> append() {
+        return new AppendMMap<>(this);
+    }
+
     @Override
     public int hashCode() {
         throw new IllegalStateException("MMap is not done yet");
@@ -79,12 +99,20 @@ public boolean equals(Object o) {
         throw new IllegalStateException("MMap is not done yet");
     }
 
+    public int size() {
+        return delegate.size();
+    }
+
     private static class DoneMMap<K, V> extends MMap<K, V> {
-        private final int hashCode;
+        volatile long hashCode = Long.MAX_VALUE;
 
         private DoneMMap(HashMap<K, V> delegate) {
             super(delegate);
-            this.hashCode = delegate.hashCode();
+        }
+
+        private DoneMMap(HashMap<K, V> delegate, long hashCode) {
+            super(delegate);
+            this.hashCode = hashCode;
         }
 
         @Override
@@ -99,7 +127,12 @@ public MMap<K, V> done() {
 
         @Override
         public int hashCode() {
-            return hashCode;
+            if (this.hashCode != Long.MAX_VALUE) {
+                return (int) hashCode;
+            }
+            int result = delegate.hashCode();
+            this.hashCode = result;
+            return result;
         }
 
         @Override
@@ -111,4 +144,35 @@ public boolean equals(Object o) {
             return delegate.equals(other.delegate);
         }
     }
+
+    private static class AppendMMap<K, V> extends DoneMMap<K, V> {
+
+        AppendMMap(MMap<K, V> orig) {
+            super(new HashMap<>(orig.delegate));
+            if (orig instanceof DoneMMap) {
+                this.hashCode = ((DoneMMap<K, V>) orig).hashCode;
+            } else {
+                this.hashCode = Long.MAX_VALUE;
+            }
+        }
+
+        @Override
+        public V put(K key, V value) {
+            boolean ifPresent = delegate.containsKey(key);
+            V originalValue = delegate.put(key, value);
+            if (hashCode != Long.MAX_VALUE) {
+                int keyHash = Objects.hashCode(key);
+                if (ifPresent) {
+                    hashCode -= keyHash ^ Objects.hashCode(originalValue);
+                }
+                hashCode += keyHash ^ Objects.hashCode(value);
+            }
+            return originalValue;
+        }
+
+        @Override
+        public MMap<K, V> done() {
+            return new DoneMMap<>(delegate, hashCode);
+        }
+    }
 }