Package org.gradle.api

# Interface ExtensiblePolymorphicDomainObjectContainer<T>

Type Parameters:
  `T` - the (base) container element type

All Superinterfaces:
  `Collection<T>`, `Configurable<NamedDomainObjectContainer<T>>`, `DomainObjectCollection<T>`, `DomainObjectSet<T>`, `Iterable<T>`, `NamedDomainObjectCollection<T>`, `NamedDomainObjectContainer<T>`, `org.gradle.api.internal.rules.NamedDomainObjectFactoryRegistry<T>`, `NamedDomainObjectSet<T>`, `PolymorphicDomainObjectContainer<T>`, `Set<T>`

All Known Subinterfaces:
  `NativeToolChainRegistry`, `PlatformContainer`, `PublicationContainer`, `SoftwareComponentContainer`

@ManagedType public interface ExtensiblePolymorphicDomainObjectContainer<T> extends PolymorphicDomainObjectContainer<T>, org.gradle.api.internal.rules.NamedDomainObjectFactoryRegistry<T>
A `PolymorphicDomainObjectContainer` that can be extended at runtime to create elements of new types.

See Also:
  - `Create an instance of this as a managed property (preferred).`
  - `Create an instance of this manually.`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `<U extends T>
  void`
  `registerBinding(Class<U> type, Class<? extends U> implementationType)`
  Registers a binding from the specified "public" domain object type to the specified implementation type.
  `<U extends T>
  void`
  `registerFactory(Class<U> type, Closure<? extends U> factory)`
  Registers a factory for creating elements of the specified type.
  `<U extends T>
  void`
  `registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory)`
  Registers a factory for creating elements of the specified type.

  ### Methods inherited from interface java.util.Collection

  `parallelStream, removeIf, stream, toArray`

  ### Methods inherited from interface org.gradle.api.DomainObjectCollection

  `addAllLater, addLater, all, all, configureEach, disallowChanges, whenObjectAdded, whenObjectAdded, whenObjectRemoved, whenObjectRemoved, withType, withType`

  ### Methods inherited from interface java.lang.Iterable

  `forEach`

  ### Methods inherited from interface org.gradle.api.NamedDomainObjectCollection

  `add, addAll, addRule, addRule, addRule, findByName, getAsMap, getAt, getByName, getByName, getByName, getCollectionSchema, getNamer, getNames, getRules, named, named, named, named`

  ### Methods inherited from interface org.gradle.api.NamedDomainObjectContainer

  `configure, create, create, create, maybeCreate, register, register`

  ### Methods inherited from interface org.gradle.api.NamedDomainObjectSet

  `findAll, matching, matching, named, withType`

  ### Methods inherited from interface org.gradle.api.PolymorphicDomainObjectContainer

  `containerWithType, create, create, maybeCreate, register, register`

  ### Methods inherited from interface java.util.Set

  `add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, spliterator, toArray, toArray`

- ## Method Details

  - ### registerFactory

    <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.
    Specified by:
      `registerFactory` in interface `org.gradle.api.internal.rules.NamedDomainObjectFactoryRegistry<T>`
    Type Parameters:
      `U` - the type of objects created by the factory
    Parameters:
      `type` - the type of objects created by the factory
      `factory` - the factory to register
    Throws:
      `IllegalArgumentException` - if the specified type is not a subtype of the container element type

  - ### registerFactory

    <U extends T> void registerFactory(Class<U> type, Closure<? extends U> factory)
    Registers a factory for creating elements of the specified type. Typically, the specified type is an interface type.
    Type Parameters:
      `U` - the type of objects created by the factory
    Parameters:
      `type` - the type of objects created by the factory
      `factory` - the factory to register
    Throws:
      `IllegalArgumentException` - if the specified type is not a subtype of the container element type

  - ### registerBinding

    <U extends T> void registerBinding(Class<U> type, Class<? extends U> implementationType)
    Registers a binding from the specified "public" domain object type to the specified implementation type. Whenever the container is asked to create an element with the binding's public type, it will instantiate the binding's implementation type. If the implementation type has a constructor annotated with `Inject`, its arguments will be injected.

    The implementation type may also be an interface that has a read-only `name` property of type String, and is otherwise empty or consists entirely of managed properties.

    In general, registering a binding is preferable over implementing and registering a factory.

    Type Parameters:
      `U` - a public domain object type
    Parameters:
      `type` - a public domain object type
      `implementationType` - the corresponding implementation type