You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by mi...@apache.org on 2018/03/05 22:34:48 UTC
[2/3] maven-resolver git commit: [MRESOLVER-35] Move dependency
collector and friends to subpackage in maven-resolver-impl
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DataPool.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DataPool.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DataPool.java
new file mode 100644
index 0000000..a8a8e9e
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DataPool.java
@@ -0,0 +1,439 @@
+package org.eclipse.aether.internal.impl.collect;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import org.eclipse.aether.RepositoryCache;
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.collection.DependencyManager;
+import org.eclipse.aether.collection.DependencySelector;
+import org.eclipse.aether.collection.DependencyTraverser;
+import org.eclipse.aether.collection.VersionFilter;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.DependencyNode;
+import org.eclipse.aether.repository.ArtifactRepository;
+import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.resolution.ArtifactDescriptorException;
+import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
+import org.eclipse.aether.resolution.ArtifactDescriptorResult;
+import org.eclipse.aether.resolution.VersionRangeRequest;
+import org.eclipse.aether.resolution.VersionRangeResult;
+import org.eclipse.aether.version.Version;
+import org.eclipse.aether.version.VersionConstraint;
+
+/**
+ */
+final class DataPool
+{
+
+ private static final String ARTIFACT_POOL = DataPool.class.getName() + "$Artifact";
+
+ private static final String DEPENDENCY_POOL = DataPool.class.getName() + "$Dependency";
+
+ private static final String DESCRIPTORS = DataPool.class.getName() + "$Descriptors";
+
+ public static final ArtifactDescriptorResult NO_DESCRIPTOR =
+ new ArtifactDescriptorResult( new ArtifactDescriptorRequest() );
+
+ private ObjectPool<Artifact> artifacts;
+
+ private ObjectPool<Dependency> dependencies;
+
+ private Map<Object, Descriptor> descriptors;
+
+ private Map<Object, Constraint> constraints = new HashMap<Object, Constraint>();
+
+ private Map<Object, List<DependencyNode>> nodes = new HashMap<Object, List<DependencyNode>>( 256 );
+
+ @SuppressWarnings( "unchecked" )
+ DataPool( RepositorySystemSession session )
+ {
+ RepositoryCache cache = session.getCache();
+
+ if ( cache != null )
+ {
+ artifacts = (ObjectPool<Artifact>) cache.get( session, ARTIFACT_POOL );
+ dependencies = (ObjectPool<Dependency>) cache.get( session, DEPENDENCY_POOL );
+ descriptors = (Map<Object, Descriptor>) cache.get( session, DESCRIPTORS );
+ }
+
+ if ( artifacts == null )
+ {
+ artifacts = new ObjectPool<Artifact>();
+ if ( cache != null )
+ {
+ cache.put( session, ARTIFACT_POOL, artifacts );
+ }
+ }
+
+ if ( dependencies == null )
+ {
+ dependencies = new ObjectPool<Dependency>();
+ if ( cache != null )
+ {
+ cache.put( session, DEPENDENCY_POOL, dependencies );
+ }
+ }
+
+ if ( descriptors == null )
+ {
+ descriptors = Collections.synchronizedMap( new WeakHashMap<Object, Descriptor>( 256 ) );
+ if ( cache != null )
+ {
+ cache.put( session, DESCRIPTORS, descriptors );
+ }
+ }
+ }
+
+ public Artifact intern( Artifact artifact )
+ {
+ return artifacts.intern( artifact );
+ }
+
+ public Dependency intern( Dependency dependency )
+ {
+ return dependencies.intern( dependency );
+ }
+
+ public Object toKey( ArtifactDescriptorRequest request )
+ {
+ return request.getArtifact();
+ }
+
+ public ArtifactDescriptorResult getDescriptor( Object key, ArtifactDescriptorRequest request )
+ {
+ Descriptor descriptor = descriptors.get( key );
+ if ( descriptor != null )
+ {
+ return descriptor.toResult( request );
+ }
+ return null;
+ }
+
+ public void putDescriptor( Object key, ArtifactDescriptorResult result )
+ {
+ descriptors.put( key, new GoodDescriptor( result ) );
+ }
+
+ public void putDescriptor( Object key, ArtifactDescriptorException e )
+ {
+ descriptors.put( key, BadDescriptor.INSTANCE );
+ }
+
+ public Object toKey( VersionRangeRequest request )
+ {
+ return new ConstraintKey( request );
+ }
+
+ public VersionRangeResult getConstraint( Object key, VersionRangeRequest request )
+ {
+ Constraint constraint = constraints.get( key );
+ if ( constraint != null )
+ {
+ return constraint.toResult( request );
+ }
+ return null;
+ }
+
+ public void putConstraint( Object key, VersionRangeResult result )
+ {
+ constraints.put( key, new Constraint( result ) );
+ }
+
+ public Object toKey( Artifact artifact, List<RemoteRepository> repositories, DependencySelector selector,
+ DependencyManager manager, DependencyTraverser traverser, VersionFilter filter )
+ {
+ return new GraphKey( artifact, repositories, selector, manager, traverser, filter );
+ }
+
+ public List<DependencyNode> getChildren( Object key )
+ {
+ return nodes.get( key );
+ }
+
+ public void putChildren( Object key, List<DependencyNode> children )
+ {
+ nodes.put( key, children );
+ }
+
+ abstract static class Descriptor
+ {
+
+ public abstract ArtifactDescriptorResult toResult( ArtifactDescriptorRequest request );
+
+ }
+
+ static final class GoodDescriptor
+ extends Descriptor
+ {
+
+ final Artifact artifact;
+
+ final List<Artifact> relocations;
+
+ final Collection<Artifact> aliases;
+
+ final List<RemoteRepository> repositories;
+
+ final List<Dependency> dependencies;
+
+ final List<Dependency> managedDependencies;
+
+ GoodDescriptor( ArtifactDescriptorResult result )
+ {
+ artifact = result.getArtifact();
+ relocations = result.getRelocations();
+ aliases = result.getAliases();
+ dependencies = result.getDependencies();
+ managedDependencies = result.getManagedDependencies();
+ repositories = result.getRepositories();
+ }
+
+ public ArtifactDescriptorResult toResult( ArtifactDescriptorRequest request )
+ {
+ ArtifactDescriptorResult result = new ArtifactDescriptorResult( request );
+ result.setArtifact( artifact );
+ result.setRelocations( relocations );
+ result.setAliases( aliases );
+ result.setDependencies( dependencies );
+ result.setManagedDependencies( managedDependencies );
+ result.setRepositories( repositories );
+ return result;
+ }
+
+ }
+
+ static final class BadDescriptor
+ extends Descriptor
+ {
+
+ static final BadDescriptor INSTANCE = new BadDescriptor();
+
+ public ArtifactDescriptorResult toResult( ArtifactDescriptorRequest request )
+ {
+ return NO_DESCRIPTOR;
+ }
+
+ }
+
+ static final class Constraint
+ {
+
+ final VersionRepo[] repositories;
+
+ final VersionConstraint versionConstraint;
+
+ Constraint( VersionRangeResult result )
+ {
+ versionConstraint = result.getVersionConstraint();
+ List<Version> versions = result.getVersions();
+ repositories = new VersionRepo[versions.size()];
+ int i = 0;
+ for ( Version version : versions )
+ {
+ repositories[i++] = new VersionRepo( version, result.getRepository( version ) );
+ }
+ }
+
+ public VersionRangeResult toResult( VersionRangeRequest request )
+ {
+ VersionRangeResult result = new VersionRangeResult( request );
+ for ( VersionRepo vr : repositories )
+ {
+ result.addVersion( vr.version );
+ result.setRepository( vr.version, vr.repo );
+ }
+ result.setVersionConstraint( versionConstraint );
+ return result;
+ }
+
+ static final class VersionRepo
+ {
+
+ final Version version;
+
+ final ArtifactRepository repo;
+
+ VersionRepo( Version version, ArtifactRepository repo )
+ {
+ this.version = version;
+ this.repo = repo;
+ }
+
+ }
+
+ }
+
+ static final class ConstraintKey
+ {
+
+ private final Artifact artifact;
+
+ private final List<RemoteRepository> repositories;
+
+ private final int hashCode;
+
+ ConstraintKey( VersionRangeRequest request )
+ {
+ artifact = request.getArtifact();
+ repositories = request.getRepositories();
+ hashCode = artifact.hashCode();
+ }
+
+ @Override
+ public boolean equals( Object obj )
+ {
+ if ( obj == this )
+ {
+ return true;
+ }
+ else if ( !( obj instanceof ConstraintKey ) )
+ {
+ return false;
+ }
+ ConstraintKey that = (ConstraintKey) obj;
+ return artifact.equals( that.artifact ) && equals( repositories, that.repositories );
+ }
+
+ private static boolean equals( List<RemoteRepository> repos1, List<RemoteRepository> repos2 )
+ {
+ if ( repos1.size() != repos2.size() )
+ {
+ return false;
+ }
+ for ( int i = 0, n = repos1.size(); i < n; i++ )
+ {
+ RemoteRepository repo1 = repos1.get( i );
+ RemoteRepository repo2 = repos2.get( i );
+ if ( repo1.isRepositoryManager() != repo2.isRepositoryManager() )
+ {
+ return false;
+ }
+ if ( repo1.isRepositoryManager() )
+ {
+ if ( !equals( repo1.getMirroredRepositories(), repo2.getMirroredRepositories() ) )
+ {
+ return false;
+ }
+ }
+ else if ( !repo1.getUrl().equals( repo2.getUrl() ) )
+ {
+ return false;
+ }
+ else if ( repo1.getPolicy( true ).isEnabled() != repo2.getPolicy( true ).isEnabled() )
+ {
+ return false;
+ }
+ else if ( repo1.getPolicy( false ).isEnabled() != repo2.getPolicy( false ).isEnabled() )
+ {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return hashCode;
+ }
+
+ }
+
+ static final class GraphKey
+ {
+
+ private final Artifact artifact;
+
+ private final List<RemoteRepository> repositories;
+
+ private final DependencySelector selector;
+
+ private final DependencyManager manager;
+
+ private final DependencyTraverser traverser;
+
+ private final VersionFilter filter;
+
+ private final int hashCode;
+
+ GraphKey( Artifact artifact, List<RemoteRepository> repositories, DependencySelector selector,
+ DependencyManager manager, DependencyTraverser traverser, VersionFilter filter )
+ {
+ this.artifact = artifact;
+ this.repositories = repositories;
+ this.selector = selector;
+ this.manager = manager;
+ this.traverser = traverser;
+ this.filter = filter;
+
+ int hash = 17;
+ hash = hash * 31 + artifact.hashCode();
+ hash = hash * 31 + repositories.hashCode();
+ hash = hash * 31 + hash( selector );
+ hash = hash * 31 + hash( manager );
+ hash = hash * 31 + hash( traverser );
+ hash = hash * 31 + hash( filter );
+ hashCode = hash;
+ }
+
+ @Override
+ public boolean equals( Object obj )
+ {
+ if ( obj == this )
+ {
+ return true;
+ }
+ else if ( !( obj instanceof GraphKey ) )
+ {
+ return false;
+ }
+ GraphKey that = (GraphKey) obj;
+ return artifact.equals( that.artifact ) && repositories.equals( that.repositories )
+ && eq( selector, that.selector ) && eq( manager, that.manager ) && eq( traverser, that.traverser )
+ && eq( filter, that.filter );
+ }
+
+ @Override
+ public int hashCode()
+ {
+ return hashCode;
+ }
+
+ private static <T> boolean eq( T o1, T o2 )
+ {
+ return ( o1 != null ) ? o1.equals( o2 ) : o2 == null;
+ }
+
+ private static int hash( Object o )
+ {
+ return ( o != null ) ? o.hashCode() : 0;
+ }
+
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCollectionContext.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCollectionContext.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCollectionContext.java
new file mode 100644
index 0000000..3bf4fe1
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCollectionContext.java
@@ -0,0 +1,86 @@
+package org.eclipse.aether.internal.impl.collect;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.List;
+
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.collection.DependencyCollectionContext;
+import org.eclipse.aether.graph.Dependency;
+
+/**
+ * @see DefaultDependencyCollector
+ */
+final class DefaultDependencyCollectionContext
+ implements DependencyCollectionContext
+{
+
+ private final RepositorySystemSession session;
+
+ private Artifact artifact;
+
+ private Dependency dependency;
+
+ private List<Dependency> managedDependencies;
+
+ DefaultDependencyCollectionContext( RepositorySystemSession session, Artifact artifact,
+ Dependency dependency, List<Dependency> managedDependencies )
+ {
+ this.session = session;
+ this.artifact = ( dependency != null ) ? dependency.getArtifact() : artifact;
+ this.dependency = dependency;
+ this.managedDependencies = managedDependencies;
+ }
+
+ public RepositorySystemSession getSession()
+ {
+ return session;
+ }
+
+ public Artifact getArtifact()
+ {
+ return artifact;
+ }
+
+ public Dependency getDependency()
+ {
+ return dependency;
+ }
+
+ public List<Dependency> getManagedDependencies()
+ {
+ return managedDependencies;
+ }
+
+ public void set( Dependency dependency, List<Dependency> managedDependencies )
+ {
+ artifact = dependency.getArtifact();
+ this.dependency = dependency;
+ this.managedDependencies = managedDependencies;
+ }
+
+ @Override
+ public String toString()
+ {
+ return String.valueOf( getDependency() );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCollector.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCollector.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCollector.java
new file mode 100644
index 0000000..f96d923
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCollector.java
@@ -0,0 +1,896 @@
+package org.eclipse.aether.internal.impl.collect;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import static java.util.Objects.requireNonNull;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.eclipse.aether.DefaultRepositorySystemSession;
+import org.eclipse.aether.RepositoryException;
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.RequestTrace;
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.ArtifactProperties;
+import org.eclipse.aether.collection.CollectRequest;
+import org.eclipse.aether.collection.CollectResult;
+import org.eclipse.aether.collection.DependencyCollectionException;
+import org.eclipse.aether.collection.DependencyGraphTransformer;
+import org.eclipse.aether.collection.DependencyManagement;
+import org.eclipse.aether.collection.DependencyManager;
+import org.eclipse.aether.collection.DependencySelector;
+import org.eclipse.aether.collection.DependencyTraverser;
+import org.eclipse.aether.collection.VersionFilter;
+import org.eclipse.aether.graph.DefaultDependencyNode;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.DependencyNode;
+import org.eclipse.aether.graph.Exclusion;
+import org.eclipse.aether.impl.ArtifactDescriptorReader;
+import org.eclipse.aether.impl.DependencyCollector;
+import org.eclipse.aether.impl.RemoteRepositoryManager;
+import org.eclipse.aether.impl.VersionRangeResolver;
+import org.eclipse.aether.repository.ArtifactRepository;
+import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.resolution.ArtifactDescriptorException;
+import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
+import org.eclipse.aether.resolution.ArtifactDescriptorResult;
+import org.eclipse.aether.resolution.VersionRangeRequest;
+import org.eclipse.aether.resolution.VersionRangeResolutionException;
+import org.eclipse.aether.resolution.VersionRangeResult;
+import org.eclipse.aether.spi.locator.Service;
+import org.eclipse.aether.spi.locator.ServiceLocator;
+import org.eclipse.aether.spi.log.Logger;
+import org.eclipse.aether.spi.log.LoggerFactory;
+import org.eclipse.aether.spi.log.NullLoggerFactory;
+import org.eclipse.aether.util.ConfigUtils;
+import org.eclipse.aether.util.graph.manager.DependencyManagerUtils;
+import org.eclipse.aether.util.graph.transformer.TransformationContextKeys;
+import org.eclipse.aether.version.Version;
+
+/**
+ */
+@Named
+public class DefaultDependencyCollector
+ implements DependencyCollector, Service
+{
+
+ private static final String CONFIG_PROP_MAX_EXCEPTIONS = "aether.dependencyCollector.maxExceptions";
+
+ private static final String CONFIG_PROP_MAX_CYCLES = "aether.dependencyCollector.maxCycles";
+
+ private Logger logger = NullLoggerFactory.LOGGER;
+
+ private RemoteRepositoryManager remoteRepositoryManager;
+
+ private ArtifactDescriptorReader descriptorReader;
+
+ private VersionRangeResolver versionRangeResolver;
+
+ public DefaultDependencyCollector()
+ {
+ // enables default constructor
+ }
+
+ @Inject
+ DefaultDependencyCollector( RemoteRepositoryManager remoteRepositoryManager,
+ ArtifactDescriptorReader artifactDescriptorReader,
+ VersionRangeResolver versionRangeResolver, LoggerFactory loggerFactory )
+ {
+ setRemoteRepositoryManager( remoteRepositoryManager );
+ setArtifactDescriptorReader( artifactDescriptorReader );
+ setVersionRangeResolver( versionRangeResolver );
+ setLoggerFactory( loggerFactory );
+ }
+
+ public void initService( ServiceLocator locator )
+ {
+ setLoggerFactory( locator.getService( LoggerFactory.class ) );
+ setRemoteRepositoryManager( locator.getService( RemoteRepositoryManager.class ) );
+ setArtifactDescriptorReader( locator.getService( ArtifactDescriptorReader.class ) );
+ setVersionRangeResolver( locator.getService( VersionRangeResolver.class ) );
+ }
+
+ public DefaultDependencyCollector setLoggerFactory( LoggerFactory loggerFactory )
+ {
+ this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() );
+ return this;
+ }
+
+ public DefaultDependencyCollector setRemoteRepositoryManager( RemoteRepositoryManager remoteRepositoryManager )
+ {
+ this.remoteRepositoryManager = requireNonNull( remoteRepositoryManager, "remote repository provider cannot be null" );
+ return this;
+ }
+
+ public DefaultDependencyCollector setArtifactDescriptorReader( ArtifactDescriptorReader artifactDescriptorReader )
+ {
+ descriptorReader = requireNonNull( artifactDescriptorReader, "artifact descriptor reader cannot be null" );
+ return this;
+ }
+
+ public DefaultDependencyCollector setVersionRangeResolver( VersionRangeResolver versionRangeResolver )
+ {
+ this.versionRangeResolver = requireNonNull( versionRangeResolver, "version range resolver cannot be null" );
+ return this;
+ }
+
+ public CollectResult collectDependencies( RepositorySystemSession session, CollectRequest request )
+ throws DependencyCollectionException
+ {
+ session = optimizeSession( session );
+
+ RequestTrace trace = RequestTrace.newChild( request.getTrace(), request );
+
+ CollectResult result = new CollectResult( request );
+
+ DependencySelector depSelector = session.getDependencySelector();
+ DependencyManager depManager = session.getDependencyManager();
+ DependencyTraverser depTraverser = session.getDependencyTraverser();
+ VersionFilter verFilter = session.getVersionFilter();
+
+ Dependency root = request.getRoot();
+ List<RemoteRepository> repositories = request.getRepositories();
+ List<Dependency> dependencies = request.getDependencies();
+ List<Dependency> managedDependencies = request.getManagedDependencies();
+
+ Map<String, Object> stats = logger.isDebugEnabled() ? new LinkedHashMap<String, Object>() : null;
+ long time1 = System.nanoTime();
+
+ DefaultDependencyNode node;
+ if ( root != null )
+ {
+ List<? extends Version> versions;
+ VersionRangeResult rangeResult;
+ try
+ {
+ VersionRangeRequest rangeRequest =
+ new VersionRangeRequest( root.getArtifact(), request.getRepositories(),
+ request.getRequestContext() );
+ rangeRequest.setTrace( trace );
+ rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
+ versions = filterVersions( root, rangeResult, verFilter, new DefaultVersionFilterContext( session ) );
+ }
+ catch ( VersionRangeResolutionException e )
+ {
+ result.addException( e );
+ throw new DependencyCollectionException( result, e.getMessage() );
+ }
+
+ Version version = versions.get( versions.size() - 1 );
+ root = root.setArtifact( root.getArtifact().setVersion( version.toString() ) );
+
+ ArtifactDescriptorResult descriptorResult;
+ try
+ {
+ ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
+ descriptorRequest.setArtifact( root.getArtifact() );
+ descriptorRequest.setRepositories( request.getRepositories() );
+ descriptorRequest.setRequestContext( request.getRequestContext() );
+ descriptorRequest.setTrace( trace );
+ if ( isLackingDescriptor( root.getArtifact() ) )
+ {
+ descriptorResult = new ArtifactDescriptorResult( descriptorRequest );
+ }
+ else
+ {
+ descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
+ }
+ }
+ catch ( ArtifactDescriptorException e )
+ {
+ result.addException( e );
+ throw new DependencyCollectionException( result, e.getMessage() );
+ }
+
+ root = root.setArtifact( descriptorResult.getArtifact() );
+
+ if ( !session.isIgnoreArtifactDescriptorRepositories() )
+ {
+ repositories = remoteRepositoryManager.aggregateRepositories( session, repositories,
+ descriptorResult.getRepositories(),
+ true );
+ }
+ dependencies = mergeDeps( dependencies, descriptorResult.getDependencies() );
+ managedDependencies = mergeDeps( managedDependencies, descriptorResult.getManagedDependencies() );
+
+ node = new DefaultDependencyNode( root );
+ node.setRequestContext( request.getRequestContext() );
+ node.setRelocations( descriptorResult.getRelocations() );
+ node.setVersionConstraint( rangeResult.getVersionConstraint() );
+ node.setVersion( version );
+ node.setAliases( descriptorResult.getAliases() );
+ node.setRepositories( request.getRepositories() );
+ }
+ else
+ {
+ node = new DefaultDependencyNode( request.getRootArtifact() );
+ node.setRequestContext( request.getRequestContext() );
+ node.setRepositories( request.getRepositories() );
+ }
+
+ result.setRoot( node );
+
+ boolean traverse = root == null || depTraverser == null || depTraverser.traverseDependency( root );
+ String errorPath = null;
+ if ( traverse && !dependencies.isEmpty() )
+ {
+ DataPool pool = new DataPool( session );
+
+ NodeStack nodes = new NodeStack();
+ nodes.push( node );
+
+ DefaultDependencyCollectionContext context =
+ new DefaultDependencyCollectionContext( session, request.getRootArtifact(), root, managedDependencies );
+
+ DefaultVersionFilterContext versionContext = new DefaultVersionFilterContext( session );
+
+ Args args = new Args( session, trace, pool, nodes, context, versionContext, request );
+ Results results = new Results( result, session );
+
+ process( args, results, dependencies, repositories,
+ depSelector != null ? depSelector.deriveChildSelector( context ) : null,
+ depManager != null ? depManager.deriveChildManager( context ) : null,
+ depTraverser != null ? depTraverser.deriveChildTraverser( context ) : null,
+ verFilter != null ? verFilter.deriveChildFilter( context ) : null );
+
+ errorPath = results.errorPath;
+ }
+
+ long time2 = System.nanoTime();
+
+ DependencyGraphTransformer transformer = session.getDependencyGraphTransformer();
+ if ( transformer != null )
+ {
+ try
+ {
+ DefaultDependencyGraphTransformationContext context =
+ new DefaultDependencyGraphTransformationContext( session );
+ context.put( TransformationContextKeys.STATS, stats );
+ result.setRoot( transformer.transformGraph( node, context ) );
+ }
+ catch ( RepositoryException e )
+ {
+ result.addException( e );
+ }
+ }
+
+ if ( stats != null )
+ {
+ long time3 = System.nanoTime();
+ stats.put( "DefaultDependencyCollector.collectTime", time2 - time1 );
+ stats.put( "DefaultDependencyCollector.transformTime", time3 - time2 );
+ logger.debug( "Dependency collection stats: " + stats );
+ }
+
+ if ( errorPath != null )
+ {
+ throw new DependencyCollectionException( result, "Failed to collect dependencies at " + errorPath );
+ }
+ if ( !result.getExceptions().isEmpty() )
+ {
+ throw new DependencyCollectionException( result );
+ }
+
+ return result;
+ }
+
+ private static RepositorySystemSession optimizeSession( RepositorySystemSession session )
+ {
+ DefaultRepositorySystemSession optimized = new DefaultRepositorySystemSession( session );
+ optimized.setArtifactTypeRegistry( CachingArtifactTypeRegistry.newInstance( session ) );
+ return optimized;
+ }
+
+ private List<Dependency> mergeDeps( List<Dependency> dominant, List<Dependency> recessive )
+ {
+ List<Dependency> result;
+ if ( dominant == null || dominant.isEmpty() )
+ {
+ result = recessive;
+ }
+ else if ( recessive == null || recessive.isEmpty() )
+ {
+ result = dominant;
+ }
+ else
+ {
+ int initialCapacity = dominant.size() + recessive.size();
+ result = new ArrayList<Dependency>( initialCapacity );
+ Collection<String> ids = new HashSet<String>( initialCapacity, 1.0f );
+ for ( Dependency dependency : dominant )
+ {
+ ids.add( getId( dependency.getArtifact() ) );
+ result.add( dependency );
+ }
+ for ( Dependency dependency : recessive )
+ {
+ if ( !ids.contains( getId( dependency.getArtifact() ) ) )
+ {
+ result.add( dependency );
+ }
+ }
+ }
+ return result;
+ }
+
+ private static String getId( Artifact a )
+ {
+ return a.getGroupId() + ':' + a.getArtifactId() + ':' + a.getClassifier() + ':' + a.getExtension();
+ }
+
+ private void process( final Args args, Results results, List<Dependency> dependencies,
+ List<RemoteRepository> repositories, DependencySelector depSelector,
+ DependencyManager depManager, DependencyTraverser depTraverser, VersionFilter verFilter )
+ {
+ for ( Dependency dependency : dependencies )
+ {
+ processDependency( args, results, repositories, depSelector, depManager, depTraverser, verFilter,
+ dependency );
+ }
+ }
+
+ private void processDependency( Args args, Results results, List<RemoteRepository> repositories,
+ DependencySelector depSelector, DependencyManager depManager,
+ DependencyTraverser depTraverser, VersionFilter verFilter, Dependency dependency )
+ {
+
+ List<Artifact> relocations = Collections.emptyList();
+ boolean disableVersionManagement = false;
+ processDependency( args, results, repositories, depSelector, depManager, depTraverser, verFilter, dependency,
+ relocations, disableVersionManagement );
+ }
+
+ private void processDependency( Args args, Results results, List<RemoteRepository> repositories,
+ DependencySelector depSelector, DependencyManager depManager,
+ DependencyTraverser depTraverser, VersionFilter verFilter, Dependency dependency,
+ List<Artifact> relocations, boolean disableVersionManagement )
+ {
+
+ if ( depSelector != null && !depSelector.selectDependency( dependency ) )
+ {
+ return;
+ }
+
+ PremanagedDependency preManaged =
+ PremanagedDependency.create( depManager, dependency, disableVersionManagement, args.premanagedState );
+ dependency = preManaged.managedDependency;
+
+ boolean noDescriptor = isLackingDescriptor( dependency.getArtifact() );
+
+ boolean traverse = !noDescriptor && ( depTraverser == null || depTraverser.traverseDependency( dependency ) );
+
+ List<? extends Version> versions;
+ VersionRangeResult rangeResult;
+ try
+ {
+ VersionRangeRequest rangeRequest = createVersionRangeRequest( args, repositories, dependency );
+
+ rangeResult = cachedResolveRangeResult( rangeRequest, args.pool, args.session );
+
+ versions = filterVersions( dependency, rangeResult, verFilter, args.versionContext );
+ }
+ catch ( VersionRangeResolutionException e )
+ {
+ results.addException( dependency, e, args.nodes );
+ return;
+ }
+
+ for ( Version version : versions )
+ {
+ Artifact originalArtifact = dependency.getArtifact().setVersion( version.toString() );
+ Dependency d = dependency.setArtifact( originalArtifact );
+
+ ArtifactDescriptorRequest descriptorRequest = createArtifactDescriptorRequest( args, repositories, d );
+
+ final ArtifactDescriptorResult descriptorResult =
+ getArtifactDescriptorResult( args, results, noDescriptor, d, descriptorRequest );
+ if ( descriptorResult != null )
+ {
+ d = d.setArtifact( descriptorResult.getArtifact() );
+
+ DependencyNode node = args.nodes.top();
+
+ int cycleEntry = args.nodes.find( d.getArtifact() );
+ if ( cycleEntry >= 0 )
+ {
+ results.addCycle( args.nodes, cycleEntry, d );
+ DependencyNode cycleNode = args.nodes.get( cycleEntry );
+ if ( cycleNode.getDependency() != null )
+ {
+ DefaultDependencyNode child =
+ createDependencyNode( relocations, preManaged, rangeResult, version, d, descriptorResult,
+ cycleNode );
+ node.getChildren().add( child );
+ continue;
+ }
+ }
+
+ if ( !descriptorResult.getRelocations().isEmpty() )
+ {
+ boolean disableVersionManagementSubsequently =
+ originalArtifact.getGroupId().equals( d.getArtifact().getGroupId() )
+ && originalArtifact.getArtifactId().equals( d.getArtifact().getArtifactId() );
+
+ processDependency( args, results, repositories, depSelector, depManager, depTraverser, verFilter, d,
+ descriptorResult.getRelocations(), disableVersionManagementSubsequently );
+ return;
+ }
+ else
+ {
+ d = args.pool.intern( d.setArtifact( args.pool.intern( d.getArtifact() ) ) );
+
+ List<RemoteRepository> repos =
+ getRemoteRepositories( rangeResult.getRepository( version ), repositories );
+
+ DefaultDependencyNode child =
+ createDependencyNode( relocations, preManaged, rangeResult, version, d,
+ descriptorResult.getAliases(), repos, args.request.getRequestContext() );
+
+ node.getChildren().add( child );
+
+ boolean recurse = traverse && !descriptorResult.getDependencies().isEmpty();
+ if ( recurse )
+ {
+ doRecurse( args, results, repositories, depSelector, depManager, depTraverser, verFilter, d,
+ descriptorResult, child );
+ }
+ }
+ }
+ else
+ {
+ DependencyNode node = args.nodes.top();
+ List<RemoteRepository> repos =
+ getRemoteRepositories( rangeResult.getRepository( version ), repositories );
+ DefaultDependencyNode child =
+ createDependencyNode( relocations, preManaged, rangeResult, version, d, null, repos,
+ args.request.getRequestContext() );
+ node.getChildren().add( child );
+ }
+ }
+ }
+
+ private void doRecurse( Args args, Results results, List<RemoteRepository> repositories,
+ DependencySelector depSelector, DependencyManager depManager,
+ DependencyTraverser depTraverser, VersionFilter verFilter, Dependency d,
+ ArtifactDescriptorResult descriptorResult, DefaultDependencyNode child )
+ {
+ DefaultDependencyCollectionContext context = args.collectionContext;
+ context.set( d, descriptorResult.getManagedDependencies() );
+
+ DependencySelector childSelector = depSelector != null ? depSelector.deriveChildSelector( context ) : null;
+ DependencyManager childManager = depManager != null ? depManager.deriveChildManager( context ) : null;
+ DependencyTraverser childTraverser = depTraverser != null ? depTraverser.deriveChildTraverser( context ) : null;
+ VersionFilter childFilter = verFilter != null ? verFilter.deriveChildFilter( context ) : null;
+
+ final List<RemoteRepository> childRepos =
+ args.ignoreRepos
+ ? repositories
+ : remoteRepositoryManager.aggregateRepositories( args.session, repositories,
+ descriptorResult.getRepositories(), true );
+
+ Object key =
+ args.pool.toKey( d.getArtifact(), childRepos, childSelector, childManager, childTraverser, childFilter );
+
+ List<DependencyNode> children = args.pool.getChildren( key );
+ if ( children == null )
+ {
+ args.pool.putChildren( key, child.getChildren() );
+
+ args.nodes.push( child );
+
+ process( args, results, descriptorResult.getDependencies(), childRepos, childSelector, childManager,
+ childTraverser, childFilter );
+
+ args.nodes.pop();
+ }
+ else
+ {
+ child.setChildren( children );
+ }
+ }
+
+ private ArtifactDescriptorResult getArtifactDescriptorResult( Args args, Results results, boolean noDescriptor,
+ Dependency d,
+ ArtifactDescriptorRequest descriptorRequest )
+ {
+ return noDescriptor
+ ? new ArtifactDescriptorResult( descriptorRequest )
+ : resolveCachedArtifactDescriptor( args.pool, descriptorRequest, args.session, d, results, args );
+
+ }
+
+ private ArtifactDescriptorResult resolveCachedArtifactDescriptor( DataPool pool,
+ ArtifactDescriptorRequest descriptorRequest,
+ RepositorySystemSession session, Dependency d,
+ Results results, Args args )
+ {
+ Object key = pool.toKey( descriptorRequest );
+ ArtifactDescriptorResult descriptorResult = pool.getDescriptor( key, descriptorRequest );
+ if ( descriptorResult == null )
+ {
+ try
+ {
+ descriptorResult = descriptorReader.readArtifactDescriptor( session, descriptorRequest );
+ pool.putDescriptor( key, descriptorResult );
+ }
+ catch ( ArtifactDescriptorException e )
+ {
+ results.addException( d, e, args.nodes );
+ pool.putDescriptor( key, e );
+ return null;
+ }
+
+ }
+ else if ( descriptorResult == DataPool.NO_DESCRIPTOR )
+ {
+ return null;
+ }
+
+ return descriptorResult;
+ }
+
+ private static DefaultDependencyNode createDependencyNode( List<Artifact> relocations,
+ PremanagedDependency preManaged,
+ VersionRangeResult rangeResult, Version version,
+ Dependency d, Collection<Artifact> aliases,
+ List<RemoteRepository> repos, String requestContext )
+ {
+ DefaultDependencyNode child = new DefaultDependencyNode( d );
+ preManaged.applyTo( child );
+ child.setRelocations( relocations );
+ child.setVersionConstraint( rangeResult.getVersionConstraint() );
+ child.setVersion( version );
+ child.setAliases( aliases );
+ child.setRepositories( repos );
+ child.setRequestContext( requestContext );
+ return child;
+ }
+
+ private static DefaultDependencyNode createDependencyNode( List<Artifact> relocations,
+ PremanagedDependency preManaged,
+ VersionRangeResult rangeResult, Version version,
+ Dependency d, ArtifactDescriptorResult descriptorResult,
+ DependencyNode cycleNode )
+ {
+ DefaultDependencyNode child =
+ createDependencyNode( relocations, preManaged, rangeResult, version, d, descriptorResult.getAliases(),
+ cycleNode.getRepositories(), cycleNode.getRequestContext() );
+ child.setChildren( cycleNode.getChildren() );
+ return child;
+ }
+
+ private static ArtifactDescriptorRequest createArtifactDescriptorRequest( Args args,
+ List<RemoteRepository> repositories,
+ Dependency d )
+ {
+ ArtifactDescriptorRequest descriptorRequest = new ArtifactDescriptorRequest();
+ descriptorRequest.setArtifact( d.getArtifact() );
+ descriptorRequest.setRepositories( repositories );
+ descriptorRequest.setRequestContext( args.request.getRequestContext() );
+ descriptorRequest.setTrace( args.trace );
+ return descriptorRequest;
+ }
+
+ private static VersionRangeRequest createVersionRangeRequest( Args args, List<RemoteRepository> repositories,
+ Dependency dependency )
+ {
+ VersionRangeRequest rangeRequest = new VersionRangeRequest();
+ rangeRequest.setArtifact( dependency.getArtifact() );
+ rangeRequest.setRepositories( repositories );
+ rangeRequest.setRequestContext( args.request.getRequestContext() );
+ rangeRequest.setTrace( args.trace );
+ return rangeRequest;
+ }
+
+ private VersionRangeResult cachedResolveRangeResult( VersionRangeRequest rangeRequest, DataPool pool,
+ RepositorySystemSession session )
+ throws VersionRangeResolutionException
+ {
+ Object key = pool.toKey( rangeRequest );
+ VersionRangeResult rangeResult = pool.getConstraint( key, rangeRequest );
+ if ( rangeResult == null )
+ {
+ rangeResult = versionRangeResolver.resolveVersionRange( session, rangeRequest );
+ pool.putConstraint( key, rangeResult );
+ }
+ return rangeResult;
+ }
+
+ private static boolean isLackingDescriptor( Artifact artifact )
+ {
+ return artifact.getProperty( ArtifactProperties.LOCAL_PATH, null ) != null;
+ }
+
+ private static List<RemoteRepository> getRemoteRepositories( ArtifactRepository repository,
+ List<RemoteRepository> repositories )
+ {
+ if ( repository instanceof RemoteRepository )
+ {
+ return Collections.singletonList( (RemoteRepository) repository );
+ }
+ if ( repository != null )
+ {
+ return Collections.emptyList();
+ }
+ return repositories;
+ }
+
+ private static List<? extends Version> filterVersions( Dependency dependency, VersionRangeResult rangeResult,
+ VersionFilter verFilter,
+ DefaultVersionFilterContext verContext )
+ throws VersionRangeResolutionException
+ {
+ if ( rangeResult.getVersions().isEmpty() )
+ {
+ throw new VersionRangeResolutionException( rangeResult,
+ "No versions available for " + dependency.getArtifact()
+ + " within specified range" );
+ }
+
+ List<? extends Version> versions;
+ if ( verFilter != null && rangeResult.getVersionConstraint().getRange() != null )
+ {
+ verContext.set( dependency, rangeResult );
+ try
+ {
+ verFilter.filterVersions( verContext );
+ }
+ catch ( RepositoryException e )
+ {
+ throw new VersionRangeResolutionException( rangeResult,
+ "Failed to filter versions for " + dependency.getArtifact()
+ + ": " + e.getMessage(), e );
+ }
+ versions = verContext.get();
+ if ( versions.isEmpty() )
+ {
+ throw new VersionRangeResolutionException( rangeResult,
+ "No acceptable versions for " + dependency.getArtifact()
+ + ": " + rangeResult.getVersions() );
+ }
+ }
+ else
+ {
+ versions = rangeResult.getVersions();
+ }
+ return versions;
+ }
+
+ static class Args
+ {
+
+ final RepositorySystemSession session;
+
+ final boolean ignoreRepos;
+
+ final boolean premanagedState;
+
+ final RequestTrace trace;
+
+ final DataPool pool;
+
+ final NodeStack nodes;
+
+ final DefaultDependencyCollectionContext collectionContext;
+
+ final DefaultVersionFilterContext versionContext;
+
+ final CollectRequest request;
+
+ Args( RepositorySystemSession session, RequestTrace trace, DataPool pool, NodeStack nodes,
+ DefaultDependencyCollectionContext collectionContext, DefaultVersionFilterContext versionContext,
+ CollectRequest request )
+ {
+ this.session = session;
+ this.request = request;
+ this.ignoreRepos = session.isIgnoreArtifactDescriptorRepositories();
+ this.premanagedState = ConfigUtils.getBoolean( session, false, DependencyManagerUtils.CONFIG_PROP_VERBOSE );
+ this.trace = trace;
+ this.pool = pool;
+ this.nodes = nodes;
+ this.collectionContext = collectionContext;
+ this.versionContext = versionContext;
+ }
+
+ }
+
+ static class Results
+ {
+
+ private final CollectResult result;
+
+ final int maxExceptions;
+
+ final int maxCycles;
+
+ String errorPath;
+
+ Results( CollectResult result, RepositorySystemSession session )
+ {
+ this.result = result;
+ this.maxExceptions = ConfigUtils.getInteger( session, 50, CONFIG_PROP_MAX_EXCEPTIONS );
+ this.maxCycles = ConfigUtils.getInteger( session, 10, CONFIG_PROP_MAX_CYCLES );
+ }
+
+ public void addException( Dependency dependency, Exception e, NodeStack nodes )
+ {
+ if ( maxExceptions < 0 || result.getExceptions().size() < maxExceptions )
+ {
+ result.addException( e );
+ if ( errorPath == null )
+ {
+ StringBuilder buffer = new StringBuilder( 256 );
+ for ( int i = 0; i < nodes.size(); i++ )
+ {
+ if ( buffer.length() > 0 )
+ {
+ buffer.append( " -> " );
+ }
+ Dependency dep = nodes.get( i ).getDependency();
+ if ( dep != null )
+ {
+ buffer.append( dep.getArtifact() );
+ }
+ }
+ if ( buffer.length() > 0 )
+ {
+ buffer.append( " -> " );
+ }
+ buffer.append( dependency.getArtifact() );
+ errorPath = buffer.toString();
+ }
+ }
+ }
+
+ public void addCycle( NodeStack nodes, int cycleEntry, Dependency dependency )
+ {
+ if ( maxCycles < 0 || result.getCycles().size() < maxCycles )
+ {
+ result.addCycle( new DefaultDependencyCycle( nodes, cycleEntry, dependency ) );
+ }
+ }
+
+ }
+
+ static class PremanagedDependency
+ {
+
+ final String premanagedVersion;
+
+ final String premanagedScope;
+
+ final Boolean premanagedOptional;
+
+ /**
+ * @since 1.1.0
+ */
+ final Collection<Exclusion> premanagedExclusions;
+
+ /**
+ * @since 1.1.0
+ */
+ final Map<String, String> premanagedProperties;
+
+ final int managedBits;
+
+ final Dependency managedDependency;
+
+ final boolean premanagedState;
+
+ PremanagedDependency( String premanagedVersion, String premanagedScope, Boolean premanagedOptional,
+ Collection<Exclusion> premanagedExclusions, Map<String, String> premanagedProperties,
+ int managedBits, Dependency managedDependency, boolean premanagedState )
+ {
+ this.premanagedVersion = premanagedVersion;
+ this.premanagedScope = premanagedScope;
+ this.premanagedOptional = premanagedOptional;
+ this.premanagedExclusions =
+ premanagedExclusions != null
+ ? Collections.unmodifiableCollection( new ArrayList<Exclusion>( premanagedExclusions ) )
+ : null;
+
+ this.premanagedProperties =
+ premanagedProperties != null
+ ? Collections.unmodifiableMap( new HashMap<String, String>( premanagedProperties ) )
+ : null;
+
+ this.managedBits = managedBits;
+ this.managedDependency = managedDependency;
+ this.premanagedState = premanagedState;
+ }
+
+ static PremanagedDependency create( DependencyManager depManager, Dependency dependency,
+ boolean disableVersionManagement, boolean premanagedState )
+ {
+ DependencyManagement depMngt = depManager != null ? depManager.manageDependency( dependency ) : null;
+
+ int managedBits = 0;
+ String premanagedVersion = null;
+ String premanagedScope = null;
+ Boolean premanagedOptional = null;
+ Collection<Exclusion> premanagedExclusions = null;
+ Map<String, String> premanagedProperties = null;
+
+ if ( depMngt != null )
+ {
+ if ( depMngt.getVersion() != null && !disableVersionManagement )
+ {
+ Artifact artifact = dependency.getArtifact();
+ premanagedVersion = artifact.getVersion();
+ dependency = dependency.setArtifact( artifact.setVersion( depMngt.getVersion() ) );
+ managedBits |= DependencyNode.MANAGED_VERSION;
+ }
+ if ( depMngt.getProperties() != null )
+ {
+ Artifact artifact = dependency.getArtifact();
+ premanagedProperties = artifact.getProperties();
+ dependency = dependency.setArtifact( artifact.setProperties( depMngt.getProperties() ) );
+ managedBits |= DependencyNode.MANAGED_PROPERTIES;
+ }
+ if ( depMngt.getScope() != null )
+ {
+ premanagedScope = dependency.getScope();
+ dependency = dependency.setScope( depMngt.getScope() );
+ managedBits |= DependencyNode.MANAGED_SCOPE;
+ }
+ if ( depMngt.getOptional() != null )
+ {
+ premanagedOptional = dependency.isOptional();
+ dependency = dependency.setOptional( depMngt.getOptional() );
+ managedBits |= DependencyNode.MANAGED_OPTIONAL;
+ }
+ if ( depMngt.getExclusions() != null )
+ {
+ premanagedExclusions = dependency.getExclusions();
+ dependency = dependency.setExclusions( depMngt.getExclusions() );
+ managedBits |= DependencyNode.MANAGED_EXCLUSIONS;
+ }
+ }
+ return new PremanagedDependency( premanagedVersion, premanagedScope, premanagedOptional,
+ premanagedExclusions, premanagedProperties, managedBits, dependency,
+ premanagedState );
+
+ }
+
+ public void applyTo( DefaultDependencyNode child )
+ {
+ child.setManagedBits( managedBits );
+ if ( premanagedState )
+ {
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_VERSION, premanagedVersion );
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_SCOPE, premanagedScope );
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_OPTIONAL, premanagedOptional );
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_EXCLUSIONS, premanagedExclusions );
+ child.setData( DependencyManagerUtils.NODE_DATA_PREMANAGED_PROPERTIES, premanagedProperties );
+ }
+ }
+
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCycle.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCycle.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCycle.java
new file mode 100644
index 0000000..15e1835
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyCycle.java
@@ -0,0 +1,87 @@
+package org.eclipse.aether.internal.impl.collect;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.DependencyCycle;
+import org.eclipse.aether.graph.DependencyNode;
+import org.eclipse.aether.util.artifact.ArtifactIdUtils;
+
+/**
+ * @see DefaultDependencyCollector
+ */
+final class DefaultDependencyCycle
+ implements DependencyCycle
+{
+
+ private final List<Dependency> dependencies;
+
+ private final int cycleEntry;
+
+ DefaultDependencyCycle( NodeStack nodes, int cycleEntry, Dependency dependency )
+ {
+ // skip root node unless it actually has a dependency or is considered the cycle entry (due to its label)
+ int offset = ( cycleEntry > 0 && nodes.get( 0 ).getDependency() == null ) ? 1 : 0;
+ Dependency[] dependencies = new Dependency[nodes.size() - offset + 1];
+ for ( int i = 0, n = dependencies.length - 1; i < n; i++ )
+ {
+ DependencyNode node = nodes.get( i + offset );
+ dependencies[i] = node.getDependency();
+ // when cycle starts at root artifact as opposed to root dependency, synthesize a dependency
+ if ( dependencies[i] == null )
+ {
+ dependencies[i] = new Dependency( node.getArtifact(), null );
+ }
+ }
+ dependencies[dependencies.length - 1] = dependency;
+ this.dependencies = Collections.unmodifiableList( Arrays.asList( dependencies ) );
+ this.cycleEntry = cycleEntry;
+ }
+
+ public List<Dependency> getPrecedingDependencies()
+ {
+ return dependencies.subList( 0, cycleEntry );
+ }
+
+ public List<Dependency> getCyclicDependencies()
+ {
+ return dependencies.subList( cycleEntry, dependencies.size() );
+ }
+
+ @Override
+ public String toString()
+ {
+ StringBuilder buffer = new StringBuilder( 256 );
+ for ( int i = 0, n = dependencies.size(); i < n; i++ )
+ {
+ if ( i > 0 )
+ {
+ buffer.append( " -> " );
+ }
+ buffer.append( ArtifactIdUtils.toVersionlessId( dependencies.get( i ).getArtifact() ) );
+ }
+ return buffer.toString();
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyGraphTransformationContext.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyGraphTransformationContext.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyGraphTransformationContext.java
new file mode 100644
index 0000000..c2b3585
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultDependencyGraphTransformationContext.java
@@ -0,0 +1,74 @@
+package org.eclipse.aether.internal.impl.collect;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.HashMap;
+import java.util.Map;
+import static java.util.Objects.requireNonNull;
+
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.collection.DependencyGraphTransformationContext;
+
+/**
+ */
+class DefaultDependencyGraphTransformationContext
+ implements DependencyGraphTransformationContext
+{
+
+ private final RepositorySystemSession session;
+
+ private final Map<Object, Object> map;
+
+ DefaultDependencyGraphTransformationContext( RepositorySystemSession session )
+ {
+ this.session = session;
+ this.map = new HashMap<Object, Object>();
+ }
+
+ public RepositorySystemSession getSession()
+ {
+ return session;
+ }
+
+ public Object get( Object key )
+ {
+ return map.get( requireNonNull( key, "key cannot be null" ) );
+ }
+
+ public Object put( Object key, Object value )
+ {
+ requireNonNull( key, "key cannot be null" );
+ if ( value != null )
+ {
+ return map.put( key, value );
+ }
+ else
+ {
+ return map.remove( key );
+ }
+ }
+
+ @Override
+ public String toString()
+ {
+ return String.valueOf( map );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultVersionFilterContext.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultVersionFilterContext.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultVersionFilterContext.java
new file mode 100644
index 0000000..684b7da
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/DefaultVersionFilterContext.java
@@ -0,0 +1,217 @@
+package org.eclipse.aether.internal.impl.collect;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.ConcurrentModificationException;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.collection.VersionFilter;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.repository.ArtifactRepository;
+import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.resolution.VersionRangeResult;
+import org.eclipse.aether.version.Version;
+import org.eclipse.aether.version.VersionConstraint;
+
+/**
+ * @see DefaultDependencyCollector
+ */
+final class DefaultVersionFilterContext
+ implements VersionFilter.VersionFilterContext
+{
+
+ private final Iterator<Version> EMPTY = Collections.<Version>emptySet().iterator();
+
+ private final RepositorySystemSession session;
+
+ private Dependency dependency;
+
+ VersionRangeResult result;
+
+ int count;
+
+ byte[] deleted = new byte[64];
+
+ DefaultVersionFilterContext( RepositorySystemSession session )
+ {
+ this.session = session;
+ }
+
+ public void set( Dependency dependency, VersionRangeResult result )
+ {
+ this.dependency = dependency;
+ this.result = result;
+ count = result.getVersions().size();
+ if ( deleted.length < count )
+ {
+ deleted = new byte[count];
+ }
+ else
+ {
+ for ( int i = count - 1; i >= 0; i-- )
+ {
+ deleted[i] = (byte) 0;
+ }
+ }
+ }
+
+ public List<Version> get()
+ {
+ if ( count == result.getVersions().size() )
+ {
+ return result.getVersions();
+ }
+ if ( count <= 1 )
+ {
+ if ( count <= 0 )
+ {
+ return Collections.emptyList();
+ }
+ return Collections.singletonList( iterator().next() );
+ }
+ List<Version> versions = new ArrayList<Version>( count );
+ for ( Version version : this )
+ {
+ versions.add( version );
+ }
+ return versions;
+ }
+
+ public RepositorySystemSession getSession()
+ {
+ return session;
+ }
+
+ public Dependency getDependency()
+ {
+ return dependency;
+ }
+
+ public VersionConstraint getVersionConstraint()
+ {
+ return result.getVersionConstraint();
+ }
+
+ public int getCount()
+ {
+ return count;
+ }
+
+ public ArtifactRepository getRepository( Version version )
+ {
+ return result.getRepository( version );
+ }
+
+ public List<RemoteRepository> getRepositories()
+ {
+ return Collections.unmodifiableList( result.getRequest().getRepositories() );
+ }
+
+ public Iterator<Version> iterator()
+ {
+ return ( count > 0 ) ? new VersionIterator() : EMPTY;
+ }
+
+ @Override
+ public String toString()
+ {
+ return dependency + " " + result.getVersions();
+ }
+
+ private class VersionIterator
+ implements Iterator<Version>
+ {
+
+ private final List<Version> versions;
+
+ private final int size;
+
+ private int count;
+
+ private int index;
+
+ private int next;
+
+ VersionIterator()
+ {
+ count = DefaultVersionFilterContext.this.count;
+ index = -1;
+ next = 0;
+ versions = result.getVersions();
+ size = versions.size();
+ advance();
+ }
+
+ private void advance()
+ {
+ for ( next = index + 1; next < size && deleted[next] != (byte) 0; next++ )
+ {
+ // just advancing index
+ }
+ }
+
+ public boolean hasNext()
+ {
+ return next < size;
+ }
+
+ public Version next()
+ {
+ if ( count != DefaultVersionFilterContext.this.count )
+ {
+ throw new ConcurrentModificationException();
+ }
+ if ( next >= size )
+ {
+ throw new NoSuchElementException();
+ }
+ index = next;
+ advance();
+ return versions.get( index );
+ }
+
+ public void remove()
+ {
+ if ( count != DefaultVersionFilterContext.this.count )
+ {
+ throw new ConcurrentModificationException();
+ }
+ if ( index < 0 || deleted[index] == (byte) 1 )
+ {
+ throw new IllegalStateException();
+ }
+ deleted[index] = (byte) 1;
+ count = --DefaultVersionFilterContext.this.count;
+ }
+
+ @Override
+ public String toString()
+ {
+ return ( index < 0 ) ? "null" : String.valueOf( versions.get( index ) );
+ }
+
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/NodeStack.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/NodeStack.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/NodeStack.java
new file mode 100644
index 0000000..a7cbc78
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/NodeStack.java
@@ -0,0 +1,124 @@
+package org.eclipse.aether.internal.impl.collect;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.Arrays;
+
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.graph.DependencyNode;
+
+/**
+ * @see DefaultDependencyCollector
+ */
+final class NodeStack
+{
+
+ private DependencyNode[] nodes = new DependencyNode[96];
+
+ private int size;
+
+ public DependencyNode top()
+ {
+ if ( size <= 0 )
+ {
+ throw new IllegalStateException( "stack empty" );
+ }
+ return nodes[size - 1];
+ }
+
+ public void push( DependencyNode node )
+ {
+ if ( size >= nodes.length )
+ {
+ DependencyNode[] tmp = new DependencyNode[size + 64];
+ System.arraycopy( nodes, 0, tmp, 0, nodes.length );
+ nodes = tmp;
+ }
+ nodes[size++] = node;
+ }
+
+ public void pop()
+ {
+ if ( size <= 0 )
+ {
+ throw new IllegalStateException( "stack empty" );
+ }
+ size--;
+ }
+
+ public int find( Artifact artifact )
+ {
+ for ( int i = size - 1; i >= 0; i-- )
+ {
+ DependencyNode node = nodes[i];
+
+ Artifact a = node.getArtifact();
+ if ( a == null )
+ {
+ break;
+ }
+
+ if ( !a.getArtifactId().equals( artifact.getArtifactId() ) )
+ {
+ continue;
+ }
+ if ( !a.getGroupId().equals( artifact.getGroupId() ) )
+ {
+ continue;
+ }
+ if ( !a.getExtension().equals( artifact.getExtension() ) )
+ {
+ continue;
+ }
+ if ( !a.getClassifier().equals( artifact.getClassifier() ) )
+ {
+ continue;
+ }
+ /*
+ * NOTE: While a:1 and a:2 are technically different artifacts, we want to consider the path a:2 -> b:2 ->
+ * a:1 a cycle in the current context. The artifacts themselves might not form a cycle but their producing
+ * projects surely do. Furthermore, conflict resolution will always have to consider a:1 a loser (otherwise
+ * its ancestor a:2 would get pruned and so would a:1) so there is no point in building the sub graph of
+ * a:1.
+ */
+
+ return i;
+ }
+
+ return -1;
+ }
+
+ public int size()
+ {
+ return size;
+ }
+
+ public DependencyNode get( int index )
+ {
+ return nodes[index];
+ }
+
+ @Override
+ public String toString()
+ {
+ return Arrays.toString( nodes );
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/ObjectPool.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/ObjectPool.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/ObjectPool.java
new file mode 100644
index 0000000..acb62c5
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/ObjectPool.java
@@ -0,0 +1,52 @@
+package org.eclipse.aether.internal.impl.collect;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/**
+ * Pool of immutable object instances, used to avoid excessive memory consumption of (dirty) dependency graph which
+ * tends to have many duplicate artifacts/dependencies.
+ */
+class ObjectPool<T>
+{
+
+ private final Map<Object, Reference<T>> objects = new WeakHashMap<Object, Reference<T>>( 256 );
+
+ public synchronized T intern( T object )
+ {
+ Reference<T> pooledRef = objects.get( object );
+ if ( pooledRef != null )
+ {
+ T pooled = pooledRef.get();
+ if ( pooled != null )
+ {
+ return pooled;
+ }
+ }
+
+ objects.put( object, new WeakReference<T>( object ) );
+ return object;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/package-info.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/package-info.java b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/package-info.java
new file mode 100644
index 0000000..85baeed
--- /dev/null
+++ b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/collect/package-info.java
@@ -0,0 +1,23 @@
+// CHECKSTYLE_OFF: RegexpHeader
+/**
+ * Internal helper classes for dependency collector.
+ */
+package org.eclipse.aether.internal.impl.collect;
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/maven-resolver/blob/142469e7/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DataPoolTest.java
----------------------------------------------------------------------
diff --git a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DataPoolTest.java b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DataPoolTest.java
deleted file mode 100644
index 43651f6..0000000
--- a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DataPoolTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package org.eclipse.aether.internal.impl;
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-import static org.junit.Assert.*;
-
-import org.eclipse.aether.DefaultRepositorySystemSession;
-import org.eclipse.aether.artifact.DefaultArtifact;
-import org.eclipse.aether.graph.Dependency;
-import org.eclipse.aether.repository.RemoteRepository;
-import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
-import org.eclipse.aether.resolution.ArtifactDescriptorResult;
-import org.junit.Test;
-
-public class DataPoolTest
-{
-
- private DataPool newDataPool()
- {
- return new DataPool( new DefaultRepositorySystemSession() );
- }
-
- @Test
- public void testArtifactDescriptorCaching()
- {
- ArtifactDescriptorRequest request = new ArtifactDescriptorRequest();
- request.setArtifact( new DefaultArtifact( "gid:aid:1" ) );
- ArtifactDescriptorResult result = new ArtifactDescriptorResult( request );
- result.setArtifact( new DefaultArtifact( "gid:aid:2" ) );
- result.addRelocation( request.getArtifact() );
- result.addDependency( new Dependency( new DefaultArtifact( "gid:dep:3" ), "compile" ) );
- result.addManagedDependency( new Dependency( new DefaultArtifact( "gid:mdep:3" ), "runtime" ) );
- result.addRepository( new RemoteRepository.Builder( "test", "default", "http://localhost" ).build() );
- result.addAlias( new DefaultArtifact( "gid:alias:4" ) );
-
- DataPool pool = newDataPool();
- Object key = pool.toKey( request );
- pool.putDescriptor( key, result );
- ArtifactDescriptorResult cached = pool.getDescriptor( key, request );
- assertNotNull( cached );
- assertEquals( result.getArtifact(), cached.getArtifact() );
- assertEquals( result.getRelocations(), cached.getRelocations() );
- assertEquals( result.getDependencies(), cached.getDependencies() );
- assertEquals( result.getManagedDependencies(), cached.getManagedDependencies() );
- assertEquals( result.getRepositories(), cached.getRepositories() );
- assertEquals( result.getAliases(), cached.getAliases() );
- }
-
-}