* 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 (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);
    }

    public List<ArtifactFilter> getFilters() {

            effectiveScope = Artifact.SCOPE_PROVIDED;
        }

        return effectiveScope;
    }

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

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

@Deprecated
public class OrArtifactFilter implements ArtifactFilter {

    private Set<ArtifactFilter> filters;

    public OrArtifactFilter() {
        this.filters = new LinkedHashSet<>();
    }

    public OrArtifactFilter(Collection<ArtifactFilter> filters) {
        this.filters = new LinkedHashSet<>(filters);
    }

    public boolean include(Artifact artifact) {
        for (ArtifactFilter filter : filters) {

import org.apache.maven.artifact.Artifact;

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

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

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

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 all of the best versions to use

     *             extensions.
     */
    ArtifactFilter getArtifactFilter();

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

    /**

        this.downloadUrl = downloadUrl;
    }

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

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

    @Override
    public ArtifactHandler getArtifactHandler() {
        return artifactHandler;

        artifact.setDownloadUrl(downloadUrl);
    }

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

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

    /** {@inheritDoc} */
    public ArtifactHandler getArtifactHandler() {

            }
        }

        ArtifactFilter artifactFilter = getArtifactFilter(mojoDescriptor);
        List<MavenProject> projectsToResolve = LifecycleDependencyResolver.getProjects(
                session.getCurrentProject(), session, mojoDescriptor.isAggregator());
        for (MavenProject projectToResolve : projectsToResolve) {
            projectToResolve.setArtifactFilter(artifactFilter);
        }
    }