import org.gradle.api.specs.Specs;

import javax.annotation.Nullable;

public class CollectionFilter<T> implements Spec<Object> {

    private final Class<? extends T> type;
    private final Spec<? super T> spec;

    public CollectionFilter(Class<T> type) {
        this(type, Specs.satisfyAll());
    }

    public CollectionFilter(Class<? extends T> type, Spec<? super T> spec) {
        this.type = type;

        this(collection, filter, instantiator, namer, MutationGuards.identity());
    }

    // should be protected, but use of the class generator forces it to be public

        }
    }

    private class FilteredEventRegister<S extends T> implements CollectionEventRegister<S> {
        private final CollectionFilter<S> filter;
        private final CollectionEventRegister<S> delegate;

        FilteredEventRegister(CollectionFilter<S> filter, CollectionEventRegister<T> delegate) {
            this.filter = filter;
            this.delegate = Cast.uncheckedCast(delegate);
        }

        super(type, decorator);
    }

    private DefaultPluginCollection(DefaultPluginCollection<? super T> collection, CollectionFilter<T> filter) {
        super(collection, filter);
    }

    @Override
    protected <S extends T> DefaultPluginCollection<S> filtered(CollectionFilter<S> filter) {
        return new DefaultPluginCollection<S>(this, filter);
    }

    @Override

 */
package org.gradle.api.internal;

import groovy.lang.Closure;
import org.gradle.api.NamedDomainObjectList;
import org.gradle.api.Namer;
import org.gradle.api.internal.collections.CollectionFilter;
import org.gradle.api.internal.collections.ElementSource;
import org.gradle.api.internal.collections.FilteredIndexedElementSource;
import org.gradle.api.internal.collections.IndexedElementSource;

import groovy.lang.Closure;
import org.gradle.api.Action;
import org.gradle.api.DomainObjectSet;
import org.gradle.api.internal.collections.CollectionEventRegister;
import org.gradle.api.internal.collections.CollectionFilter;
import org.gradle.api.internal.collections.ElementSource;
import org.gradle.api.internal.collections.IterationOrderRetainingSetElementSource;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;

        return eventRegister;
    }

    protected CollectionFilter<T> createFilter(Spec<? super T> filter) {
        return new CollectionFilter<>(type, eventRegister.getDecorator().decorateSpec(filter));
    }

    protected <S extends T> CollectionFilter<S> createFilter(Class<S> type) {
        return new CollectionFilter<>(type);
    }

     *         {@code null} to collect all transitive dependencies.
     */
    public ArtifactFilter getCollectionFilter() {
        return collectionFilter;
    }

    public ArtifactResolutionRequest setCollectionFilter(ArtifactFilter filter) {
        this.collectionFilter = filter;

        return this;
    }

    /**

public class FilteredElementSource<T, S extends T> implements ElementSource<S> {
    protected final ElementSource<T> collection;
    protected final CollectionFilter<S> filter;

    public FilteredElementSource(ElementSource<T> collection, CollectionFilter<S> filter) {
        this.collection = collection;
        this.filter = filter;
    }

    @Override
    public boolean add(S o) {

    protected <S extends T> DefaultTaskCollection<S> filtered(CollectionFilter<S> filter) {
        return Cast.uncheckedNonnullCast(getInstantiator().newInstance(DefaultTaskCollection.class, this, filter, getInstantiator(), project, parentMutationGuard));
    }

    @Override
    protected <S extends T> DefaultTaskCollection<S> filtered(Spec<String> nameFilter, CollectionFilter<S> elementFilter) {