Resolution

Instance Constructors

new Resolution(rootDependencies: Set[Dependency], dependencies: Set[Dependency], forceVersions: Map[Module, String], conflicts: Set[Dependency], projectCache: Map[Resolution.ModuleVersion, (Source, Project)], errorCache: Map[Resolution.ModuleVersion, Seq[String]], finalDependenciesCache: Map[Dependency, Seq[Dependency]], filter: Option[(Dependency) ⇒ Boolean], profileActivation: Option[(String, Activation, Map[String, String]) ⇒ Boolean])

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 artifacts: Seq[Artifact]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def classifiersArtifacts(classifiers: Seq[String]): Seq[Artifact]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val conflicts: Set[Dependency]
def copyWithCache(rootDependencies: Set[Dependency] = rootDependencies, dependencies: Set[Dependency] = dependencies, forceVersions: Map[Module, String] = forceVersions, conflicts: Set[Dependency] = conflicts, projectCache: Map[Resolution.ModuleVersion, (Source, Project)] = projectCache, errorCache: Map[Resolution.ModuleVersion, Seq[String]] = errorCache, filter: Option[(Dependency) ⇒ Boolean] = filter, profileActivation: Option[(String, Activation, Map[String, String]) ⇒ Boolean] = profileActivation): Resolution
val dependencies: Set[Dependency]
def dependencyArtifacts: Seq[(Dependency, Artifact)]
def dependencyClassifiersArtifacts(classifiers: Seq[String]): Seq[(Dependency, Artifact)]
def dependencyManagementMissing(project: Project): Set[Resolution.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[Resolution.ModuleVersion]

Required modules for the dependency management of project.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val errorCache: Map[Resolution.ModuleVersion, Seq[String]]
def errors: Seq[(Dependency, Seq[String])]
val filter: Option[(Dependency) ⇒ Boolean]
val finalDependenciesCache: Map[Dependency, Seq[Dependency]]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val forceVersions: Map[Module, String]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
lazy val isDone: Boolean

Whether the resolution is done.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
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[Resolution.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
final def notifyAll(): Unit

Definition Classes
AnyRef
val profileActivation: Option[(String, Activation, Map[String, String]) ⇒ Boolean]
val projectCache: Map[Resolution.ModuleVersion, (Source, Project)]
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).
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: Set[Dependency]
def subset(dependencies: Set[Dependency]): Resolution

Removes from this Resolution dependencies that are not in dependencies neither brought transitively by them.
Removes from this Resolution dependencies that are not in dependencies 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
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.
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( ... )
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.

Related Docs: object Resolution | package core

Instance Constructors

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def artifacts: Seq[Artifact]

final def asInstanceOf[T0]: T0

def classifiersArtifacts(classifiers: Seq[String]): Seq[Artifact]

def clone(): AnyRef

val conflicts: Set[Dependency]

val dependencies: Set[Dependency]

def dependencyArtifacts: Seq[(Dependency, Artifact)]

def dependencyClassifiersArtifacts(classifiers: Seq[String]): Seq[(Dependency, Artifact)]

def dependencyManagementMissing(project: Project): Set[Resolution.ModuleVersion]

def dependencyManagementRequirements(project: Project): Set[Resolution.ModuleVersion]

final def eq(arg0: AnyRef): Boolean

val errorCache: Map[Resolution.ModuleVersion, Seq[String]]

def errors: Seq[(Dependency, Seq[String])]

val filter: Option[(Dependency) ⇒ Boolean]

val finalDependenciesCache: Map[Dependency, Seq[Dependency]]

def finalize(): Unit

val forceVersions: Map[Module, String]

final def getClass(): Class[_]

lazy val isDone: Boolean

final def isInstanceOf[T0]: Boolean

def minDependencies: Set[Dependency]

lazy val missingFromCache: Set[Resolution.ModuleVersion]

final def ne(arg0: AnyRef): Boolean

lazy val newDependencies: Set[Dependency]

lazy val nextDependenciesAndConflicts: (Seq[Dependency], Seq[Dependency], Map[Module, String])

final def nextIfNoMissing: Resolution

final def notify(): Unit

final def notifyAll(): Unit

val profileActivation: Option[(String, Activation, Map[String, String]) ⇒ Boolean]

val projectCache: Map[Resolution.ModuleVersion, (Source, Project)]

lazy val remainingDependencies: Set[Dependency]

lazy val reverseDependencies: Map[Dependency, Vector[Dependency]]

val rootDependencies: Set[Dependency]

def subset(dependencies: Set[Dependency]): Resolution

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

lazy val transitiveDependencies: Seq[Dependency]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withDependencyManagement(project: Project): Project

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped