Class<T> castType = Cast.uncheckedCast(getType());
        registerFactory(castType, factory);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory) {
        namedEntityInstantiator.registerFactory(type, factory);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, final Closure<? extends U> factory) {

        given:
        instantiator.registerFactory(TestType, { new TestType(value: it) })

        expect:
        instantiator.create("foo", TestType).value == "foo"
    }

    def "registering an incompatible type results in an exception"() {
        when:
        instantiator.registerFactory(String, {})

        then:
        IllegalArgumentException e = thrown()

        return instantiator.create(name, type);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory, ModelRuleDescriptor descriptor) {
        registry.registerFactory(type, factory, descriptor);
    }

    @Override
    public Set<? extends Class<? extends T>> getCreatableTypes() {

        super(ComponentSpec.class);
        this.projectIdentifier = projectIdentifier;
        registerFactory(DefaultComponentSpec.class, new ImplementationFactory<ComponentSpec, DefaultComponentSpec>() {
            @Override

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory) {
        registerFactory(type, factory, null);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory, ModelRuleDescriptor descriptor) {
        checkCanRegister(type, descriptor);
        delegate.registerFactory(type, factory);
    }

        container.asDynamicObject.getProperty("Barney") == realBarney
    }

    def "create elements with specified type"() {
        container.registerFactory(Person, { new DefaultPerson(name: it) } as NamedDomainObjectFactory)
        container.registerFactory(AgeAwarePerson, { new DefaultAgeAwarePerson(name: it, age: 42) } as NamedDomainObjectFactory)

        when:
        project.container {
            Fred(Person)

            super(type, instantiator, namer)
        }

        @Override
        <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory, ModelRuleDescriptor descriptor) {
            registerFactory(type, factory)
        }
    }

    Class<NamedThing> itemClass = NamedThing
    Class<SpecialNamedThing> specialItemClass = SpecialNamedThing

    }

    def "can add and configure publication with API"() {
        given:
        Publication pub = publication("test")
        NamedDomainObjectFactory<Publication> factory = Mock()
        container.registerFactory(Publication, factory)

        when:
        container.create("name", Publication) {
            value = 2
        }

        then:
        1 * factory.create("name") >> pub

        and:

     * @param <U> the type of objects created by the factory
     *
     * @throws IllegalArgumentException if the specified type is not a subtype of the container element type
     */
    @Override
    <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory);

    /**
     * Registers a factory for creating elements of the specified type.
     * Typically, the specified type is an interface type.
     *

 */

package org.gradle.api.internal.rules;

import org.gradle.api.NamedDomainObjectFactory;

public interface NamedDomainObjectFactoryRegistry<T> {

    <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory);