sbt

Project

object Project extends Init[Scope] with ProjectExtra

Linear Supertypes
ProjectExtra, Init[Scope], AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. Project
  2. ProjectExtra
  3. Init
  4. AnyRef
  5. Any
Visibility
  1. Public
  2. All

Type Members

  1. final class Compiled[T] extends AnyRef

  2. type CompiledMap = Map[sbt.Project.ScopedKey[_], sbt.Project.Compiled[_]]

    Definition Classes
    Init

  3. final class Constructor extends AnyRef

  4. final class Flattened extends AnyRef

  5. sealed trait Initialize[T] extends AnyRef

  6. sealed trait Keyed[S, T] extends Initialize[T]

  7. trait KeyedInitialize[T] extends Keyed[T, T]

  8. type MapConstant = ~>[ScopedKey, Option]

    Definition Classes
    Init

  9. type MapScoped = ~>[ScopedKey, ScopedKey]

    Definition Classes
    Init

  10. final class RuntimeUndefined extends RuntimeException

  11. type ScopeLocal = (sbt.Project.ScopedKey[_]) ⇒ Seq[sbt.Project.Setting[_]]

    Definition Classes
    Init

  12. final case class ScopedKey[T](scope: Scope, key: AttributeKey[T]) extends KeyedInitialize[T] with Product with Serializable

  13. type ScopedMap = IMap[ScopedKey, SettingSeq]

    Definition Classes
    Init

  14. final class Setting[T] extends SettingsDefinition

  15. final class SettingList extends SettingsDefinition

  16. type SettingSeq[T] = Seq[Setting[T]]

    Definition Classes
    Init

  17. sealed trait SettingsDefinition extends AnyRef

  18. final class Undefined extends AnyRef

  19. final class Uninitialized extends Exception

  20. type ValidateRef = ~>[ScopedKey, ValidatedRef]

    Definition Classes
    Init

  21. type ValidatedInit[T] = Either[Seq[Undefined], Initialize[T]]

    Definition Classes
    Init

  22. type ValidatedRef[T] = Either[Undefined, ScopedKey[T]]

    Definition Classes
    Init

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  3. final def ##(): Int

    Definition Classes
    AnyRef → Any

  4. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  5. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  6. val ExtraBuilds: AttributeKey[List[URI]]

  7. object Initialize extends AnyRef

  8. object LoadAction extends Enumeration

  9. val ProjectReturn: AttributeKey[List[File]]

  10. object SettingsDefinition extends AnyRef

  11. def Undefined(definingKey: sbt.Project.ScopedKey[_], referencedKey: sbt.Project.ScopedKey[_]): Undefined

    Definition Classes
    Init

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

    Definition Classes
    Init

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

    Definition Classes
    Init

  14. def addExtraBuilds(s: State, extra: List[URI]): State

  15. def addLocal(init: Seq[sbt.Project.Setting[_]])(implicit scopeLocal: (sbt.Project.ScopedKey[_]) ⇒ Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

    Definition Classes
    Init

  16. def app[HL <: HList, T](inputs: KList[Initialize, HL])(f: (HL) ⇒ T): Initialize[T]

    Definition Classes
    Init

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

    Definition Classes
    Init

  18. def apply(id: String, base: File, aggregate: ⇒ Seq[ProjectReference] = Nil, dependencies: ⇒ Seq[ClasspathDep[ProjectReference]] = Nil, delegates: ⇒ Seq[ProjectReference] = Nil, settings: ⇒ Seq[sbt.Project.Setting[_]] = defaultSettings, configurations: Seq[Configuration] = Configurations.default): Project

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

    Definition Classes
    Init

  20. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

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

    Definition Classes
    Init

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

    Definition Classes
    Init

  23. implicit def classpathDependency[T](p: T)(implicit arg0: (T) ⇒ ProjectReference): ClasspathDependency

    Definition Classes
    ProjectExtra

  24. def clone(): AnyRef

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()

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

  26. def compile(sMap: ScopedMap): CompiledMap

    Definition Classes
    Init

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

    Definition Classes
    Init

  28. implicit def configDependencyConstructor[T](p: T)(implicit arg0: (T) ⇒ ProjectReference): Constructor

    Definition Classes
    ProjectExtra

  29. def current(state: State): ProjectRef

  30. def defaultSettings: Seq[sbt.Project.Setting[_]]

  31. def definitions(structure: BuildStructure, actual: Boolean, key: sbt.AttributeKey[_])(implicit display: Show[sbt.Project.ScopedKey[_]]): Seq[Scope]

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

    Definition Classes
    Init

  33. def delegates(structure: BuildStructure, scope: Scope, key: sbt.AttributeKey[_]): Seq[sbt.Project.ScopedKey[_]]

  34. def details(structure: BuildStructure, actual: Boolean, scope: Scope, key: sbt.AttributeKey[_])(implicit display: Show[sbt.Project.ScopedKey[_]]): String

  35. def display(ref: ProjectReference): String

  36. def display(ref: BuildReference): String

  37. def display(ref: Reference): String

  38. def displayFull(scoped: sbt.Project.ScopedKey[_], keyNameColor: Option[String]): String

  39. def displayFull(scoped: sbt.Project.ScopedKey[_]): String

  40. def displayMasked(scoped: sbt.Project.ScopedKey[_], mask: ScopeMask): String

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

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

    Definition Classes
    Init

  43. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  44. def equal(a: sbt.Project.ScopedKey[_], b: sbt.Project.ScopedKey[_], mask: ScopeMask): Boolean

  45. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any

  46. def extraBuilds(s: State): List[URI]

  47. def extract(se: SessionSettings, st: BuildStructure): Extracted

  48. def extract(state: State): Extracted

  49. def fillTaskAxis(scoped: sbt.Project.ScopedKey[_]): sbt.Project.ScopedKey[_]

  50. def finalize(): Unit

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()

  51. def flattenLocals(compiled: CompiledMap): Map[sbt.Project.ScopedKey[_], Flattened]

    Definition Classes
    Init

  52. final def getClass(): java.lang.Class[_]

    Definition Classes
    AnyRef → Any

  53. def getHook[T](key: SettingKey[(T) ⇒ T], data: Settings[Scope]): (T) ⇒ T

  54. def getHooks(data: Settings[Scope]): ((State) ⇒ State, (State) ⇒ State)

  55. def getOrError[T](state: State, key: AttributeKey[T], msg: String): T

  56. def getOrNil[T](s: State, key: AttributeKey[List[T]]): List[T]

  57. def getProject(ref: ProjectRef, units: Map[URI, LoadedBuildUnit]): Option[ResolvedProject]

  58. def getProject(ref: ProjectRef, structure: LoadedBuild): Option[ResolvedProject]

  59. def getProject(ref: ProjectRef, structure: BuildStructure): Option[ResolvedProject]

  60. def getProjectForReference(ref: Reference, structure: BuildStructure): Option[ResolvedProject]

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

    Definition Classes
    Init

  62. def graphSettings(structure: BuildStructure, actual: Boolean, graphName: String, file: File)(implicit display: Show[sbt.Project.ScopedKey[_]]): Unit

  63. def graphSettings(structure: BuildStructure, basedir: File)(implicit display: Show[sbt.Project.ScopedKey[_]]): Unit

  64. def grouped(init: Seq[sbt.Project.Setting[_]]): ScopedMap

    Definition Classes
    Init

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

    Definition Classes
    Init

  66. def hashCode(): Int

    Definition Classes
    AnyRef → Any

  67. def inConfig(conf: Configuration)(ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

    Definition Classes
    ProjectExtra

  68. def inPluginProject(s: State): Boolean

  69. def inScope(scope: Scope)(ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

    Definition Classes
    ProjectExtra

  70. def inTask(t: Scoped)(ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

    Definition Classes
    ProjectExtra

  71. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  72. def isProjectLoaded(state: State): Boolean

  73. def loadAction(s: State, action: Value): (State, File)

  74. val loadActionParser: Parser[Value]

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

    Definition Classes
    Init

  76. def makeSettings(settings: Seq[sbt.Project.Setting[_]], delegates: (Scope) ⇒ Seq[Scope], scopeLocal: (sbt.Project.ScopedKey[_]) ⇒ Seq[sbt.Project.Setting[_]])(implicit display: Show[sbt.Project.ScopedKey[_]]): Settings[Scope]

  77. def mapScope(f: (Scope) ⇒ Scope): ~>[ScopedKey, ScopedKey]

  78. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  79. final def notify(): Unit

    Definition Classes
    AnyRef

  80. final def notifyAll(): Unit

    Definition Classes
    AnyRef

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

    Definition Classes
    Init

  82. def orIdentity[T](opt: Option[(T) ⇒ T]): (T) ⇒ T

  83. def projectReturn(s: State): List[File]

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

    Definition Classes
    Init

  85. def relation(structure: BuildStructure, actual: Boolean)(implicit display: Show[sbt.Project.ScopedKey[_]]): Rel

  86. def removeExtraBuilds(s: State, remove: List[URI]): State

  87. def resolved(id: String, base: File, aggregate: ⇒ Seq[ProjectRef], dependencies: ⇒ Seq[ResolvedClasspathDependency], delegates: ⇒ Seq[ProjectRef], settings: Seq[sbt.Project.Setting[_]], configurations: Seq[Configuration]): ResolvedProject

  88. def reverseDependencies(cMap: Map[sbt.Project.ScopedKey[_], Flattened], scoped: sbt.Project.ScopedKey[_]): Iterable[sbt.Project.ScopedKey[_]]

  89. implicit def richInitialize[T](i: Initialize[T]): RichInitialize[T]

  90. implicit def richInitializeInputTask[T](init: Initialize[InputTask[T]]): RichInitializeInputTask[T]

  91. implicit def richInitializeTask[T](init: Initialize[Task[T]]): RichInitializeTask[T]

  92. def runTask[T](taskKey: ScopedKey[Task[T]], state: State, config: EvaluateConfig): Option[(State, Result[T])]

  93. def runTask[T](taskKey: ScopedKey[Task[T]], state: State, checkCycles: Boolean): Option[(State, Result[T])]

  94. def runUnloadHooks(s: State): State

  95. def scopedKeyData(structure: BuildStructure, scope: Scope, key: sbt.AttributeKey[_]): Option[sbt.ScopedKeyData[_]]

  96. def session(state: State): SessionSettings

  97. def setAll(extracted: Extracted, settings: Seq[sbt.Project.Setting[_]]): SessionSettings

  98. def setCond[T](key: AttributeKey[T], vopt: Option[T], attributes: AttributeMap): AttributeMap

  99. def setExtraBuilds(s: State, extra: List[URI]): State

  100. def setProject(session: SessionSettings, structure: BuildStructure, s: State): State

  101. def setProjectReturn(s: State, pr: List[File]): State

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

    Definition Classes
    Init

  103. def settingGraph(structure: BuildStructure, basedir: File, scoped: sbt.Project.ScopedKey[_])(implicit display: Show[sbt.Project.ScopedKey[_]]): SettingGraph

  104. def showContextKey(session: SessionSettings, structure: BuildStructure, keyNameColor: Option[String] = None): Show[sbt.Project.ScopedKey[_]]

  105. def showContextKey(state: State, keyNameColor: Option[String]): Show[sbt.Project.ScopedKey[_]]

  106. def showContextKey(state: State): Show[sbt.Project.ScopedKey[_]]

  107. def showDefinitions(key: sbt.AttributeKey[_], defs: Seq[Scope])(implicit display: Show[sbt.Project.ScopedKey[_]]): String

  108. def showFullKey(keyNameColor: Option[String]): Show[sbt.Project.ScopedKey[_]]

  109. lazy val showFullKey: Show[sbt.Project.ScopedKey[_]]

    Definition Classes
    Project → Init

  110. def showLoadingKey(loaded: LoadedBuild, keyNameColor: Option[String] = None): Show[sbt.Project.ScopedKey[_]]

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

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

    Definition Classes
    Init

  113. def showUses(defs: Seq[sbt.Project.ScopedKey[_]])(implicit display: Show[sbt.Project.ScopedKey[_]]): String

  114. def sort(cMap: CompiledMap): Seq[sbt.Project.Compiled[_]]

    Definition Classes
    Init

  115. def structure(state: State): BuildStructure

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

    Definition Classes
    AnyRef

  117. def toString(): String

    Definition Classes
    AnyRef → Any

  118. def transform(g: (Scope) ⇒ Scope, ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

  119. def transformRef(g: (Scope) ⇒ Scope, ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

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

    Definition Classes
    Init

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

    Definition Classes
    Init

  122. def updateCurrent(s: State): State

  123. def updateExtraBuilds(s: State, f: (List[URI]) ⇒ List[URI]): State

  124. def usedBy(structure: BuildStructure, actual: Boolean, key: sbt.AttributeKey[_])(implicit display: Show[sbt.Project.ScopedKey[_]]): Seq[sbt.Project.ScopedKey[_]]

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

    Definition Classes
    Init

  126. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

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

    Definition Classes
    AnyRef
    Annotations
    @throws()

  128. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

Deprecated Value Members

  1. def evaluateTask[T](taskKey: ScopedKey[Task[T]], state: State, checkCycles: Boolean, maxWorkers: Int): Option[Result[T]]

    Annotations
    @deprecated
    Deprecated

    (Since version 0.11.1) This method does not apply state changes requested during task execution. Use 'runTask' instead, which does.

Inherited from ProjectExtra

Inherited from Init[Scope]

Inherited from AnyRef

Inherited from Any