org.eclipse.aether.util.graph.selector.ExclusionDependencySelector Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of spring-cloud-contract-shade Show documentation
Show all versions of spring-cloud-contract-shade Show documentation
Spring Cloud Contract Shaded Dependencies
package org.eclipse.aether.util.graph.selector;
/*
* 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.Collection;
import java.util.Comparator;
import java.util.TreeSet;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.collection.DependencyCollectionContext;
import org.eclipse.aether.collection.DependencySelector;
import org.eclipse.aether.graph.Dependency;
import org.eclipse.aether.graph.Exclusion;
/**
* A dependency selector that applies exclusions based on artifact coordinates.
*
* @see Dependency#getExclusions()
*/
public final class ExclusionDependencySelector
implements DependencySelector
{
// sorted and dupe-free array, faster to iterate than LinkedHashSet
private final Exclusion[] exclusions;
private int hashCode;
/**
* Creates a new selector without any exclusions.
*/
public ExclusionDependencySelector()
{
this.exclusions = new Exclusion[0];
}
/**
* Creates a new selector with the specified exclusions.
*
* @param exclusions The exclusions, may be {@code null}.
*/
public ExclusionDependencySelector( Collection exclusions )
{
if ( exclusions != null && !exclusions.isEmpty() )
{
TreeSet sorted = new TreeSet( ExclusionComparator.INSTANCE );
sorted.addAll( exclusions );
this.exclusions = sorted.toArray( new Exclusion[sorted.size()] );
}
else
{
this.exclusions = new Exclusion[0];
}
}
private ExclusionDependencySelector( Exclusion[] exclusions )
{
this.exclusions = exclusions;
}
public boolean selectDependency( Dependency dependency )
{
Artifact artifact = dependency.getArtifact();
for ( Exclusion exclusion : exclusions )
{
if ( matches( exclusion, artifact ) )
{
return false;
}
}
return true;
}
private boolean matches( Exclusion exclusion, Artifact artifact )
{
if ( !matches( exclusion.getArtifactId(), artifact.getArtifactId() ) )
{
return false;
}
if ( !matches( exclusion.getGroupId(), artifact.getGroupId() ) )
{
return false;
}
if ( !matches( exclusion.getExtension(), artifact.getExtension() ) )
{
return false;
}
if ( !matches( exclusion.getClassifier(), artifact.getClassifier() ) )
{
return false;
}
return true;
}
private boolean matches( String pattern, String value )
{
return "*".equals( pattern ) || pattern.equals( value );
}
public DependencySelector deriveChildSelector( DependencyCollectionContext context )
{
Dependency dependency = context.getDependency();
Collection exclusions = ( dependency != null ) ? dependency.getExclusions() : null;
if ( exclusions == null || exclusions.isEmpty() )
{
return this;
}
Exclusion[] merged = this.exclusions;
int count = merged.length;
for ( Exclusion exclusion : exclusions )
{
int index = Arrays.binarySearch( merged, exclusion, ExclusionComparator.INSTANCE );
if ( index < 0 )
{
index = -( index + 1 );
if ( count >= merged.length )
{
Exclusion[] tmp = new Exclusion[merged.length + exclusions.size()];
System.arraycopy( merged, 0, tmp, 0, index );
tmp[index] = exclusion;
System.arraycopy( merged, index, tmp, index + 1, count - index );
merged = tmp;
}
else
{
System.arraycopy( merged, index, merged, index + 1, count - index );
merged[index] = exclusion;
}
count++;
}
}
if ( merged == this.exclusions )
{
return this;
}
if ( merged.length != count )
{
Exclusion[] tmp = new Exclusion[count];
System.arraycopy( merged, 0, tmp, 0, count );
merged = tmp;
}
return new ExclusionDependencySelector( merged );
}
@Override
public boolean equals( Object obj )
{
if ( this == obj )
{
return true;
}
else if ( null == obj || !getClass().equals( obj.getClass() ) )
{
return false;
}
ExclusionDependencySelector that = (ExclusionDependencySelector) obj;
return Arrays.equals( exclusions, that.exclusions );
}
@Override
public int hashCode()
{
if ( hashCode == 0 )
{
int hash = getClass().hashCode();
hash = hash * 31 + Arrays.hashCode( exclusions );
hashCode = hash;
}
return hashCode;
}
private static class ExclusionComparator
implements Comparator
{
static final ExclusionComparator INSTANCE = new ExclusionComparator();
public int compare( Exclusion e1, Exclusion e2 )
{
if ( e1 == null )
{
return ( e2 == null ) ? 0 : 1;
}
else if ( e2 == null )
{
return -1;
}
int rel = e1.getArtifactId().compareTo( e2.getArtifactId() );
if ( rel == 0 )
{
rel = e1.getGroupId().compareTo( e2.getGroupId() );
if ( rel == 0 )
{
rel = e1.getExtension().compareTo( e2.getExtension() );
if ( rel == 0 )
{
rel = e1.getClassifier().compareTo( e2.getClassifier() );
}
}
}
return rel;
}
}
}