final class Resolution extends Product with Serializable
State of a dependency resolution.
Done if method isDone
returns true
.
- Alphabetic
- By Inheritance
- Resolution
- Serializable
- Serializable
- Product
- Equals
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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( ... ) @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[_]
- 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
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( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @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