gradle/org.gradle.api.tasks/TaskContainer

TaskContainer

interface TaskContainer : TaskCollection<T> , PolymorphicDomainObjectContainer<T> (source)

A TaskContainer is responsible for managing a set of Task instances.

You can obtain a TaskContainer instance by calling getTasks, or using the tasks property in your build script.

Properties

creating

val <T : Any> NamedDomainObjectContainer<T>.creating: NamedDomainObjectContainerCreatingDelegateProvider<T>

Provides a property delegate that creates elements of the default collection type.

Functions

add

abstract fun add(e: T): Boolean

addAll

abstract fun addAll(c: Collection<out T>): Boolean

addAllLater

abstract fun addAllLater(provider: Provider<out Iterable<T>>)

addLater

abstract fun addLater(provider: Provider<out T>)

addRule

abstract fun addRule(rule: Rule): Rule

all

abstract fun all(action: Action<in T>)

clear

abstract fun clear()

configure

abstract fun configure(configureClosure: Closure): NamedDomainObjectContainer<T>

abstract fun configure(cl: Closure): T

configureEach

abstract fun configureEach(action: Action<in T>)

containerWithType

abstract fun containerWithType(type: Class): NamedDomainObjectContainer

containerWithType

inline fun PolymorphicDomainObjectContainer<T>.containerWithType(type: KClass): NamedDomainObjectContainer

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.PolymorphicDomainObjectContainer.containerWithType.

contains

abstract fun contains(p: Any): Boolean

containsAll

abstract fun containsAll(p: Collection<out Any>): Boolean

copyOf

open fun <E> copyOf(coll: Collection<out E>): Set<E>

create

abstract fun create(name: String): Task

Creates a Task with the given name and adds it to this container.

abstract fun create(options: Map<String, out Any>): Task

Creates a Task and adds it to this container.

abstract fun create(name: String, configureClosure: Closure): Task

Creates a Task with the given name adds it to this container.

abstract fun <T : Task?> create(name: String, type: Class<T>): T

Creates a Task with the given name and type, and adds it to this container.

abstract fun create(options: Map<String, out Any>, configureClosure: Closure): Task

Creates a Task adds it to this container.

abstract fun <T : Task?> create(name: String, type: Class<T>, constructorArgs: Array<Any>): T

Creates a Task with the given name and type, passing the given arguments to the @Inject-annotated constructor, and adds it to this container.

abstract fun <T : Task?> create(name: String, type: Class<T>, configuration: Action<in T>): T

Creates a Task with the given name and type, configures it with the given action, and adds it to this container.

create

inline fun PolymorphicDomainObjectContainer<in U>.create(name: String): U

Creates a domain object with the specified name and type, and adds it to the container.

inline fun TaskContainer.create(vararg options: Pair<String, Any?>): Task

Kotlin extension function for org.gradle.api.tasks.TaskContainer.create.

inline fun PolymorphicDomainObjectContainer<in U>.create(name: String, noinline configuration: U.() -> Unit): U

Creates a domain object with the specified name and type, adds it to the container, and configures it with the specified action.

inline fun PolymorphicDomainObjectContainer<T>.create(name: String, type: KClass): U

inline fun PolymorphicDomainObjectContainer<T>.create(name: String, type: KClass, configuration: Action<in U>): U

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.PolymorphicDomainObjectContainer.create.

inline fun <T : Task> TaskContainer.create(name: String, vararg arguments: Any): T

Creates a Task with the given name and type, passing the given arguments to the javax.inject.Inject-annotated constructor, and adds it to this project tasks container.

inline fun <T : Task> TaskContainer.create(name: String, type: KClass<T>): T

inline fun <T : Task> TaskContainer.create(name: String, type: KClass<T>, vararg constructorArgs: Any): T

inline fun <T : Task> TaskContainer.create(name: String, type: KClass<T>, configuration: Action<in T>): T

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.tasks.TaskContainer.create.

creating

fun <T : Any> NamedDomainObjectContainer<T>.creating(configuration: T.() -> Unit): NamedDomainObjectContainerCreatingDelegateProvider<T>

Provides a property delegate that creates elements of the default collection type with the given configuration.

fun <T : Any, U : T> PolymorphicDomainObjectContainer<T>.creating(type: KClass): PolymorphicDomainObjectContainerCreatingDelegateProvider<T, U>

Provides a property delegate that creates elements of the given type.

fun <T : Any, U : T> PolymorphicDomainObjectContainer<T>.creating(type: Class, configuration: U.() -> Unit): PolymorphicDomainObjectContainerCreatingDelegateProvider<T, U>

Provides a property delegate that creates elements of the given type expressed as a java.lang.Class with the given configuration.

fun <T : Any, U : T> PolymorphicDomainObjectContainer<T>.creating(type: KClass, configuration: U.() -> Unit): PolymorphicDomainObjectContainerCreatingDelegateProvider<T, U>

Provides a property delegate that creates elements of the given type with the given configuration.

equals

abstract fun equals(p: Any): Boolean

findAll

abstract fun findAll(spec: Closure): Collection<T>

abstract fun findAll(spec: Closure): Set<T>

findByName

abstract fun findByName(name: String): T

findByPath

@Nullable

abstract fun findByPath(path: String): Task

Locates a task by path.

forEach

open fun forEach(action: Consumer<in T>)

get

operator fun <T : Any> NamedDomainObjectCollection<T>.get(name: String): T

Locates an object by name, failing if there is no such object.

getAsMap

abstract fun getAsMap(): SortedMap<String, T>

getAt

abstract fun getAt(name: String): T

getByName

abstract fun getByName(name: String, configureClosure: Closure): T

getByName

inline fun <T : Any> NamedDomainObjectCollection<out Any>.getByName(name: String): T

Locates an object by name and casts it to the expected type T.

inline fun <T : Any> NamedDomainObjectCollection<out Any>.getByName(name: String, configure: T.() -> Unit): T

Locates an object by name and casts it to the expected type T then configures it.

fun <T : Any> NamedDomainObjectCollection<out Any>.getByName(name: String, type: KClass<T>): T

Locates an object by name and casts it to the expected type.

fun <T : Any> NamedDomainObjectCollection<out Any>.getByName(name: String, type: KClass<T>, configure: T.() -> Unit): T

Locates an object by name and casts it to the expected type then configures it.

getByPath

abstract fun getByPath(path: String): Task

Locates a task by path.

getCollectionSchema

abstract fun getCollectionSchema(): NamedDomainObjectCollectionSchema

getNamer

abstract fun getNamer(): Namer<T>

getNames

abstract fun getNames(): SortedSet<String>

getRules

abstract fun getRules(): List<Rule>

getting

fun <T : Any, U : T> NamedDomainObjectContainer<T>.getting(type: KClass): PolymorphicDomainObjectContainerGettingDelegateProvider<T, U>

Provides a property delegate that gets elements of the given type.

fun <T : Any, U : T> NamedDomainObjectContainer<T>.getting(type: KClass, configuration: U.() -> Unit): PolymorphicDomainObjectContainerGettingDelegateProvider<T, U>

Provides a property delegate that gets elements of the given type and applies the given configuration.

hashCode

abstract fun hashCode(): Int

invoke

inline operator fun TaskContainer.invoke(configuration: TaskContainerScope.() -> Unit): TaskContainer

Allows a TaskContainer to be configured via an augmented DSL that includes a shorthand string notation for configuring existing tasks.

isEmpty

abstract fun isEmpty(): Boolean

iterator

abstract fun iterator(): Iterator<T>

abstract fun iterator(): Iterator<E>

matching

abstract fun matching(spec: Spec<in T>): DomainObjectCollection<T>

abstract fun matching(spec: Spec<in T>): DomainObjectSet<T>

abstract fun matching(spec: Spec<in T>): NamedDomainObjectCollection<T>

abstract fun matching(spec: Spec<in T>): NamedDomainObjectSet<T>

abstract fun matching(spec: Spec<in T>): TaskCollection<T>

maybeCreate

abstract fun maybeCreate(name: String): T

abstract fun maybeCreate(name: String, type: Class): U

maybeCreate

inline fun PolymorphicDomainObjectContainer<in U>.maybeCreate(name: String): U

Creates a domain object with the specified name and type if it does not exists, and adds it to the container.

inline fun PolymorphicDomainObjectContainer<T>.maybeCreate(name: String, type: KClass): U

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.PolymorphicDomainObjectContainer.maybeCreate.

named

abstract fun named(name: String): NamedDomainObjectProvider<T>

open fun named(nameFilter: Spec<String>): NamedDomainObjectCollection<T>

abstract fun <S : T?> named(name: String, type: Class<S>): NamedDomainObjectProvider<S>

abstract fun named(nameFilter: Spec<String>): NamedDomainObjectSet<T>

abstract fun named(name: String): TaskProvider<T>

abstract fun named(nameFilter: Spec<String>): TaskCollection<T>

abstract fun <S : T?> named(name: String, type: Class<S>): TaskProvider<S>

named

inline fun <T : Any> NamedDomainObjectCollection<out Any>.named(name: String): NamedDomainObjectProvider<T>

fun <T : Any> NamedDomainObjectCollection<out Any>.named(name: String, type: KClass<T>): NamedDomainObjectProvider<T>

Locates an object by name and type, without triggering its creation or configuration, failing if there is no such object.

inline fun <T : Task> TaskCollection<out Task>.named(name: String): TaskProvider<T>

fun <T : Task> TaskCollection<out Task>.named(name: String, type: KClass<T>): TaskProvider<T>

Locates a task by name and type, without triggering its creation or configuration, failing if there is no such task.

inline fun <S : T, T : Any> NamedDomainObjectCollection<T>.named(name: String, type: KClass<S>): NamedDomainObjectProvider<S>

inline fun <S : T, T : Any> NamedDomainObjectCollection<T>.named(name: String, type: KClass<S>, configurationAction: Action<in S>): NamedDomainObjectProvider<S>

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.NamedDomainObjectCollection.named.

inline fun <T : Any> NamedDomainObjectCollection<out Any>.named(name: String, noinline configuration: T.() -> Unit): NamedDomainObjectProvider<T>

fun <T : Any> NamedDomainObjectCollection<out Any>.named(name: String, type: KClass<T>, configuration: T.() -> Unit): NamedDomainObjectProvider<T>

Configures an object by name and type, without triggering its creation or configuration, failing if there is no such object.

inline fun <S : T, T : Task> TaskCollection<T>.named(name: String, type: KClass<S>): TaskProvider<S>

inline fun <S : T, T : Task> TaskCollection<T>.named(name: String, type: KClass<S>, configurationAction: Action<in S>): TaskProvider<S>

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.tasks.TaskCollection.named.

inline fun <T : Task> TaskCollection<out Task>.named(name: String, noinline configuration: T.() -> Unit): TaskProvider<T>

fun <T : Task> TaskCollection<out Task>.named(name: String, type: KClass<T>, configuration: T.() -> Unit): TaskProvider<T>

Configures a task by name and type, without triggering its creation or configuration, failing if there is no such task.

open fun <E> of(): Set<E>

parallelStream

open fun parallelStream(): Stream<E>

provideDelegate

operator fun <T : Any> NamedDomainObjectCollection<T>.provideDelegate(thisRef: Any?, property: KProperty<*>): NamedDomainObjectProvider<T>

Allows a NamedDomainObjectCollection to be used as a property delegate.

abstract fun register(name: String): TaskProvider<Task>

abstract fun <T : Task?> register(name: String, type: Class<T>): TaskProvider<T>

Defines a new task, which will be created when it is required.

abstract fun register(name: String, configurationAction: Action<in Task>): TaskProvider<Task>

abstract fun <T : Task?> register(name: String, type: Class<T>, configurationAction: Action<in T>): TaskProvider<T>

Defines a new task, which will be created and configured when it is required.

abstract fun <T : Task?> register(name: String, type: Class<T>, constructorArgs: Array<Any>): TaskProvider<T>

Defines a new task, which will be created when it is required passing the given arguments to the @Inject-annotated constructor.

inline fun <T : Any> PolymorphicDomainObjectContainer<in T>.register(name: String): NamedDomainObjectProvider<T>

Defines a new object, which will be created when it is required.

inline fun <T : Task> TaskContainer.register(name: String): TaskProvider<T>

Defines a new task, which will be created when it is required.

inline fun <T : Any> PolymorphicDomainObjectContainer<in T>.register(name: String, noinline configuration: T.() -> Unit): NamedDomainObjectProvider<T>

Defines and configure a new object, which will be created when it is required.

inline fun PolymorphicDomainObjectContainer<T>.register(name: String, type: KClass): NamedDomainObjectProvider

inline fun PolymorphicDomainObjectContainer<T>.register(name: String, type: KClass, configurationAction: Action<in U>): NamedDomainObjectProvider

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.PolymorphicDomainObjectContainer.register.

inline fun <T : Task> TaskContainer.register(name: String, vararg arguments: Any): TaskProvider<T>

Defines a new task, which will be created when it is required passing the given arguments to the javax.inject.Inject-annotated constructor.

inline fun <T : Task> TaskContainer.register(name: String, noinline configuration: T.() -> Unit): TaskProvider<T>

Defines and configure a new task, which will be created when it is required.

inline fun <T : Task> TaskContainer.register(name: String, type: KClass<T>): TaskProvider<T>

inline fun <T : Task> TaskContainer.register(name: String, type: KClass<T>, vararg constructorArgs: Any): TaskProvider<T>

inline fun <T : Task> TaskContainer.register(name: String, type: KClass<T>, configurationAction: Action<in T>): TaskProvider<T>

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.tasks.TaskContainer.register.

remove

abstract fun remove(p: Any): Boolean

removeAll

abstract fun removeAll(p: Collection<out Any>): Boolean

removeIf

open fun removeIf(filter: Predicate<in E>): Boolean

replace

abstract fun replace(name: String): Task

Creates a Task with the given name and adds it to this container, replacing any existing task with the same name.

abstract fun <T : Task?> replace(name: String, type: Class<T>): T

Creates a Task with the given name and type, and adds it to this container, replacing any existing task of the same name.

replace

inline fun <T : Task> TaskContainer.replace(name: String, type: KClass<T>): T

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.tasks.TaskContainer.replace.

retainAll

abstract fun retainAll(p: Collection<out Any>): Boolean

size

abstract fun size(): Int

spliterator

open fun spliterator(): Spliterator<T>

open fun spliterator(): Spliterator<E>

stream

open fun stream(): Stream<E>

toArray

abstract fun toArray(): Array<Any>

abstract fun <T> toArray(p: Array<T>): Array<T>

whenObjectAdded

abstract fun whenObjectAdded(action: Closure)

abstract fun whenObjectAdded(action: Action<in T>): Action<in T>

whenObjectRemoved

abstract fun whenObjectRemoved(action: Closure)

abstract fun whenObjectRemoved(action: Action<in T>): Action<in T>

whenTaskAdded

abstract fun whenTaskAdded(closure: Closure)

abstract fun whenTaskAdded(action: Action<in T>): Action<in T>

withType

abstract fun <S : T?> withType(type: Class<S>): DomainObjectCollection<S>

abstract fun <S : T?> withType(type: Class<S>): DomainObjectSet<S>

abstract fun <S : T?> withType(type: Class<S>): NamedDomainObjectCollection<S>

abstract fun <S : T?> withType(type: Class<S>): NamedDomainObjectSet<S>

abstract fun <S : T?> withType(type: Class<S>): TaskCollection<S>

withType

inline fun <S : Any> DomainObjectCollection<in S>.withType(): DomainObjectCollection<S>

inline fun <S : Any> NamedDomainObjectCollection<in S>.withType(): NamedDomainObjectCollection<S>

inline fun <S : Task> TaskCollection<in S>.withType(): TaskCollection<S>

Returns a collection containing the objects in this collection of the given type. The returned collection is live, so that when matching objects are later added to this collection, they are also visible in the filtered collection.

inline fun <S : Any> DomainObjectCollection<in S>.withType(noinline configuration: S.() -> Unit): DomainObjectCollection<S>

Returns a collection containing the objects in this collection of the given type. Equivalent to calling withType(type).all(configureAction).

inline fun <S : T, T : Any> DomainObjectCollection<T>.withType(type: KClass<S>): DomainObjectCollection<S>

inline fun <S : T, T : Any> DomainObjectCollection<T>.withType(type: KClass<S>, configureAction: Action<in S>): DomainObjectCollection<S>

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.DomainObjectCollection.withType.

inline fun <S : T, T : Any> DomainObjectSet<T>.withType(type: KClass<S>): DomainObjectSet<S>

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.DomainObjectSet.withType.

inline fun <S : T, T : Any> NamedDomainObjectCollection<T>.withType(type: KClass<S>): NamedDomainObjectCollection<S>

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.NamedDomainObjectCollection.withType.

inline fun <S : T, T : Any> NamedDomainObjectSet<T>.withType(type: KClass<S>): NamedDomainObjectSet<S>

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.NamedDomainObjectSet.withType.

inline fun <S : T, T : Task> TaskCollection<T>.withType(type: KClass<S>): TaskCollection<S>

Kotlin extension function taking kotlin.reflect.KClass for org.gradle.api.tasks.TaskCollection.withType.