gradle/org.gradle.kotlin.dsl/TaskContainerScope

TaskContainerScope

class TaskContainerScope : TaskContainerDelegate(source)

Receiver for the tasks block providing an extended set of operators for the configuration of tasks.

Types

Companion

object Companion

Properties

container

val container: TaskContainer

creating

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

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

val TaskContainer.~~creating~~: NamedDomainObjectContainerCreatingDelegateProvider<Task>

Provides a property delegate that creates tasks of the default type.

delegate

open val delegate: TaskContainer

size

open override val size: Int

Functions

add

open override fun add(element: Task): Boolean

addAll

open override fun addAll(elements: Collection<Task>): Boolean

addAllLater

open override fun addAllLater(provider: Provider<out Iterable<Task>>)

addLater

open override fun addLater(provider: Provider<out Task>)

addRule

open override fun addRule(rule: Rule): Rule

open override fun addRule(description: String, ruleAction: Closure<Any>): Rule

open override fun addRule(description: String, ruleAction: Action<String>): Rule

all

open override fun all(action: Closure<Any>)

open override fun all(action: Action<in Task>)

clear

open override fun clear()

configure

open override fun configure(configureClosure: Closure<Any>): NamedDomainObjectContainer<Task>

configureEach

open override fun configureEach(action: Action<in Task>)

containerWithType

open override 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

open operator override fun contains(element: Task): Boolean

containsAll

open override fun containsAll(elements: Collection<Task>): Boolean

create

open override fun ~~create~~(name: String): Task

open override fun ~~create~~(options: Map<String, *>): Task

open override fun ~~create~~(name: String, configureClosure: Closure<Any>): Task

open override fun <T : Task> ~~create~~(name: String, type: Class<T>): T

open override fun ~~create~~(name: String, configureAction: Action<in Task>): Task

open override fun ~~create~~(options: Map<String, *>, configureClosure: Closure<Any>): Task

open override fun <T : Task> ~~create~~(name: String, type: Class<T>, vararg constructorArgs: Any?): T

open override fun <T : Task> ~~create~~(name: String, type: Class<T>, configuration: Action<in T>): T

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, noinline configureAction: T.() -> Unit): T

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

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 TaskContainer.~~creating~~(configuration: Task.() -> Unit): NamedDomainObjectContainerCreatingDelegateProvider<Task>

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

fun TaskContainer.~~creating~~(type: KClass): PolymorphicDomainObjectContainerCreatingDelegateProvider<Task, U>

Provides a property delegate that creates tasks 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.

fun TaskContainer.~~creating~~(type: Class, configuration: U.() -> Unit): PolymorphicDomainObjectContainerCreatingDelegateProvider<Task, U>

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

fun TaskContainer.~~creating~~(type: KClass, configuration: U.() -> Unit): PolymorphicDomainObjectContainerCreatingDelegateProvider<Task, U>

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

findAll

open override fun findAll(spec: Closure<Any>): MutableSet<Task>

findByName

open override fun findByName(name: String): Task?

findByPath

open override fun findByPath(path: String): Task?

forEach

open fun forEach(p0: Consumer<in Task>)

get

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

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

getAsMap

open override fun getAsMap(): SortedMap<String, Task>

getAt

open override fun getAt(name: String): Task

getByName

open override fun getByName(name: String): Task

open override fun getByName(name: String, configureClosure: Closure<Any>): Task

open override fun getByName(name: String, configureAction: Action<in Task>): Task

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

open override fun getByPath(path: String): Task

getCollectionSchema

open override fun getCollectionSchema(): NamedDomainObjectCollectionSchema

getNamer

open override fun getNamer(): Namer<Task>

getNames

open override fun getNames(): SortedSet<String>

getRules

open override fun getRules(): MutableList<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.

invoke

operator fun String.~~invoke~~(): TaskProvider<Task>

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

operator fun String.invoke(configuration: Task.() -> Unit): TaskProvider<Task>

operator fun String.invoke(type: KClass, configuration: U.() -> Unit): TaskProvider

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

operator fun String.invoke(type: KClass): TaskProvider

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

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

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): MutableIterator<Task>

matching

open override fun matching(closure: Closure<Any>): TaskCollection<Task>

open override fun matching(spec: Spec<in Task>): TaskCollection<Task>

maybeCreate

open override fun maybeCreate(name: String): Task

open override 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

open override fun named(name: String): TaskProvider<Task>

open override fun named(predicate: Spec<String>): TaskCollection<Task>

open override fun <S : Task> named(name: String, type: Class<S>): TaskProvider<S>

open override fun named(name: String, configurationAction: Action<in Task>): TaskProvider<Task>

open override fun <S : Task> named(name: String, type: Class<S>, configurationAction: Action<in 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.

parallelStream

open fun parallelStream(): Stream<Task>

provideDelegate

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

Allows a NamedDomainObjectCollection to be used as a property delegate.

open override fun register(name: String): TaskProvider<Task>

open override fun <T : Task> register(name: String, type: Class<T>): TaskProvider<T>

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

open override fun <T : Task> register(name: String, type: Class<T>, vararg constructorArgs: Any?): TaskProvider<T>

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

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

open override fun remove(element: Task): Boolean

removeAll

open override fun removeAll(elements: Collection<Task>): Boolean

removeIf

open fun removeIf(p0: Predicate<in Task>): Boolean

replace

open override fun replace(name: String): Task

open override fun <T : Task> replace(name: String, type: Class<T>): T

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

open override fun retainAll(elements: Collection<Task>): Boolean

spliterator

open override fun spliterator(): Spliterator<Task>

stream

open fun stream(): Stream<Task>

toArray

open fun <T : Any> ~~toArray~~(p0: IntFunction<Array<T>>): Array<T>

whenObjectAdded

open override fun whenObjectAdded(action: Closure<Any>)

open override fun whenObjectAdded(action: Action<in Task>): Action<in Task>

whenObjectRemoved

open override fun whenObjectRemoved(action: Closure<Any>)

open override fun whenObjectRemoved(action: Action<in Task>): Action<in Task>

whenTaskAdded

open override fun whenTaskAdded(closure: Closure<Any>)

open override fun whenTaskAdded(action: Action<in Task>): Action<in Task>

withType

open override fun <S : Task> withType(type: Class<S>): TaskCollection<S>

open override fun <S : Task> withType(type: Class<S>, configureClosure: Closure<Any>): DomainObjectCollection<S>

open override fun <S : Task> withType(type: Class<S>, configureAction: Action<in S>): DomainObjectCollection<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.