* specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact.resolver.filter;

import org.apache.maven.artifact.Artifact;

/**
 */
public interface ArtifactFilter {
    boolean include(Artifact artifact);

        for (ArtifactFilter filter : filters) {
            if (filter.include(artifact)) {
                return true;
            }
        }

        return false;
    }

    public void add(ArtifactFilter artifactFilter) {
        filters.add(artifactFilter);
    }

    @Override
    public int hashCode() {
        int hash = 17;
        hash = hash * 31 + filters.hashCode();
        return hash;

            effectiveScope = Artifact.SCOPE_PROVIDED;
        }

        return effectiveScope;
    }

    private static ArtifactFilter createDependencyFilter(Dependency dependency, ArtifactFilter inheritedFilter) {
        ArtifactFilter effectiveFilter = inheritedFilter;

        if (!dependency.getExclusions().isEmpty()) {

     *             extensions.
     */
    @Deprecated
    ArtifactFilter getArtifactFilter();

    /**
     * Returns a filter for only the core artifacts.
     *
     * @return the artifact filter
     */
    ArtifactFilter getCoreArtifactFilter();

    /**

        boolean include = true;
        for (Iterator<ArtifactFilter> i = filters.iterator(); i.hasNext() && include; ) {
            ArtifactFilter filter = i.next();
            if (!filter.include(artifact)) {
                include = false;
            }
        }
        return include;
    }

    public void add(ArtifactFilter artifactFilter) {
        filters.add(artifactFilter);
    }

import org.apache.maven.artifact.resolver.ArtifactResolutionResult;
import org.apache.maven.artifact.resolver.ResolutionListener;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.repository.legacy.resolver.conflict.ConflictResolver;

/**
 * Artifact collector - takes a set of original artifacts and resolves the best versions to use

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

import org.apache.maven.artifact.Artifact;

/**
 */
public class ExclusionSetFilter implements ArtifactFilter {
    private Set<String> excludes;

    public ExclusionSetFilter(String[] excludes) {
        this.excludes = new LinkedHashSet<>(Arrays.asList(excludes));
    }

    private Set<Artifact> artifactDependencies;

    private ArtifactRepository localRepository;

    private List<ArtifactRepository> remoteRepositories;

    private ArtifactFilter collectionFilter;

    private ArtifactFilter resolutionFilter;

    // Needs to go away
    private List<ResolutionListener> listeners = new ArrayList<>();

    // This is like a filter but overrides all transitive versions

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.metadata.ArtifactMetadataSource;
import org.apache.maven.artifact.repository.ArtifactRepository;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.wagon.events.TransferListener;

/**
 */
// Just hide the one method we want behind the RepositorySystem interface.
@Deprecated
public interface ArtifactResolver {

    void updateVersion(String version, ArtifactRepository localRepository);

    String getDownloadUrl();

    void setDownloadUrl(String downloadUrl);

    ArtifactFilter getDependencyFilter();

    void setDependencyFilter(ArtifactFilter artifactFilter);

    ArtifactHandler getArtifactHandler();

    List<String> getDependencyTrail();

    void setDependencyTrail(List<String> dependencyTrail);