Remove CacheMapAdapter and use Cache directly in AbstractSession

- Remove CacheMapAdapter.java as it's no longer needed
- Update DefaultRequestCache to use Cache<K,V> directly instead of Map adapter
- Update AbstractSession to use Cache for all internal caching:
  * services cache: Map -> Cache
  * allNodes cache: WeakHashMap -> Cache
  * allArtifacts cache: ConcurrentHashMap<Class, Map> -> Cache<Class, Cache>
  * allRepositories cache: WeakHashMap -> Cache
  * allDependencies cache: WeakHashMap -> Cache
- This brings the implementation closer to the original PR apache#2506
- All 12 cache tests continue to pass
- Maintains thread safety and memory efficiency with soft references

Author: gnodet

impl/maven-impl/src/main/java/org/apache/maven/impl/AbstractSession.java

@@ -28,8 +28,6 @@
 import java.util.NoSuchElementException;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.WeakHashMap;
-import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -96,6 +94,7 @@
 import org.apache.maven.api.services.VersionRangeResolver;
 import org.apache.maven.api.services.VersionResolver;
 import org.apache.maven.api.services.VersionResolverException;
+import org.apache.maven.impl.cache.Cache;
 import org.eclipse.aether.DefaultRepositorySystemSession;
 import org.eclipse.aether.RepositorySystem;
 import org.eclipse.aether.RepositorySystemSession;
@@ -112,16 +111,14 @@ public abstract class AbstractSession implements InternalSession {
     protected final RepositorySystem repositorySystem;
     protected final List<RemoteRepository> repositories;
     protected final Lookup lookup;
-    private final Map<Class<? extends Service>, Service> services = new ConcurrentHashMap<>();
+    private final Cache<Class<? extends Service>, Service> services = Cache.newCache();
     private final List<Listener> listeners = new CopyOnWriteArrayList<>();
-    private final Map<org.eclipse.aether.graph.DependencyNode, Node> allNodes =
-            Collections.synchronizedMap(new WeakHashMap<>());
-    private final Map<Class<? extends Artifact>, Map<org.eclipse.aether.artifact.Artifact, Artifact>> allArtifacts =
-            new ConcurrentHashMap<>();
-    private final Map<org.eclipse.aether.repository.RemoteRepository, RemoteRepository> allRepositories =
-            Collections.synchronizedMap(new WeakHashMap<>());
-    private final Map<org.eclipse.aether.graph.Dependency, Dependency> allDependencies =
-            Collections.synchronizedMap(new WeakHashMap<>());
+    private final Cache<org.eclipse.aether.graph.DependencyNode, Node> allNodes = Cache.newCache();
+    private final Cache<Class<? extends Artifact>, Cache<org.eclipse.aether.artifact.Artifact, Artifact>> allArtifacts =
+            Cache.newCache();
+    private final Cache<org.eclipse.aether.repository.RemoteRepository, RemoteRepository> allRepositories =
+            Cache.newCache();
+    private final Cache<org.eclipse.aether.graph.Dependency, Dependency> allDependencies = Cache.newCache();
     private volatile RequestCache requestCache;
 
     static {
@@ -225,18 +222,18 @@ public Artifact getArtifact(@Nonnull org.eclipse.aether.artifact.Artifact artifa
     @SuppressWarnings("unchecked")
     @Override
     public <T extends Artifact> T getArtifact(Class<T> clazz, org.eclipse.aether.artifact.Artifact artifact) {
-        Map<org.eclipse.aether.artifact.Artifact, Artifact> map =
-                allArtifacts.computeIfAbsent(clazz, c -> Collections.synchronizedMap(new WeakHashMap<>()));
+        Cache<org.eclipse.aether.artifact.Artifact, Artifact> cache =
+                allArtifacts.computeIfAbsent(clazz, c -> Cache.newCache());
         if (clazz == Artifact.class) {
-            return (T) map.computeIfAbsent(artifact, a -> new DefaultArtifact(this, a));
+            return (T) cache.computeIfAbsent(artifact, a -> new DefaultArtifact(this, a));
         } else if (clazz == DownloadedArtifact.class) {
             if (artifact.getPath() == null) {
                 throw new IllegalArgumentException("The given artifact is not resolved");
             } else {
-                return (T) map.computeIfAbsent(artifact, a -> new DefaultDownloadedArtifact(this, a));
+                return (T) cache.computeIfAbsent(artifact, a -> new DefaultDownloadedArtifact(this, a));
             }
         } else if (clazz == ProducedArtifact.class) {
-            return (T) map.computeIfAbsent(artifact, a -> new DefaultProducedArtifact(this, a));
+            return (T) cache.computeIfAbsent(artifact, a -> new DefaultProducedArtifact(this, a));
         } else {
             throw new IllegalArgumentException("Unsupported Artifact class: " + clazz);
         }

impl/maven-impl/src/main/java/org/apache/maven/impl/cache/CacheMapAdapter.java

@@ -38,7 +38,7 @@ public class DefaultRequestCache extends AbstractRequestCache {
             SessionData.key(ConcurrentMap.class, CacheMetadata.class);
     protected static final Object ROOT = new Object();
 
-    protected final Map<Object, CachingSupplier<?, ?>> forever = new ConcurrentHashMap<>();
+    protected final Cache<Object, CachingSupplier<?, ?>> forever = Cache.newCache();
 
     @Override
     @SuppressWarnings("unchecked")
@@ -48,13 +48,13 @@ protected <REQ extends Request<?>, REP extends Result<REQ>> CachingSupplier<REQ,
                 req instanceof CacheMetadata metadata ? metadata.getCacheRetention() : null,
                 CacheRetention.SESSION_SCOPED);
 
-        Map<Object, CachingSupplier<?, ?>> cache = null;
+        Cache<Object, CachingSupplier<?, ?>> cache = null;
         if ((retention == CacheRetention.REQUEST_SCOPED || retention == CacheRetention.SESSION_SCOPED)
                 && req.getSession() instanceof Session session) {
             Object key = retention == CacheRetention.REQUEST_SCOPED ? doGetOuterRequest(req) : ROOT;
-            Map<Object, Map<Object, CachingSupplier<?, ?>>> caches =
+            Map<Object, Cache<Object, CachingSupplier<?, ?>>> caches =
                     session.getData().computeIfAbsent(KEY, ConcurrentHashMap::new);
-            cache = caches.computeIfAbsent(key, k -> new CacheMapAdapter<>());
+            cache = caches.computeIfAbsent(key, k -> Cache.newCache());
         } else if (retention == CacheRetention.PERSISTENT) {
             cache = forever;
         }