import groovy.lang.Closure;
import groovy.lang.DelegatesTo;
import org.gradle.api.provider.Provider;
import org.gradle.api.specs.Spec;

import java.util.Collection;

/**
 * <p>A {@code DomainObjectCollection} is a specialised {@link Collection} that adds the ability to receive modification notifications and use live filtered sub collections.</p>
 *

        }

        public void addComposited(DomainObjectCollection<? extends T> collection) {
            this.store.add(collection);
        }

        public void removeComposited(DomainObjectCollection<? extends T> collection) {
            Iterator<DomainObjectCollection<? extends T>> iterator = store.iterator();
            while (iterator.hasNext()) {
                DomainObjectCollection<? extends T> next = iterator.next();

 * @return The matching objects. Returns an empty collection if there are no such objects
 * in this collection.
 * @see [DomainObjectCollection.withType]
 */
inline fun <reified S : Any> DomainObjectCollection<in S>.withType(noinline configuration: S.() -> Unit) =
    withType(S::class.java, configuration)


/**

| link:{javadocPath}/org/gradle/api/DomainObjectCollection.html#withType-java.lang.Class-org.gradle.api.Action-[DomainObjectCollection.withType()]
| Use `withType().configureEach()` instead.

| link:{javadocPath}/org/gradle/api/DomainObjectCollection.html#all-org.gradle.api.Action-[DomainObjectCollection.all()]
| Use `configureEach()` instead.

    /**
     * Creates a {@link CompositeDomainObjectSet} for managing a collection of {@link DomainObjectCollection} of the specified type.
     */
    <T> CompositeDomainObjectSet<T> newDomainObjectSet(Class<T> elementType, DomainObjectCollection<? extends T> collection);

    <T> ExtensiblePolymorphicDomainObjectContainer<T> newPolymorphicDomainObjectContainer(Class<T> elementType);

    private final Class<T> elementType;
    private final DomainObjectCollection<T> collection;
    private final NamedEntityInstantiator<T> instantiator;
    private final org.gradle.api.Namer<? super T> namer;
    private final Action<? super T> onCreateAction;

/**
 * <p>A {@code DomainObjectSet} is a specialization of {@link DomainObjectCollection} that guarantees {@link Set} semantics.</p>
 *
 * <p>You can create an instance of this type using the factory method {@link org.gradle.api.model.ObjectFactory#domainObjectSet(Class)}.</p>
 *
 * @param <T> The type of objects in this set.
 */
public interface DomainObjectSet<T> extends DomainObjectCollection<T>, Set<T> {

    /**
     * {@inheritDoc}
     */

    }

    @Override
    public DomainObjectCollection<T> matching(final Spec<? super T> spec) {
        return filtered(createFilter(spec));
    }

    @Override
    public DomainObjectCollection<T> matching(Closure spec) {
        return matching(Specs.convertClosureToSpec(spec));
    }

    @Override
    public <S extends T> DomainObjectCollection<S> withType(final Class<S> type) {

                ${NamedDomainObjectContainer::class.qualifiedName}<Build_gradle.A>
                ${NamedDomainObjectCollection::class.qualifiedName}<Build_gradle.B>
                ${DomainObjectCollection::class.qualifiedName}<Build_gradle.A>
                ${DomainObjectCollection::class.qualifiedName}<Build_gradle.B>
                ${TaskCollection::class.qualifiedName}<${Task::class.qualifiedName}>

        whenObjectRemoved(ConfigureUtil.configureUsing(action));
    }

    @Override
    public <S extends T> DomainObjectCollection<S> withType(Class<S> type, Action<? super S> configureAction) {
        return delegate.withType(type, configureAction);
    }

    @Override
    public <S extends T> DomainObjectCollection<S> withType(Class<S> type, Closure configureClosure) {