org.eclipse.aether.internal.impl.DataPool Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of maven-resolver-impl Show documentation
Show all versions of maven-resolver-impl Show documentation
An implementation of the repository system.
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 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 artifacts;
private ObjectPool dependencies;
private Map descriptors;
private Map constraints = new HashMap();
private Map> nodes = new HashMap>( 256 );
@SuppressWarnings( "unchecked" )
public DataPool( RepositorySystemSession session )
{
RepositoryCache cache = session.getCache();
if ( cache != null )
{
artifacts = (ObjectPool) cache.get( session, ARTIFACT_POOL );
dependencies = (ObjectPool) cache.get( session, DEPENDENCY_POOL );
descriptors = (Map) cache.get( session, DESCRIPTORS );
}
if ( artifacts == null )
{
artifacts = new ObjectPool();
if ( cache != null )
{
cache.put( session, ARTIFACT_POOL, artifacts );
}
}
if ( dependencies == null )
{
dependencies = new ObjectPool();
if ( cache != null )
{
cache.put( session, DEPENDENCY_POOL, dependencies );
}
}
if ( descriptors == null )
{
descriptors = Collections.synchronizedMap( new WeakHashMap( 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 repositories, DependencySelector selector,
DependencyManager manager, DependencyTraverser traverser, VersionFilter filter )
{
return new GraphKey( artifact, repositories, selector, manager, traverser, filter );
}
public List getChildren( Object key )
{
return nodes.get( key );
}
public void putChildren( Object key, List 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 relocations;
final Collection aliases;
final List repositories;
final List dependencies;
final List managedDependencies;
public 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;
public Constraint( VersionRangeResult result )
{
versionConstraint = result.getVersionConstraint();
List 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 repositories;
private final int hashCode;
public 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 repos1, List 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 repositories;
private final DependencySelector selector;
private final DependencyManager manager;
private final DependencyTraverser traverser;
private final VersionFilter filter;
private final int hashCode;
public GraphKey( Artifact artifact, List 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 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;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy