object Scoped
Methods and types related to constructing settings, including keys, scopes, and initializations.
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- Scoped
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- All
Type Members
- type AnyInitTask = Def.Initialize[Task[T]] forSome {type T}
- final class Apply10 [A, B, C, D, E, F, G, H, I, J] extends AnyRef
- final class Apply11 [A, B, C, D, E, F, G, H, I, J, K] extends AnyRef
- final class Apply2 [A, B] extends AnyRef
- final class Apply3 [A, B, C] extends AnyRef
- final class Apply4 [A, B, C, D] extends AnyRef
- final class Apply5 [A, B, C, D, E] extends AnyRef
- final class Apply6 [A, B, C, D, E, F] extends AnyRef
- final class Apply7 [A, B, C, D, E, F, G] extends AnyRef
- final class Apply8 [A, B, C, D, E, F, G, H] extends AnyRef
- final class Apply9 [A, B, C, D, E, F, G, H, I] extends AnyRef
-
sealed
trait
DefinableSetting
[S] extends AnyRef
Mixin trait for adding convenience vocabulary associated with applying a setting to a configuration item.
- sealed trait DefinableTask [S] extends AnyRef
- final class RichAnyTaskSeq extends AnyRef
- sealed abstract class RichInitTaskBase [S, R[_]] extends AnyRef
-
final
class
RichInitialize
[S] extends AnyRef
Wraps an sbt.Def.Initialize instance to provide
map
andflatMap
semantics. - final class RichInitializeInputTask [S] extends RichInitTaskBase[S, InputTask]
- final class RichInitializeTask [S] extends RichInitTaskBase[S, Task]
- final class RichTaskSeq [T] extends AnyRef
- final class RichTaskable10 [A, B, C, D, E, F, G, H, I, J] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D], L[E], L[F], L[G], L[H], L[I], L[J])]
- final class RichTaskable11 [A, B, C, D, E, F, G, H, I, J, K] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D], L[E], L[F], L[G], L[H], L[I], L[J], L[K])]
- final class RichTaskable2 [A, B] extends RichTaskables[[L[x]](L[A], L[B])]
- final class RichTaskable3 [A, B, C] extends RichTaskables[[L[x]](L[A], L[B], L[C])]
- final class RichTaskable4 [A, B, C, D] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D])]
- final class RichTaskable5 [A, B, C, D, E] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D], L[E])]
- final class RichTaskable6 [A, B, C, D, E, F] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D], L[E], L[F])]
- final class RichTaskable7 [A, B, C, D, E, F, G] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D], L[E], L[F], L[G])]
- final class RichTaskable8 [A, B, C, D, E, F, G, H] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D], L[E], L[F], L[G], L[H])]
- final class RichTaskable9 [A, B, C, D, E, F, G, H, I] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D], L[E], L[F], L[G], L[H], L[I])]
- sealed abstract class RichTaskables [K[L[x]]] extends AnyRef
- type ST[X] = ScopedTaskable[X]
-
sealed
trait
ScopingSetting
[ResultType] extends AnyRef
Mixin trait for adding convenience vocabulary associated with specifying the Scope of a setting.
Mixin trait for adding convenience vocabulary associated with specifying the Scope of a setting. Allows specification of the Scope or part of the Scope of a setting being referenced.
name in Global := "hello Global scope" name in (Compile, packageBin) := "hello Compile scope packageBin" name in Compile := "hello Compile scope" name.in(Compile).:=("hello ugly syntax")
Example:
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- implicit def inputScopedToKey[T](s: InputKey[T]): Def.ScopedKey[InputTask[T]]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def mkTuple10[A, B, C, D, E, F, G, H, I, J]: (A, B, C, D, E, F, G, H, I, J) ⇒ (A, B, C, D, E, F, G, H, I, J)
- def mkTuple11[A, B, C, D, E, F, G, H, I, J, K]: (A, B, C, D, E, F, G, H, I, J, K) ⇒ (A, B, C, D, E, F, G, H, I, J, K)
- def mkTuple12[A, B, C, D, E, F, G, H, I, J, K, L]: (A, B, C, D, E, F, G, H, I, J, K, L) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L)
- def mkTuple13[A, B, C, D, E, F, G, H, I, J, K, L, N]: (A, B, C, D, E, F, G, H, I, J, K, L, N) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, N)
- def mkTuple14[A, B, C, D, E, F, G, H, I, J, K, L, N, O]: (A, B, C, D, E, F, G, H, I, J, K, L, N, O) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, N, O)
- def mkTuple15[A, B, C, D, E, F, G, H, I, J, K, L, N, O, P]: (A, B, C, D, E, F, G, H, I, J, K, L, N, O, P) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, N, O, P)
- def mkTuple2[A, B]: (A, B) ⇒ (A, B)
- def mkTuple3[A, B, C]: (A, B, C) ⇒ (A, B, C)
- def mkTuple4[A, B, C, D]: (A, B, C, D) ⇒ (A, B, C, D)
- def mkTuple5[A, B, C, D, E]: (A, B, C, D, E) ⇒ (A, B, C, D, E)
- def mkTuple6[A, B, C, D, E, F]: (A, B, C, D, E, F) ⇒ (A, B, C, D, E, F)
- def mkTuple7[A, B, C, D, E, F, G]: (A, B, C, D, E, F, G) ⇒ (A, B, C, D, E, F, G)
- def mkTuple8[A, B, C, D, E, F, G, H]: (A, B, C, D, E, F, G, H) ⇒ (A, B, C, D, E, F, G, H)
- def mkTuple9[A, B, C, D, E, F, G, H, I]: (A, B, C, D, E, F, G, H, I) ⇒ (A, B, C, D, E, F, G, H, I)
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- implicit def richAnyTaskSeq(in: Seq[AnyInitTask]): RichAnyTaskSeq
- implicit def richTaskSeq[T](in: Seq[Def.Initialize[Task[T]]]): RichTaskSeq[T]
- def scopedInput[T](s: Scope, k: AttributeKey[InputTask[T]]): InputKey[T]
- def scopedSetting[T](s: Scope, k: AttributeKey[T]): SettingKey[T]
- def scopedTask[T](s: Scope, k: AttributeKey[Task[T]]): TaskKey[T]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- implicit def taskScopedToKey[T](s: TaskKey[T]): Def.ScopedKey[Task[T]]
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )