final class Resolution extends Product with Serializable
State of a dependency resolution.
Done if method isDone
returns true
.
- Alphabetic
- By Inheritance
- Resolution
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new Resolution()
- new Resolution(rootDependencies: Seq[Dependency], dependencySet: DependencySet, forceVersions: Map[Module, String], conflicts: Set[Dependency], projectCache: Map[ModuleVersion, (ArtifactSource, Project)], errorCache: Map[ModuleVersion, Seq[String]], finalDependenciesCache: Map[Dependency, Seq[Dependency]], filter: Option[(Dependency) => Boolean], reconciliation: Option[(Module) => Reconciliation], osInfo: Os, jdkVersion: Option[Version], userActivations: Option[Map[String, Boolean]], mapDependencies: Option[(Dependency) => Dependency], extraProperties: Seq[(String, String)], forceProperties: Map[String, String], defaultConfiguration: Configuration)
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def addToErrorCache(entries: Iterable[(ModuleVersion, Seq[String])]): Resolution
- def addToProjectCache(projects: (ModuleVersion, (ArtifactSource, Project))*): Resolution
- def artifacts(types: Set[Type], classifiers: Option[Seq[Classifier]], classpathOrder: Boolean): Seq[Artifact]
- def artifacts(types: Set[Type], classifiers: Option[Seq[Classifier]]): Seq[Artifact]
- def artifacts(classifiers: Option[Seq[Classifier]]): Seq[Artifact]
- def artifacts(types: Set[Type]): Seq[Artifact]
- def artifacts(): Seq[Artifact]
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def canEqual(obj: Any): Boolean
- Definition Classes
- Resolution → Equals
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- val conflicts: Set[Dependency]
- val defaultConfiguration: Configuration
- lazy val dependencies: Set[Dependency]
- def dependenciesOf(dep: Dependency, withRetainedVersions: Boolean, withFallbackConfig: Boolean): Seq[Dependency]
- def dependenciesOf(dep: Dependency, withRetainedVersions: Boolean): Seq[Dependency]
- def dependenciesOf(dep: Dependency): Seq[Dependency]
- def dependenciesWithRetainedVersions: Set[Dependency]
- def dependencyArtifacts(classifiers: Option[Seq[Classifier]], classpathOrder: Boolean): Seq[(Dependency, Publication, Artifact)]
- def dependencyArtifacts(classifiers: Option[Seq[Classifier]]): Seq[(Dependency, Publication, Artifact)]
- def dependencyArtifacts(): Seq[(Dependency, Publication, Artifact)]
- def dependencyManagementMissing(project: Project): Set[ModuleVersion]
Missing modules in cache, to get the full list of dependencies of
project
, taking dependency management / inheritance into account.Missing modules in cache, to get the full list of dependencies of
project
, taking dependency management / inheritance into account.Note that adding the missing modules to the cache may unveil other missing modules, so these modules should be added to the cache, and
dependencyManagementMissing
checked again for new missing modules. - def dependencyManagementRequirements(project: Project): Set[ModuleVersion]
Required modules for the dependency management of
project
. - val dependencySet: DependencySet
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(obj: Any): Boolean
- Definition Classes
- Resolution → Equals → AnyRef → Any
- val errorCache: Map[ModuleVersion, Seq[String]]
- def errors: Seq[(ModuleVersion, Seq[String])]
Returns errors on dependencies
Returns errors on dependencies
- returns
errors
- val extraProperties: Seq[(String, String)]
- val filter: Option[(Dependency) => Boolean]
- val finalDependenciesCache: Map[Dependency, Seq[Dependency]]
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- val forceProperties: Map[String, String]
- val forceVersions: Map[Module, String]
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- lazy val hashCode: Int
- Definition Classes
- Resolution → AnyRef → Any
- lazy val isDone: Boolean
Whether the resolution is done.
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- val jdkVersion: Option[Version]
- val mapDependencies: Option[(Dependency) => Dependency]
- def minDependencies: Set[Dependency]
Minimized dependency set.
Minimized dependency set. Returns
dependencies
with no redundancy.E.g.
dependencies
may contains several dependencies towards module org:name:version, a first one excluding A and B, and a second one excluding A and C. In practice, B and C will be brought anyway, because the first dependency doesn't exclude C, and the second one doesn't exclude B. So having both dependencies is equivalent to having only one dependency towards org:name:version, excluding just A.The same kind of substitution / filtering out can be applied with configurations. If
dependencies
contains several dependencies towards org:name:version, a first one bringing its configuration "runtime", a second one "compile", and the configuration mapping of org:name:version says that "runtime" extends "compile", then all the dependencies brought by the latter will be brought anyway by the former, so that the latter can be removed.- returns
A minimized
dependencies
, applying this kind of substitutions.
- lazy val missingFromCache: Set[ModuleVersion]
The modules we miss some info about.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- lazy val newDependencies: Set[Dependency]
The final next dependency set, stripped of no more required ones.
- lazy val nextDependenciesAndConflicts: (Seq[Dependency], Seq[Dependency], Map[Module, String])
The "next" dependency set, made of the current dependencies and their transitive dependencies, trying to solve version conflicts.
The "next" dependency set, made of the current dependencies and their transitive dependencies, trying to solve version conflicts. Transitive dependencies are calculated with the current cache.
May contain dependencies added in previous iterations, but no more required. These are filtered below, see
newDependencies
.Returns a tuple made of the conflicting dependencies, all the dependencies, and the retained version of each module.
- final def nextIfNoMissing: Resolution
If no module info is missing, the next state of the resolution, which can be immediately calculated.
If no module info is missing, the next state of the resolution, which can be immediately calculated. Else, the current resolution.
- Annotations
- @tailrec()
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def orderedDependencies: Seq[Dependency]
- val osInfo: Os
- def productArity: Int
- Definition Classes
- Resolution → Product
- def productElement(n: Int): Any
- Definition Classes
- Resolution → Product
- def productElementName(n: Int): String
- Definition Classes
- Resolution → Product
- def productElementNames: Iterator[String]
- Definition Classes
- Product
- def productIterator: Iterator[Any]
- Definition Classes
- Product
- def productPrefix: String
- Definition Classes
- Resolution → Product
- val projectCache: Map[ModuleVersion, (ArtifactSource, Project)]
- lazy val reconciledVersions: Map[Module, String]
- val reconciliation: Option[(Module) => Reconciliation]
- lazy val remainingDependencies: Set[Dependency]
Returns dependencies from the "next" dependency set, filtering out those that are no more required.
Returns dependencies from the "next" dependency set, filtering out those that are no more required.
The versions of all the dependencies returned are erased (emptied).
- def retainedVersions: Map[Module, String]
- lazy val reverseDependencies: Map[Dependency, Vector[Dependency]]
Returns a map giving the dependencies that brought each of the dependency of the "next" dependency set.
Returns a map giving the dependencies that brought each of the dependency of the "next" dependency set.
The versions of all the dependencies returned are erased (emptied).
- val rootDependencies: Seq[Dependency]
- def subset(dependencies: Seq[Dependency]): Resolution
Removes from this
Resolution
dependencies that are not independencies
neither brought transitively by them.Removes from this
Resolution
dependencies that are not independencies
neither brought transitively by them.This keeps the versions calculated by this
Resolution
. The common dependencies of different subsets will thus be guaranteed to have the same versions. - final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- Resolution → AnyRef → Any
- lazy val transitiveDependencies: Seq[Dependency]
Transitive dependencies of the current dependencies, according to what there currently is in cache.
Transitive dependencies of the current dependencies, according to what there currently is in cache.
No attempt is made to solve version conflicts here.
- val userActivations: Option[Map[String, Boolean]]
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- def withConflicts(conflicts: Set[Dependency]): Resolution
- def withDefaultConfiguration(defaultConfiguration: Configuration): Resolution
- def withDependencies(dependencies: Set[Dependency]): Resolution
- def withDependencyManagement(project: Project): Project
Add dependency management / inheritance related items to
project
, from what's available in cache.Add dependency management / inheritance related items to
project
, from what's available in cache.It is recommended to have fetched what
dependencyManagementMissing
returned prior to calling this. - def withDependencySet(dependencySet: DependencySet): Resolution
- def withErrorCache(errorCache: Map[ModuleVersion, Seq[String]]): Resolution
- def withExtraProperties(extraProperties: Seq[(String, String)]): Resolution
- def withFilter(filter: Option[(Dependency) => Boolean]): Resolution
- def withFinalDependenciesCache(finalDependenciesCache: Map[Dependency, Seq[Dependency]]): Resolution
- def withForceProperties(forceProperties: Map[String, String]): Resolution
- def withForceVersions(forceVersions: Map[Module, String]): Resolution
- def withJdkVersion(jdkVersion: Option[Version]): Resolution
- def withMapDependencies(mapDependencies: Option[(Dependency) => Dependency]): Resolution
- def withOsInfo(osInfo: Os): Resolution
- def withProjectCache(projectCache: Map[ModuleVersion, (ArtifactSource, Project)]): Resolution
- def withReconciliation(reconciliation: Option[(Module) => Reconciliation]): Resolution
- def withRootDependencies(rootDependencies: Seq[Dependency]): Resolution
- def withUserActivations(userActivations: Option[Map[String, Boolean]]): Resolution
Deprecated Value Members
- def artifacts(withOptional: Boolean): Seq[Artifact]
- Annotations
- @deprecated
- Deprecated
(Since version 1.1.0-M8) Use artifacts overload accepting types and classifiers instead
- def classifiersArtifacts(classifiers: Seq[String]): Seq[Artifact]
- Annotations
- @deprecated
- Deprecated
(Since version 1.1.0-M8) Use the artifacts overload accepting types and classifiers instead
- def dependencyArtifacts(withOptional: Boolean): Seq[(Dependency, Artifact)]
- Annotations
- @deprecated
- Deprecated
(Since version 1.1.0-M8) Use dependencyArtifacts overload accepting classifiers instead
- def dependencyClassifiersArtifacts(classifiers: Seq[String]): Seq[(Dependency, Artifact)]
- Annotations
- @deprecated
- Deprecated
(Since version 1.1.0-M8) Use dependencyArtifacts overload accepting classifiers instead
- def metadataErrors: Seq[(ModuleVersion, Seq[String])]
- Annotations
- @deprecated
- Deprecated
(Since version 1.1.0) Use errors instead