SettingKey

abstract val key: AttributeKey[T]

abstract def scope: Scope

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ++=[U](vs: U)(implicit a: Values[T, U]): Def.Setting[T]

final def +=[U](v: U)(implicit a: Append.Value[T, U]): Def.Setting[T]

final def --=[U](vs: U)(implicit r: Values[T, U]): Def.Setting[T]

final def -=[U](v: U)(implicit r: Remove.Value[T, U]): Def.Setting[T]

final def :=(v: T): Def.Setting[T]

final def <++=[V](vs: Def.Initialize[V])(implicit a: Values[T, V]): Def.Setting[T]

final def <+=[V](v: Def.Initialize[V])(implicit a: Append.Value[T, V]): Def.Setting[T]

final def <<=(app: Def.Initialize[T]): Def.Setting[T]

Binds a single value to this.

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def ?: Def.Initialize[Option[T]]

Creates an Def.Initialize with value scala.None if there was no previous definition of this key, and scala.Some(value) if a definition exists.

final def ??[T >: T](or: ⇒ T): Def.Initialize[T]

Like ?, but with a call-by-name parameter rather than an existing Def.Initialize.

final def append1[V](v: Def.Initialize[V], source: SourcePosition)(implicit a: Append.Value[T, V]): Def.Setting[T]

final def appendN[V](vs: Def.Initialize[V], source: SourcePosition)(implicit a: Values[T, V]): Def.Setting[T]

final def apply[Z](g: (T) ⇒ Z): Def.Initialize[Z]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def dependencies: List[Def.ScopedKey[T]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def evaluate(ss: Settings[Scope]): T

def finalize(): Unit

final def get(settings: Settings[Scope]): Option[T]

From the given Settings, extract the value bound to this key.

final def getClass(): Class[_]

def hashCode(): Int

final def in(scope: Scope): SettingKey[T]

def in(p: ScopeAxis[Reference], c: ScopeAxis[ConfigKey], t: ScopeAxis[AttributeKey[_]]): SettingKey[T]

def in(p: Reference, c: ConfigKey, t: Scoped): SettingKey[T]

def in(p: Reference, t: Scoped): SettingKey[T]

def in(p: Reference, c: ConfigKey): SettingKey[T]

def in(c: ConfigKey, t: Scoped): SettingKey[T]

def in(c: ConfigKey): SettingKey[T]

def in(t: Scoped): SettingKey[T]

def in(p: Reference): SettingKey[T]

final def isInstanceOf[T0]: Boolean

def make[S](other: Def.Initialize[S], source: SourcePosition)(f: (T, S) ⇒ T): Def.Setting[T]

final def mapConstant(g: Def.MapConstant): Def.Initialize[T]

final def mapReferenced(g: Def.MapScoped): Def.Initialize[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def or[T >: T](i: Def.Initialize[T]): Def.Initialize[T]

Creates an Def.Initialize with value bound to this key, or returns i parameter if unbound.

final def remove1[V](v: Def.Initialize[V], source: SourcePosition)(implicit r: Remove.Value[T, V]): Def.Setting[T]

final def removeN[V](vs: Def.Initialize[V], source: SourcePosition)(implicit r: Values[T, V]): Def.Setting[T]

final def scopedKey: Def.ScopedKey[T]

final def set(app: Def.Initialize[T], source: SourcePosition): Def.Setting[T]

Internally used function for setting a value along with the .sbt file location where it is defined.

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

def toString(): String

final def toTask: Def.Initialize[Task[T]]

final def transform(f: (T) ⇒ T, source: SourcePosition): Def.Setting[T]

final val transform: (T) ⇒ T

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[S](o: Def.Initialize[S]): Def.Initialize[(T, S)]

def zipWith[S, U](o: Def.Initialize[S])(f: (T, S) ⇒ U): Def.Initialize[U]

final def ~=(f: (T) ⇒ T): Def.Setting[T]

def validateReferenced(g: Def.ValidateRef): Def.ValidatedInit[T]