Package org.gradle.api.model

## Interface ObjectFactory

-     public interface ObjectFactory

  A factory for creating various kinds of model objects.

  An instance of the factory can be injected into a task, plugin or other object by annotating a public constructor or property getter method with `javax.inject.Inject`. It is also available via `Project.getObjects()`.

  Since:
    4.0

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `DirectoryProperty` | `directoryProperty()` | Creates a new `DirectoryProperty` that uses the project directory to resolve relative paths, if required.
    `<T> NamedDomainObjectContainer<T>` | `domainObjectContainer​(Class<T> elementType)` | Creates a new `NamedDomainObjectContainer` for managing named objects of the specified type.
    `<T> NamedDomainObjectContainer<T>` | `domainObjectContainer​(Class<T> elementType, NamedDomainObjectFactory<T> factory)` | Creates a new `NamedDomainObjectContainer` for managing named objects of the specified type.
    `<T> DomainObjectSet<T>` | `domainObjectSet​(Class<T> elementType)` | Creates a new `DomainObjectSet` for managing objects of the specified type.
    `ConfigurableFileCollection` | `fileCollection()` | Creates a new `ConfigurableFileCollection`.
    `RegularFileProperty` | `fileProperty()` | Creates a new `RegularFileProperty` that uses the project directory to resolve relative paths, if required.
    `ConfigurableFileTree` | `fileTree()` | Creates a new `ConfigurableFileTree`.
    `<T> ListProperty<T>` | `listProperty​(Class<T> elementType)` | Creates a `ListProperty` implementation to hold a `List` of the given element type `T`.
    `<K,​V> MapProperty<K,​V>` | `mapProperty​(Class<K> keyType, Class<V> valueType)` | Creates a `MapProperty` implementation to hold a `Map` of the given key type `K` and value type `V`.
    `<T extends Named> T` | `named​(Class<T> type, String name)` | Creates a simple immutable `Named` object of the given type and name.
    `<T> NamedDomainObjectList<T>` | `namedDomainObjectList​(Class<T> elementType)` | Creates a new `NamedDomainObjectList` for managing named objects of the specified type.
    `<T> NamedDomainObjectSet<T>` | `namedDomainObjectSet​(Class<T> elementType)` | Creates a new `NamedDomainObjectSet` for managing named objects of the specified type.
    `<T> T` | `newInstance​(Class<? extends T> type, Object... parameters)` | Create a new instance of T, using `parameters` as the construction parameters.
    `<T> ExtensiblePolymorphicDomainObjectContainer<T>` | `polymorphicDomainObjectContainer​(Class<T> elementType)` | Creates a new `ExtensiblePolymorphicDomainObjectContainer` for managing named objects of the specified type.
    `<T> Property<T>` | `property​(Class<T> valueType)` | Creates a `Property` implementation to hold values of the given type.
    `<T> SetProperty<T>` | `setProperty​(Class<T> elementType)` | Creates a `SetProperty` implementation to hold a `Set` of the given element type `T`.
    `SourceDirectorySet` | `sourceDirectorySet​(String name, String displayName)` | Creates a `SourceDirectorySet`.

- - ### Method Detail

    - #### named

          <T extends Named> T named​(Class<T> type,
                                    String name)
                             throws ObjectInstantiationException

      Creates a simple immutable `Named` object of the given type and name.

      The given type can be an interface that extends `Named` or an abstract class that 'implements' `Named`. An abstract class, if provided:

      - Must provide a zero-args constructor that is not private.
      - Must not define or inherit any instance fields.
      - Should not provide an implementation for `Named.getName()` and should define this method as abstract. Any implementation will be overridden.
      - Must not define or inherit any other abstract methods.

      An interface, if provided, must not define or inherit any other methods.

      Objects created using this method are not decorated or extensible.

      Throws:
        `ObjectInstantiationException` - On failure to create the new instance.
      Since:
        4.0

    - #### newInstance

          <T> T newInstance​(Class<? extends T> type,
                            Object... parameters)
                     throws ObjectInstantiationException

      Create a new instance of T, using `parameters` as the construction parameters.

      The type must be non-final, and can be a class, abstract class or interface.

      Objects created using this method are decorated and extensible, meaning that they have DSL support mixed in and can be extended using the `extensions` property, similar to the `Project` object.

      An @Inject annotation is required on any constructor that accepts parameters because JSR-330 semantics for dependency injection are used. In addition to those parameters provided as an argument to this method, the following services are also available for injection:

      - `ObjectFactory`.
      - `ProjectLayout`.
      - `ProviderFactory`.
      - `ExecOperations`
      - `FileSystemOperations`
      Throws:
        `ObjectInstantiationException` - On failure to create the new instance.
      Since:
        4.2

    - #### sourceDirectorySet

          @Incubating
          SourceDirectorySet sourceDirectorySet​(String name,
                                                String displayName)

      Creates a `SourceDirectorySet`.
      Parameters:
        `name` - A short name for the set.
        `displayName` - A human consumable display name for the set.
      Since:
        5.0

    - #### fileCollection

          @Incubating
          ConfigurableFileCollection fileCollection()

      Creates a new `ConfigurableFileCollection`. The collection is initially empty.
      Since:
        5.3

    - #### fileTree

          @Incubating
          ConfigurableFileTree fileTree()

      Creates a new `ConfigurableFileTree`. The tree will have no base dir specified.
      Since:
        6.0

    - #### domainObjectContainer

          @Incubating
          <T> NamedDomainObjectContainer<T> domainObjectContainer​(Class<T> elementType)

      Creates a new `NamedDomainObjectContainer` for managing named objects of the specified type.

      The specified element type must have a public constructor which takes the name as a String parameter. The type must be non-final and a class or abstract class. Interfaces are currently not supported.

      All objects MUST expose their name as a bean property called "name". The name must be constant for the life of the object.

      The objects created by the container are decorated and extensible, and have services available for injection. See `newInstance(Class, Object...)` for more details.

      Type Parameters:
        `T` - The type of objects for the container to contain.
      Parameters:
        `elementType` - The type of objects for the container to contain.
      Returns:
        The container. Never returns null.
      Since:
        5.5

    - #### domainObjectContainer

          @Incubating
          <T> NamedDomainObjectContainer<T> domainObjectContainer​(Class<T> elementType,
                                                                  NamedDomainObjectFactory<T> factory)

      Creates a new `NamedDomainObjectContainer` for managing named objects of the specified type. The given factory is used to create object instances.

      All objects MUST expose their name as a bean property named "name". The name must be constant for the life of the object.

      Type Parameters:
        `T` - The type of objects for the container to contain.
      Parameters:
        `elementType` - The type of objects for the container to contain.
        `factory` - The factory to use to create object instances.
      Returns:
        The container. Never returns null.
      Since:
        5.5

    - #### polymorphicDomainObjectContainer

          @Incubating
          <T> ExtensiblePolymorphicDomainObjectContainer<T> polymorphicDomainObjectContainer​(Class<T> elementType)

      Creates a new `ExtensiblePolymorphicDomainObjectContainer` for managing named objects of the specified type.

      The returned container will not have any factories or bindings registered.

      Type Parameters:
        `T` - The type of objects for the container to contain.
      Parameters:
        `elementType` - The type of objects for the container to contain.
      Returns:
        The container.
      Since:
        6.1

    - #### domainObjectSet

          @Incubating
          <T> DomainObjectSet<T> domainObjectSet​(Class<T> elementType)

      Creates a new `DomainObjectSet` for managing objects of the specified type.
      Type Parameters:
        `T` - The type of objects for the domain object set to contain.
      Parameters:
        `elementType` - The type of objects for the domain object set to contain.
      Returns:
        The domain object set. Never returns null.
      Since:
        5.5

    - #### namedDomainObjectSet

          @Incubating
          <T> NamedDomainObjectSet<T> namedDomainObjectSet​(Class<T> elementType)

      Creates a new `NamedDomainObjectSet` for managing named objects of the specified type.

      All objects MUST expose their name as a bean property called "name". The name must be constant for the life of the object.

      Type Parameters:
        `T` - The type of objects for the domain object set to contain.
      Parameters:
        `elementType` - The type of objects for the domain object set to contain.
      Returns:
        The domain object set.
      Since:
        6.1

    - #### namedDomainObjectList

          @Incubating
          <T> NamedDomainObjectList<T> namedDomainObjectList​(Class<T> elementType)

      Creates a new `NamedDomainObjectList` for managing named objects of the specified type.

      All objects MUST expose their name as a bean property called "name". The name must be constant for the life of the object.

      Type Parameters:
        `T` - The type of objects for the domain object set to contain.
      Parameters:
        `elementType` - The type of objects for the domain object set to contain.
      Returns:
        The domain object list.
      Since:
        6.1

    - #### property

          <T> Property<T> property​(Class<T> valueType)

      Creates a `Property` implementation to hold values of the given type. The property has no initial value.

      For certain types, there are more specialized property factory methods available:

      - For `List` properties, you should use `listProperty(Class)`.
      - For `Set` properties, you should use `setProperty(Class)`.
      - For `Map` properties, you should use `mapProperty(Class, Class)`.
      - For `Directory` properties, you should use `directoryProperty()`.
      - For `RegularFile` properties, you should use `fileProperty()`.
      Parameters:
        `valueType` - The type of the property.
      Returns:
        The property. Never returns null.
      Since:
        4.3

    - #### listProperty

          <T> ListProperty<T> listProperty​(Class<T> elementType)

      Creates a `ListProperty` implementation to hold a `List` of the given element type `T`. The property has an empty list as its initial value.

      The implementation will return immutable `List` values from its query methods.

      Type Parameters:
        `T` - The type of element.
      Parameters:
        `elementType` - The type of element.
      Returns:
        The property. Never returns null.
      Since:
        4.3

    - #### setProperty

          <T> SetProperty<T> setProperty​(Class<T> elementType)

      Creates a `SetProperty` implementation to hold a `Set` of the given element type `T`. The property has an empty set as its initial value.

      The implementation will return immutable `Set` values from its query methods.

      Type Parameters:
        `T` - The type of element.
      Parameters:
        `elementType` - The type of element.
      Returns:
        The property. Never returns null.
      Since:
        4.5

    - #### mapProperty

          @Incubating
          <K,​V> MapProperty<K,​V> mapProperty​(Class<K> keyType,
                                                         Class<V> valueType)

      Creates a `MapProperty` implementation to hold a `Map` of the given key type `K` and value type `V`. The property has an empty map as its initial value.

      The implementation will return immutable `Map` values from its query methods.

      Type Parameters:
        `K` - the type of key.
        `V` - the type of value.
      Parameters:
        `keyType` - the type of key.
        `valueType` - the type of value.
      Returns:
        the property. Never returns null.
      Since:
        5.1

    - #### directoryProperty

          @Incubating
          DirectoryProperty directoryProperty()

      Creates a new `DirectoryProperty` that uses the project directory to resolve relative paths, if required. The property has no initial value.
      Since:
        5.0

    - #### fileProperty

          @Incubating
          RegularFileProperty fileProperty()

      Creates a new `RegularFileProperty` that uses the project directory to resolve relative paths, if required. The property has no initial value.
      Since:
        5.0