Resolution

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

Definition Classes
AnyRef
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 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
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( ... )
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

Related Docs: object Resolution | package core

final class Resolution extends Product with Serializable

Instance Constructors

new Resolution()

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, (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

def canEqual(obj: Any): Boolean

def clone(): AnyRef

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]

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

val dependencySet: DependencySet

final def eq(arg0: AnyRef): Boolean

def equals(obj: Any): 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 hashCode: Int

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

def orderedDependencies: Seq[Dependency]

val osInfo: Os

def productArity: Int

def productElement(n: Int): Any

def productIterator: Iterator[Any]

def productPrefix: String

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

lazy val reconciledVersions: Map[Module, String]

val reconciliation: Option[(Module) ⇒ Reconciliation]

lazy val remainingDependencies: Set[Dependency]

def retainedVersions: Map[Module, String]

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

val rootDependencies: Seq[Dependency]

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

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

def toString(): String

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 withConflicts(conflicts: Set[Dependency]): Resolution

def withDefaultConfiguration(defaultConfiguration: Configuration): Resolution

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