Package org.gradle.api.model

Interface ObjectFactory

  • All Known Subinterfaces:
    BuildTreeObjectFactory
    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 Detail

      • named

        <T extends Named> T named​(java.lang.Class<T> type,
                          java.lang.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​(java.lang.Class<? extends T> type,
                  java.lang.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:

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

      • sourceDirectorySet

        SourceDirectorySet sourceDirectorySet​(java.lang.String name,
                                      java.lang.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

      • domainObjectContainer

        <T> NamedDomainObjectContainer<T> domainObjectContainer​(java.lang.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 supported if they declare a read-only name property of type String, and are otherwise empty or consist entirely of managed properties.

        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

        <T> NamedDomainObjectContainer<T> domainObjectContainer​(java.lang.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

        <T> ExtensiblePolymorphicDomainObjectContainer<T> polymorphicDomainObjectContainer​(java.lang.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

        <T> DomainObjectSet<T> domainObjectSet​(java.lang.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

        <T> NamedDomainObjectSet<T> namedDomainObjectSet​(java.lang.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

        <T> NamedDomainObjectList<T> namedDomainObjectList​(java.lang.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​(java.lang.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:

        Parameters:
        valueType - The type of the property.
        Returns:
        The property. Never returns null.
        Since:
        4.3

      • listProperty

        <T> ListProperty<T> listProperty​(java.lang.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​(java.lang.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

        <K,​V> MapProperty<K,​V> mapProperty​(java.lang.Class<K> keyType,
                                               java.lang.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

        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

        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