org.eclipse.aether.internal.impl.DataPool Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (c) 2010, 2014 Sonatype, Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Sonatype, Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.aether.internal.impl;
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 OBJECT_POOL = DataPool.class.getName() + "$Objects";
private static final String DESCRIPTORS = DataPool.class.getName() + "$Descriptors";
public static final ArtifactDescriptorResult NO_DESCRIPTOR =
new ArtifactDescriptorResult( new ArtifactDescriptorRequest() );
private ObjectPool objectPool;
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 )
{
objectPool = (ObjectPool) cache.get( session, OBJECT_POOL );
descriptors = (Map) cache.get( session, DESCRIPTORS );
}
if ( objectPool == null )
{
objectPool = new ObjectPool();
if ( cache != null )
{
cache.put( session, OBJECT_POOL, objectPool );
}
}
if ( descriptors == null )
{
descriptors = Collections.synchronizedMap( new WeakHashMap( 256 ) );
if ( cache != null )
{
cache.put( session, DESCRIPTORS, descriptors );
}
}
}
public Dependency intern( Dependency dependency )
{
return objectPool.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 );
}
static abstract 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 - 2024 Weber Informatics LLC | Privacy Policy