sbt

Load

object Load extends AnyRef

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. Hide All
  2. Show all
  1. Load
  2. AnyRef
  3. Any
Visibility
  1. Public
  2. All

Type Members

  1. final class BuildStructure extends AnyRef

  2. final class BuildUnit extends AnyRef

  3. sealed trait BuildUnitBase extends AnyRef

  4. final class EvaluatedConfigurations extends AnyRef

  5. final case class InjectSettings(global: Seq[sbt.Project.Setting[_]], project: Seq[sbt.Project.Setting[_]], projectLoaded: (ClassLoader) ⇒ Seq[sbt.Project.Setting[_]]) extends Product with Serializable

  6. final case class LoadBuildConfiguration(stagingDirectory: File, classpath: Seq[Attributed[File]], loader: ClassLoader, compilers: Compilers, evalPluginDef: (BuildStructure, State) ⇒ PluginData, definesClass: (File) ⇒ (String) ⇒ Boolean, delegates: (LoadedBuild) ⇒ (Scope) ⇒ Seq[Scope], scopeLocal: (sbt.Project.ScopedKey[_]) ⇒ Seq[sbt.Project.Setting[_]], pluginManagement: PluginManagement, injectSettings: InjectSettings, globalPlugin: Option[GlobalPlugin], extraBuilds: Seq[URI], log: Logger) extends Product with Serializable

  7. final class LoadedBuild extends AnyRef

  8. final class LoadedBuildUnit extends BuildUnitBase

  9. final class LoadedDefinitions extends AnyRef

  10. final class LoadedPlugins extends AnyRef

  11. final class PartBuild extends AnyRef

  12. final class PartBuildUnit extends BuildUnitBase

  13. final class StructureIndex extends AnyRef

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. def activateGlobalPlugin(config: LoadBuildConfiguration): LoadBuildConfiguration

  7. def addOverrides(unit: BuildUnit, loaders: BuildLoader): BuildLoader

  8. def addResolvers(unit: BuildUnit, isRoot: Boolean, loaders: BuildLoader): BuildLoader

  9. def apply(rootBase: File, s: State, config: LoadBuildConfiguration): (() ⇒ Eval, BuildStructure)

  10. final def asInstanceOf[T0]: T0

    Definition Classes
    Any
  11. val autoPluginSettings: Seq[sbt.Project.Setting[_]]

  12. def baseImports: List[String]

  13. def binaryPlugins(classpath: Seq[File], loader: ClassLoader): Seq[String]

  14. def build(classpath: Seq[Attributed[File]], sources: Seq[File], target: File, compilers: Compilers, definesClass: (File) ⇒ (String) ⇒ Boolean, log: Logger): (Inputs, Analysis)

  15. def buildConfigurations(loaded: LoadedBuild, rootProject: (URI) ⇒ String, rootEval: () ⇒ Eval, injectSettings: InjectSettings): Seq[sbt.Project.Setting[_]]

  16. def buildGlobalSettings(base: File, files: Seq[File], config: LoadBuildConfiguration): (ClassLoader) ⇒ Seq[sbt.Project.Setting[_]]

  17. def buildPluginDefinition(dir: File, s: State, config: LoadBuildConfiguration): PluginData

  18. def buildPlugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins

  19. def buildSettings(unit: BuildUnit): Seq[sbt.Project.Setting[_]]

  20. def buildUtil(root: URI, units: Map[URI, LoadedBuildUnit], keyIndex: KeyIndex, data: Settings[Scope]): BuildUtil[ResolvedProject]

  21. def builtinLoader(s: State, config: LoadBuildConfiguration): BuildLoader

  22. def checkAll(referenced: Map[URI, List[ProjectReference]], builds: Map[URI, PartBuildUnit]): Unit

  23. def checkBuildBase(base: File): Unit

  24. def checkCycles(units: Map[URI, LoadedBuildUnit]): Unit

  25. def checkDirectory(base: File): Unit

  26. def checkProjectBase(buildBase: File, projectBase: File): Unit

  27. def clone(): AnyRef

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  28. def configInherit(lb: LoadedBuild, ref: ResolvedReference, config: ConfigKey, rootProject: (URI) ⇒ String): Seq[ConfigKey]

  29. def configInheritRef(lb: LoadedBuild, ref: ProjectRef, config: ConfigKey): Seq[ConfigKey]

  30. def configurationOpt(map: Map[URI, LoadedBuildUnit], uri: URI, id: String, conf: ConfigKey): Option[Configuration]

  31. def configurations(srcs: Seq[File], eval: () ⇒ Eval, imports: Seq[String]): (ClassLoader) ⇒ Seq[sbt.Project.Setting[_]]

  32. def defaultDelegates: (LoadedBuild) ⇒ (Scope) ⇒ Seq[Scope]

  33. def defaultEvalOptions: Seq[String]

  34. def defaultLoad(state: State, baseDirectory: File, log: Logger, isPlugin: Boolean = false, topLevelExtras: List[URI] = Nil): (() ⇒ Eval, BuildStructure)

  35. def defaultPreGlobal(state: State, baseDirectory: File, definesClass: (File) ⇒ (String) ⇒ Boolean, globalBase: File, log: Logger): LoadBuildConfiguration

  36. def defaultWithGlobal(state: State, base: File, rawConfig: LoadBuildConfiguration, globalBase: File, log: Logger): LoadBuildConfiguration

  37. def definitions(base: File, targetBase: File, srcs: Seq[File], plugins: LoadedPlugins, definesClass: (File) ⇒ (String) ⇒ Boolean, compilers: Compilers, log: Logger): LoadedDefinitions

  38. def discover(analysis: Analysis, subclasses: String*): Seq[String]

  39. def emptyBuild(uri: URI): Nothing

  40. def enableSbtPlugin(config: LoadBuildConfiguration): LoadBuildConfiguration

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

    Definition Classes
    AnyRef
  42. def equals(arg0: Any): Boolean

    Definition Classes
    AnyRef → Any
  43. def extractSettings(plugins: Seq[Plugin]): (Seq[sbt.Project.Setting[_]], Seq[sbt.Project.Setting[_]], Seq[sbt.Project.Setting[_]])

  44. def finalTransforms(ss: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

  45. def finalize(): Unit

    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws()
  46. def findDefinitions(analysis: Analysis): Seq[String]

  47. def findPlugins(analysis: Analysis): Seq[String]

  48. def getBuild[T](map: Map[URI, T], uri: URI): T

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

    Definition Classes
    AnyRef → Any
  50. def getConfiguration(map: Map[URI, LoadedBuildUnit], uri: URI, id: String, conf: ConfigKey): Configuration

  51. def getImports(unit: BuildUnit): List[String]

  52. def getPluginNames(classpath: Seq[Attributed[File]], loader: ClassLoader): Seq[String]

  53. def getProject(map: Map[URI, LoadedBuildUnit], uri: URI, id: String): ResolvedProject

  54. def getRootProject(map: Map[URI, BuildUnitBase]): (URI) ⇒ String

  55. def globalPluginClasspath(globalPlugin: Option[GlobalPlugin]): Seq[Attributed[File]]

  56. def hasDefinition(dir: File): Boolean

  57. def hashCode(): Int

    Definition Classes
    AnyRef → Any
  58. def importAll(values: Seq[String]): List[String]

  59. def importAllRoot(values: Seq[String]): List[String]

  60. def initialSession(structure: BuildStructure, rootEval: () ⇒ Eval): SessionSettings

  61. def initialSession(structure: BuildStructure, rootEval: () ⇒ Eval, s: State): SessionSettings

  62. def injectGlobal(state: State): Seq[sbt.Project.Setting[_]]

  63. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any
  64. def isProjectThis(s: sbt.Project.Setting[_]): Boolean

  65. def lazyEval(unit: BuildUnit): () ⇒ Eval

  66. def load(file: File, loaders: BuildLoader, extra: List[URI]): PartBuild

  67. def load(file: File, s: State, config: LoadBuildConfiguration): PartBuild

  68. def loadAll(bases: List[URI], references: Map[URI, List[ProjectReference]], loaders: BuildLoader, builds: Map[URI, PartBuildUnit]): (Map[URI, List[ProjectReference]], Map[URI, PartBuildUnit], BuildLoader)

    Annotations
    @tailrec()
  69. def loadDefinition(loader: ClassLoader, definition: String): Build

  70. def loadDefinitions(loader: ClassLoader, defs: Seq[String]): Seq[Build]

  71. def loadGlobal(state: State, base: File, global: File, config: LoadBuildConfiguration): LoadBuildConfiguration

  72. def loadGlobalSettings(base: File, globalBase: File, files: Seq[File], config: LoadBuildConfiguration): LoadBuildConfiguration

  73. def loadPlugin(pluginName: String, loader: ClassLoader): Plugin

  74. def loadPluginDefinition(dir: File, config: LoadBuildConfiguration, pluginData: PluginData): LoadedPlugins

  75. def loadPlugins(loader: ClassLoader, pluginNames: Seq[String]): Seq[Plugin]

  76. def loadPlugins(dir: File, data: PluginData, loader: ClassLoader): LoadedPlugins

  77. def loadURI(uri: URI, loaders: BuildLoader, extra: List[URI]): PartBuild

  78. def loadUnit(uri: URI, localBase: File, s: State, config: LoadBuildConfiguration): BuildUnit

  79. def loadUnitNew(defDir: File, s: State, config: LoadBuildConfiguration): (LoadedPlugins, LoadedDefinitions)

  80. def loadUnitOld(defDir: File, pluginDir: File, s: State, config: LoadBuildConfiguration): (LoadedPlugins, LoadedDefinitions)

  81. def loaded(unit: BuildUnit): (PartBuildUnit, List[ProjectReference])

  82. def mkEval(classpath: Seq[File], base: File, options: Seq[String]): Eval

  83. def mkEval(defs: LoadedDefinitions, plugs: LoadedPlugins, options: Seq[String]): Eval

  84. def mkEval(unit: BuildUnit): Eval

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

    Definition Classes
    AnyRef
  86. def noBuild(uri: URI): Nothing

  87. def noConfiguration(uri: URI, id: String, conf: String): Nothing

  88. def noPlugins(dir: File, config: LoadBuildConfiguration): LoadedPlugins

  89. def noProject(uri: URI, id: String): Nothing

  90. final def notify(): Unit

    Definition Classes
    AnyRef
  91. final def notifyAll(): Unit

    Definition Classes
    AnyRef
  92. def onClasspath(classpath: Seq[File])(url: URL): Boolean

  93. def pluginDefinitionLoader(config: LoadBuildConfiguration, depcp: Seq[Attributed[File]], defcp: Seq[Attributed[File]]): (Seq[Attributed[File]], ClassLoader)

  94. def pluginDefinitionLoader(config: LoadBuildConfiguration, pluginData: PluginData): (Seq[Attributed[File]], ClassLoader)

  95. def pluginDefinitionLoader(config: LoadBuildConfiguration, dependencyClasspath: Seq[Attributed[File]]): (Seq[Attributed[File]], ClassLoader)

  96. def pluginGlobalSettings(loaded: LoadedBuild): Seq[sbt.Project.Setting[_]]

  97. def plugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins

  98. def projectInherit(lb: LoadedBuild, ref: ProjectRef): Seq[ProjectRef]

  99. def projectMap(structure: BuildStructure, current: Map[URI, String]): Map[URI, String]

  100. def projectScope(project: Reference): Scope

  101. def projects(unit: BuildUnit): Seq[Project]

  102. def reapply(newSettings: Seq[sbt.Project.Setting[_]], structure: BuildStructure)(implicit display: Show[sbt.Project.ScopedKey[_]]): BuildStructure

  103. def referenced[PR <: ProjectReference](definitions: Seq[ProjectDefinition[PR]]): Seq[PR]

  104. def resolveAll(builds: Map[URI, PartBuildUnit]): Map[URI, LoadedBuildUnit]

  105. def resolveBase(against: File): (Project) ⇒ Project

  106. def resolveProjects(uri: URI, unit: PartBuildUnit, rootProject: (URI) ⇒ String): LoadedBuildUnit

  107. def resolveProjects(loaded: PartBuild): LoadedBuild

  108. def rootedName(s: String): String

  109. def setDefinitionKey[T](tk: Task[T], key: sbt.Project.ScopedKey[_]): Task[T]

  110. def structureIndex(data: Settings[Scope], settings: Seq[sbt.Project.Setting[_]], extra: (KeyIndex) ⇒ sbt.BuildUtil[_]): StructureIndex

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

    Definition Classes
    AnyRef
  112. def toString(): String

    Definition Classes
    AnyRef → Any
  113. def transformProjectOnly(uri: URI, rootProject: (URI) ⇒ String, settings: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

  114. def transformSettings(thisScope: Scope, uri: URI, rootProject: (URI) ⇒ String, settings: Seq[sbt.Project.Setting[_]]): Seq[sbt.Project.Setting[_]]

  115. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  116. final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()
  117. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws()

Inherited from AnyRef

Inherited from Any