Def

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object DefaultSetting

object Initialize

object SettingsDefinition

def Undefined(defining: Setting[_], referencedKey: ScopedKey[_]): Undefined

def Uninitialized(validKeys: Seq[ScopedKey[_]], delegates: (Scope) ⇒ Seq[Scope], keys: Seq[Undefined], runtime: Boolean)(implicit display: Show[ScopedKey[_]]): Uninitialized

def add[T](m: ScopedMap, s: Setting[T]): ScopedMap

def addLocal(init: Seq[Setting[_]])(implicit scopeLocal: (ScopedKey[_]) ⇒ Seq[Setting[_]]): Seq[Setting[_]]

def app[K[L[x]], T](inputs: K[Initialize])(f: (K[Types.Id]) ⇒ T)(implicit alist: AList[K]): Initialize[T]

def append[T](ss: Seq[Setting[T]], s: Setting[T]): Seq[Setting[T]]

def asFunction[T](s: Settings[Scope]): (ScopedKey[T]) ⇒ T

final def asInstanceOf[T0]: T0

def asTransform(s: Settings[Scope]): ~>[ScopedKey, Types.Id]

def bind[S, T](in: Initialize[S])(f: (S) ⇒ Initialize[T]): Initialize[T]

lazy val capturedTransformations: Initialize[~>[Initialize, Initialize]]

The result of this initialization is the composition of applied transformations.

def clone(): AnyRef

def colored(s: String, color: Option[String]): String

def compile(sMap: ScopedMap): CompiledMap

def compiled(init: Seq[Setting[_]], actual: Boolean = true)(implicit delegates: (Scope) ⇒ Seq[Scope], scopeLocal: (ScopedKey[_]) ⇒ Seq[Setting[_]], display: Show[ScopedKey[_]]): CompiledMap

def definedAtString(settings: Seq[Setting[_]]): String

def delegate(sMap: ScopedMap)(implicit delegates: (Scope) ⇒ Seq[Scope], display: Show[ScopedKey[_]]): ScopedMap

final def derive[T](s: Setting[T], allowDynamic: Boolean = false, filter: (Scope) ⇒ Boolean = const(true), trigger: (AttributeKey[_]) ⇒ Boolean = const(true), default: Boolean = false): Setting[T]

Constructs a derived setting that will be automatically defined in every scope where one of its dependencies is explicitly defined and the where the scope matches filter.

def deriveAllowed[T](s: Setting[T], allowDynamic: Boolean): Option[String]

def displayFull(scoped: ScopedKey[_], keyNameColor: Option[String]): String

def displayFull(scoped: ScopedKey[_]): String

def displayMasked(scoped: ScopedKey[_], mask: ScopeMask): String

def displayRelative(current: ProjectRef, multi: Boolean, project: Reference): String

def empty(implicit delegates: (Scope) ⇒ Seq[Scope]): Settings[Scope]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flattenLocals(compiled: CompiledMap): Map[ScopedKey[_], Flattened]

final def getClass(): Class[_]

def getValue[T](s: Settings[Scope], k: ScopedKey[T]): T

def grouped(init: Seq[Setting[_]]): ScopedMap

def guessIntendedScope(validKeys: Seq[ScopedKey[_]], delegates: (Scope) ⇒ Seq[Scope], key: ScopedKey[_]): Option[ScopedKey[_]]

def hashCode(): Int

def inputKey[T](description: String): InputKey[T]

def inputTask[T](t: T): Initialize[InputTask[T]]

def inputTaskDyn[T](t: Initialize[Task[T]]): Initialize[InputTask[T]]

def intersect(s1: Scope, s2: Scope)(implicit delegates: (Scope) ⇒ Seq[Scope]): Option[Scope]

Intersects two scopes, returning the more specific one if they intersect, or None otherwise.

final def isInstanceOf[T0]: Boolean

implicit def macroPrevious[T](in: TaskKey[T]): MacroPrevious[T]

implicit def macroValueI[T](in: Initialize[T]): MacroValue[T]

implicit def macroValueIInT[T](in: Initialize[InputTask[T]]): InputEvaluated[T]

implicit def macroValueIT[T](in: Initialize[Task[T]]): MacroValue[T]

implicit def macroValueIn[T](in: InputTask[T]): InputEvaluated[T]

implicit def macroValueT[T](in: Task[T]): MacroValue[T]

def make(init: Seq[Setting[_]])(implicit delegates: (Scope) ⇒ Seq[Scope], scopeLocal: (ScopedKey[_]) ⇒ Seq[Setting[_]], display: Show[ScopedKey[_]]): Settings[Scope]

def map[S, T](in: Initialize[S])(f: (S) ⇒ T): Initialize[T]

def mapScope(f: (Scope) ⇒ Scope): MapScoped

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def optional[T, U](i: Initialize[T])(f: (Option[T]) ⇒ U): Initialize[U]

implicit def parserInitStateToInput[T](p: Initialize[(State) ⇒ Parser[T]]): ParserInput[T]

implicit def parserInitToInput[T](p: Initialize[Parser[T]]): ParserInput[T]

implicit def parserToInput[T](in: Parser[T]): ParserInput[T]

def pure[T](value: () ⇒ T): Initialize[T]

def refinedDistance(delegates: (Scope) ⇒ Seq[Scope], a: ScopedKey[_], b: ScopedKey[_]): Option[Int]

val resolvedScoped: SettingKey[ScopedKey[_]]

val runBefore: AttributeKey[Seq[Task[_]]]

def setting[T](t: T): Initialize[T]

def setting[T](key: ScopedKey[T], init: Initialize[T], pos: SourcePosition = NoPosition): Setting[T]

def settingDyn[T](t: Initialize[T]): Initialize[T]

def settingKey[T](description: String): SettingKey[T]

def showFullKey(keyNameColor: Option[String]): Show[ScopedKey[_]]

lazy val showFullKey: Show[ScopedKey[_]]

def showRelativeKey(current: ProjectRef, multi: Boolean, keyNameColor: Option[String] = None): Show[ScopedKey[_]]

def showUndefined(u: Undefined, validKeys: Seq[ScopedKey[_]], delegates: (Scope) ⇒ Seq[Scope])(implicit display: Show[ScopedKey[_]]): String

def sort(cMap: CompiledMap): Seq[Compiled[_]]

def spaceDelimited(argLabel: String = "<arg>"): Parser[Seq[String]]

A default Parser for splitting input into space-separated arguments.

implicit def stateParserToInput[T](in: (State) ⇒ Parser[T]): ParserInput[T]

final def synchronized[T0](arg0: ⇒ T0): T0

def task[T](t: T): Initialize[Task[T]]

def taskDyn[T](t: Initialize[Task[T]]): Initialize[Task[T]]

def taskKey[T](description: String): TaskKey[T]

implicit def taskMacroValueIT[T](in: Initialize[Task[T]]): MacroTaskValue[T]

def toIParser[T](p: Initialize[InputTask[T]]): Initialize[(State) ⇒ Parser[Task[T]]]

def toISParser[T](p: Initialize[Parser[T]]): Initialize[(State) ⇒ Parser[T]]

def toITask[T](i: Initialize[T]): Initialize[Task[T]]

Lifts the result of a setting initialization into a Task.

def toSParser[T](p: Parser[T]): (State) ⇒ Parser[T]

def toString(): String

val triggeredBy: AttributeKey[Seq[Task[_]]]

def uniform[S, T](inputs: Seq[Initialize[S]])(f: (Seq[S]) ⇒ T): Initialize[T]

def update[T](key: ScopedKey[T])(f: (T) ⇒ T): Setting[T]

def value[T](value: ⇒ T): Initialize[T]

def valueStrict[T](value: T): Initialize[T]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def Undefined(definingKey: ScopedKey[_], referencedKey: ScopedKey[_], derived: Boolean): Undefined

final def derive[T](s: Setting[T], allowDynamic: Boolean, filter: (Scope) ⇒ Boolean, trigger: (AttributeKey[_]) ⇒ Boolean): Setting[T]