DefaultResolutionStrategy (Gradle API 1.0)

java.lang.Object
- org.gradle.api.internal.artifacts.configurations.DefaultResolutionStrategy

All Implemented Interfaces:

ResolutionStrategy, ResolutionStrategyInternal
```
public class DefaultResolutionStrategy
extends Object
implements ResolutionStrategyInternal
```
by Szczepan Faber, created at: 10/7/11

Constructor Summary

Constructors
Constructor and Description

DefaultResolutionStrategy()

Constructors
Constructor and Description
`DefaultResolutionStrategy()`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`cacheChangingModulesFor(int value, String units)` Sets the length of time that changing modules will be cached, with units expressed as a String.
`void`	`cacheChangingModulesFor(int value, TimeUnit units)` Sets the length of time that changing modules will be cached.
`void`	`cacheDynamicVersionsFor(int value, String units)` Sets the length of time that dynamic versions will be cached, with units expressed as a String.
`void`	`cacheDynamicVersionsFor(int value, TimeUnit units)` Sets the length of time that dynamic versions will be cached.
`ResolutionStrategy`	`failOnVersionConflict()` In case of conflict, Gradle by default uses the newest of conflicting versions.
`DefaultResolutionStrategy`	`force(Object... forcedModuleNotations)` Allows forcing certain versions of dependencies, including transitive dependencies.
`CachePolicy`	`getCachePolicy()` Gets the current expiry policy for dynamic revisions.
`ConflictResolution`	`getConflictResolution()` Until the feature 'settles' and we receive more feedback, it's internal
`Set<ModuleVersionSelector>`	`getForcedModules()` Returns currently configured forced modules.
`ResolutionRules`	`getResolutionRules()` The nascent DSL for cache control, and possibly other per-module resolution overrides
`DefaultResolutionStrategy`	`setForcedModules(Object... forcedModuleNotations)` Allows forcing certain versions of dependencies, including transitive dependencies.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DefaultResolutionStrategy
```
public DefaultResolutionStrategy()
```
- Method Detail
  - getForcedModules
```
public Set<ModuleVersionSelector> getForcedModules()
```
    Description copied from interface: ResolutionStrategy
    
    Returns currently configured forced modules. For more information on forcing versions see ResolutionStrategy.force(Object...)
    
    Specified by:
    
    getForcedModules in interface ResolutionStrategy
    
    Returns:
    forced modules
  - failOnVersionConflict
```
public ResolutionStrategy failOnVersionConflict()
```
    Description copied from interface: ResolutionStrategy
    In case of conflict, Gradle by default uses the newest of conflicting versions. However, you can change this behavior. Use this method to configure the resolution to fail eagerly on any version conflict, e.g. multiple different versions of the same dependency (group and name are equal) in the same Configuration. The check includes both first level and transitive dependencies. See example below:
```
 configurations.all {
   resolutionStrategy.failOnVersionConflict()
 }
 
```
    Specified by:
    
    failOnVersionConflict in interface ResolutionStrategy
    
    Returns:
    this resolution strategy instance
  - getConflictResolution
```
public ConflictResolution getConflictResolution()
```
    Description copied from interface: ResolutionStrategyInternal
    
    Until the feature 'settles' and we receive more feedback, it's internal
    
    Specified by:
    
    getConflictResolution in interface ResolutionStrategyInternal
    
    Returns:
    conflict resolution
  - getResolutionRules
```
public ResolutionRules getResolutionRules()
```
    Description copied from interface: ResolutionStrategyInternal
    
    The nascent DSL for cache control, and possibly other per-module resolution overrides
    
    Specified by:
    
    getResolutionRules in interface ResolutionStrategyInternal
    
    Returns:
    the resolution rules
  - force
```
public DefaultResolutionStrategy force(Object... forcedModuleNotations)
```
    Description copied from interface: ResolutionStrategy
    Allows forcing certain versions of dependencies, including transitive dependencies. Appends new forced modules to be considered when resolving dependencies.
    It accepts following notations:
    - String in a format of: 'group:name:version', for example: 'org.gradle:gradle-core:1.0'
    - instance of ModuleVersionSelector
    - any collection or array of above will be automatically flattened
    Example:
```
 configurations.all {
   resolutionStrategy.force 'asm:asm-all:3.3.1', 'commons-io:commons-io:1.4'
 }
 
```
    Specified by:
    
    force in interface ResolutionStrategy
    
    Parameters:
    forcedModuleNotations - typically group:name:version notations to append
    
    Returns:
    this ResolutionStrategy instance
  - setForcedModules
```
public DefaultResolutionStrategy setForcedModules(Object... forcedModuleNotations)
```
    Description copied from interface: ResolutionStrategy
    Allows forcing certain versions of dependencies, including transitive dependencies. Replaces existing forced modules with the input.
    For information on notations see ResolutionStrategy.force(Object...)
    Example:
```
 configurations.all {
   resolutionStrategy.forcedModules = ['asm:asm-all:3.3.1', 'commons-io:commons-io:1.4']
 }
 
```
    Specified by:
    
    setForcedModules in interface ResolutionStrategy
    
    Parameters:
    forcedModuleNotations - typically group:name:version notations to set
    
    Returns:
    this ResolutionStrategy instance
  - getCachePolicy
```
public CachePolicy getCachePolicy()
```
    Description copied from interface: ResolutionStrategyInternal
    
    Gets the current expiry policy for dynamic revisions.
    
    Specified by:
    
    getCachePolicy in interface ResolutionStrategyInternal
    
    Returns:
    the expiry policy
  - cacheDynamicVersionsFor
```
public void cacheDynamicVersionsFor(int value,
                           String units)
```
    Description copied from interface: ResolutionStrategy
    
    Sets the length of time that dynamic versions will be cached, with units expressed as a String.
    A convenience method for ResolutionStrategy.cacheDynamicVersionsFor(int, java.util.concurrent.TimeUnit) with units expressed as a String. Units are resolved by calling the valueOf(String) method of TimeUnit with the upper-cased string value.
    
    Specified by:
    
    cacheDynamicVersionsFor in interface ResolutionStrategy
    
    Parameters:
    value - The number of time units
    units - The units
  - cacheDynamicVersionsFor
```
public void cacheDynamicVersionsFor(int value,
                           TimeUnit units)
```
    Description copied from interface: ResolutionStrategy
    
    Sets the length of time that dynamic versions will be cached.
    Gradle keeps a cache of dynamic version => resolved version (ie 2.+ => 2.3). By default, these cached values are kept for 24 hours, after which the cached entry is expired and the dynamic version is resolved again.
    
    Use this method to provide a custom expiry time after which the cached value for any dynamic version will be expired.
    
    Specified by:
    
    cacheDynamicVersionsFor in interface ResolutionStrategy
    
    Parameters:
    value - The number of time units
    units - The units
  - cacheChangingModulesFor
```
public void cacheChangingModulesFor(int value,
                           String units)
```
    Description copied from interface: ResolutionStrategy
    
    Sets the length of time that changing modules will be cached, with units expressed as a String.
    A convenience method for ResolutionStrategy.cacheChangingModulesFor(int, java.util.concurrent.TimeUnit) with units expressed as a String. Units are resolved by calling the valueOf(String) method of TimeUnit with the upper-cased string value.
    
    Specified by:
    
    cacheChangingModulesFor in interface ResolutionStrategy
    
    Parameters:
    value - The number of time units
    units - The units
  - cacheChangingModulesFor
```
public void cacheChangingModulesFor(int value,
                           TimeUnit units)
```
    Description copied from interface: ResolutionStrategy
    
    Sets the length of time that changing modules will be cached.
    Gradle caches the contents and artifacts of changing modules. By default, these cached values are kept for 24 hours, after which the cached entry is expired and the module is resolved again.
    
    Use this method to provide a custom expiry time after which the cached entries for any changing module will be expired.
    
    Specified by:
    
    cacheChangingModulesFor in interface ResolutionStrategy
    
    Parameters:
    value - The number of time units
    units - The units

Class DefaultResolutionStrategy

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DefaultResolutionStrategy

Method Detail

getForcedModules

failOnVersionConflict

getConflictResolution

getResolutionRules

force

setForcedModules

getCachePolicy

cacheDynamicVersionsFor

cacheDynamicVersionsFor

cacheChangingModulesFor

cacheChangingModulesFor