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;

    }

    /** {@inheritDoc} */
    @Override
    public ArtifactFilter getDependencyFilter() {
        return artifact.getDependencyFilter();
    }

    /** {@inheritDoc} */
    @Override
    public void setDependencyFilter(ArtifactFilter artifactFilter) {
        artifact.setDependencyFilter(artifactFilter);
    }

    /** {@inheritDoc} */
    @Override

        Map<String, Artifact> managedVersions = request.getManagedVersionMap();
        List<ResolutionListener> listeners = request.getListeners();
        ArtifactFilter collectionFilter = request.getCollectionFilter();
        ArtifactFilter resolutionFilter = request.getResolutionFilter();
        RepositorySystemSession session = getSession(request.getLocalRepository());

import org.apache.maven.artifact.resolver.ResolutionNode;
import org.apache.maven.artifact.resolver.filter.AndArtifactFilter;
import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.versioning.ArtifactVersion;
import org.apache.maven.artifact.versioning.ManagedVersionMap;
import org.apache.maven.artifact.versioning.OverConstrainedVersionException;

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

        this.downloadUrl = downloadUrl;
    }

    @Override
    public ArtifactFilter getDependencyFilter() {
        return dependencyFilter;
    }

    @Override
    public void setDependencyFilter(ArtifactFilter artifactFilter) {
        dependencyFilter = artifactFilter;
    }

    @Override
    public ArtifactHandler getArtifactHandler() {
        return artifactHandler;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;

import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
import org.apache.maven.artifact.resolver.filter.ExclusionSetFilter;
import org.apache.maven.extension.internal.CoreExports;

/**
 */
@Named
@Singleton
@Deprecated

    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;

/**
 * InversionArtifactFilter
 */
@Deprecated
public class InversionArtifactFilter implements ArtifactFilter {
    private final ArtifactFilter toInvert;

    public InversionArtifactFilter(ArtifactFilter toInvert) {
        this.toInvert = toInvert;
    }

    @Override
    public boolean include(Artifact artifact) {
        return !toInvert.include(artifact);

            effectiveScope = Artifact.SCOPE_PROVIDED;
        }

        return effectiveScope;
    }

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

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