Resolution

Instance Constructors

new Resolution(rootDependencies: Seq[Dependency], dependencies: Set[Dependency], forceVersions: Map[Module, String], conflicts: Set[Dependency], projectCache: Map[ModuleVersion, (Source, Project)], errorCache: Map[ModuleVersion, Seq[String]], finalDependenciesCache: Map[Dependency, Seq[Dependency]], filter: Option[(Dependency) ⇒ Boolean], osInfo: Os, jdkVersion: Option[Version], userActivations: Option[Map[String, Boolean]], mapDependencies: Option[(Dependency) ⇒ Dependency], extraProperties: Seq[(String, String)], forceProperties: Map[String, String])

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, (Source, Project))*): Resolution
def artifacts(types: Set[Type] = defaultTypes, classifiers: Option[Seq[Classifier]] = None): Seq[Artifact]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val conflicts: Set[Dependency]
val dependencies: Set[Dependency]
def dependenciesOf(dep: Dependency, withReconciledVersions: Boolean = true): Seq[Dependency]
def dependenciesWithSelectedVersions: Set[Dependency]
def dependencyArtifacts(classifiers: Option[Seq[Classifier]] = None): 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.
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef
val osInfo: Os
val projectCache: Map[ModuleVersion, (Source, Project)]
def reconciledVersions: Map[Module, String]
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: Seq[Dependency]
def subset(dependencies: Seq[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.
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( ... )
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.

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 artifacts: 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 dependencyArtifacts: 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

Related Docs: object Resolution | package core

Instance Constructors

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addToErrorCache(entries: Iterable[(ModuleVersion, Seq[String])]): Resolution

def addToProjectCache(projects: (ModuleVersion, (Source, Project))*): Resolution

def artifacts(types: Set[Type] = defaultTypes, classifiers: Option[Seq[Classifier]] = None): Seq[Artifact]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val conflicts: Set[Dependency]

val dependencies: Set[Dependency]

def dependenciesOf(dep: Dependency, withReconciledVersions: Boolean = true): Seq[Dependency]

def dependenciesWithSelectedVersions: Set[Dependency]

def dependencyArtifacts(classifiers: Option[Seq[Classifier]] = None): Seq[(Dependency, Publication, Artifact)]

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

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

final def eq(arg0: AnyRef): Boolean

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

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

val extraProperties: Seq[(String, String)]

val filter: Option[(Dependency) ⇒ Boolean]

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

def finalize(): Unit

val forceProperties: Map[String, String]

val forceVersions: Map[Module, String]

final def getClass(): Class[_]

lazy val isDone: Boolean

final def isInstanceOf[T0]: Boolean

val jdkVersion: Option[Version]

val mapDependencies: Option[(Dependency) ⇒ Dependency]

def minDependencies: Set[Dependency]

lazy val missingFromCache: Set[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 osInfo: Os

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

def reconciledVersions: Map[Module, String]

lazy val remainingDependencies: Set[Dependency]

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

val rootDependencies: Seq[Dependency]

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

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

lazy val transitiveDependencies: Seq[Dependency]

val userActivations: Option[Map[String, Boolean]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withDependencyManagement(project: Project): Project

Deprecated Value Members

def artifacts(withOptional: Boolean): Seq[Artifact]

def artifacts: Seq[Artifact]

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

def dependencyArtifacts(withOptional: Boolean): Seq[(Dependency, Artifact)]

def dependencyArtifacts: Seq[(Dependency, Artifact)]

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

def metadataErrors: Seq[(ModuleVersion, Seq[String])]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped