Packages

object Scoped

Methods and types related to constructing settings, including keys, scopes, and initializations.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Scoped
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type AnyInitTask = Def.Initialize[Task[T]] forSome {type T}
  2. final class Apply10[A, B, C, D, E, F, G, H, I, J] extends AnyRef
  3. final class Apply11[A, B, C, D, E, F, G, H, I, J, K] extends AnyRef
  4. final class Apply2[A, B] extends AnyRef
  5. final class Apply3[A, B, C] extends AnyRef
  6. final class Apply4[A, B, C, D] extends AnyRef
  7. final class Apply5[A, B, C, D, E] extends AnyRef
  8. final class Apply6[A, B, C, D, E, F] extends AnyRef
  9. final class Apply7[A, B, C, D, E, F, G] extends AnyRef
  10. final class Apply8[A, B, C, D, E, F, G, H] extends AnyRef
  11. final class Apply9[A, B, C, D, E, F, G, H, I] extends AnyRef
  12. sealed trait DefinableSetting[S] extends AnyRef

    Mixin trait for adding convenience vocabulary associated with applying a setting to a configuration item.

  13. sealed trait DefinableTask[S] extends AnyRef
  14. final class RichAnyTaskSeq extends AnyRef
  15. sealed abstract class RichInitTaskBase[S, R[_]] extends AnyRef

    Enriches Initialize[R[S]] types.

    Enriches Initialize[R[S]] types. Abstracts over the specific task-like type constructor.

    S

    the type of the underlying vault

    R

    the task-like type constructor (either Task or InputTask)

  16. final class RichInitialize[S] extends AnyRef

    Wraps an sbt.Def.Initialize instance to provide map and flatMap semantics.

  17. final class RichInitializeInputTask[S] extends RichInitTaskBase[S, InputTask]

    Enriches Initialize[InputTask[S]] types.

    Enriches Initialize[InputTask[S]] types.

    S

    the type of the underlying value

  18. final class RichInitializeTask[S] extends RichInitTaskBase[S, Task]

    Enriches Initialize[Task[S]] types.

    Enriches Initialize[Task[S]] types.

    S

    the type of the underlying value

  19. final class RichTaskSeq[T] extends AnyRef
  20. 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])]
  21. 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])]
  22. final class RichTaskable2[A, B] extends RichTaskables[[L[x]](L[A], L[B])]
  23. final class RichTaskable3[A, B, C] extends RichTaskables[[L[x]](L[A], L[B], L[C])]
  24. final class RichTaskable4[A, B, C, D] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D])]
  25. final class RichTaskable5[A, B, C, D, E] extends RichTaskables[[L[x]](L[A], L[B], L[C], L[D], L[E])]
  26. 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])]
  27. 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])]
  28. 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])]
  29. 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])]
  30. sealed abstract class RichTaskables[K[L[x]]] extends AnyRef
  31. type ST[X] = Taskable[X]
  32. 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.

    Example: 

    1. 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")

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  8. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  9. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  10. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. implicit def inputScopedToKey[T](s: InputKey[T]): Def.ScopedKey[InputTask[T]]
  12. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  13. 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)
  14. 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)
  15. 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)
  16. 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)
  17. 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)
  18. 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)
  19. def mkTuple2[A, B]: (A, B) ⇒ (A, B)
  20. def mkTuple3[A, B, C]: (A, B, C) ⇒ (A, B, C)
  21. def mkTuple4[A, B, C, D]: (A, B, C, D) ⇒ (A, B, C, D)
  22. def mkTuple5[A, B, C, D, E]: (A, B, C, D, E) ⇒ (A, B, C, D, E)
  23. def mkTuple6[A, B, C, D, E, F]: (A, B, C, D, E, F) ⇒ (A, B, C, D, E, F)
  24. def mkTuple7[A, B, C, D, E, F, G]: (A, B, C, D, E, F, G) ⇒ (A, B, C, D, E, F, G)
  25. 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)
  26. 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)
  27. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  28. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  29. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  30. implicit def richAnyTaskSeq(in: Seq[AnyInitTask]): RichAnyTaskSeq
  31. implicit def richTaskSeq[T](in: Seq[Def.Initialize[Task[T]]]): RichTaskSeq[T]
  32. def scopedInput[T](s: Scope, k: AttributeKey[InputTask[T]]): InputKey[T]
  33. def scopedSetting[T](s: Scope, k: AttributeKey[T]): SettingKey[T]
  34. def scopedTask[T](s: Scope, k: AttributeKey[Task[T]]): TaskKey[T]
  35. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  36. implicit def taskScopedToKey[T](s: TaskKey[T]): Def.ScopedKey[Task[T]]
  37. def toString(): String
    Definition Classes
    AnyRef → Any
  38. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  39. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  40. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()

Inherited from AnyRef

Inherited from Any

Ungrouped