Package: org.gradle.api.artifacts

## [Java] Interface ConfigurationContainer

- org.gradle.api.artifacts.ConfigurationContainer

- All Superinterfaces:
    NamedDomainObjectSet, Iterable, NamedDomainObjectCollection, DomainObjectCollection, Collection, NamedDomainObjectContainer

  A `ConfigurationContainer` is responsible for declaring and managing configurations. See also Configuration.

  You can obtain a `ConfigurationContainer` instance by calling Project.getConfigurations, or using the `configurations` property in your build script.

  The configurations in a container are accessible as read-only properties of the container, using the name of the configuration as the property name. For example:

       configurations.create('myConfiguration')
       configurations.myConfiguration.transitive = false

  A dynamic method is added for each configuration which takes a configuration closure. This is equivalent to calling getByName(String, groovy.lang.Closure). For example:

       configurations.create('myConfiguration')
       configurations.myConfiguration {
           transitive = false
       }

  ## Examples

  An example showing how to refer to a given configuration by name in order to get hold of all dependencies (e.g. jars, but only)

         apply plugin: 'java' //so that I can use 'compile' configuration

         //copying all dependencies attached to 'compile' into a specific folder
         task copyAllDependencies(type: Copy) {
           //referring to the 'compile' configuration
           from configurations.compile
           into 'allLibs'
         }

  An example showing how to declare and configure configurations

       apply plugin: 'java' //so that I can use 'compile', 'testCompile' configurations

       configurations {
         //adding a configuration:
         myConfiguration

         //adding a configuration that extends existing configuration:
         //(testCompile was added by the java plugin)
         myIntegrationTestsCompile.extendsFrom(testCompile)

         //configuring existing configurations not to put transitive dependencies on the compile classpath
         //this way you can avoid issues with implicit dependencies to transitive libraries
         compile.transitive = false
         testCompile.transitive = false
       }

  Examples on configuring the resolution strategy - see docs for ResolutionStrategy

- - ### Methods Summary

    Methods
    Type | Name and description
    --- | ---
    `Configuration` | `detachedConfiguration(Dependency... dependencies)` Creates a configuration, but does not add it to this container.
    `Configuration` | `getAt(String name)` {@inheritDoc}
    `Configuration` | `getByName(String name)` {@inheritDoc}
    `Configuration` | `getByName(String name, groovy.lang.Closure configureClosure)` {@inheritDoc}

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `interface NamedDomainObjectContainer` | `configure, create, create, create, maybeCreate`
    `interface NamedDomainObjectSet` | `findAll, matching, matching, withType`
    `interface org.gradle.util.Configurable` | `org.gradle.util.Configurable#configure(groovy.lang.Closure)`

- - ### Method Detail

    - #### public Configuration detachedConfiguration(Dependency... dependencies)

      Creates a configuration, but does not add it to this container.

      Parameters:
        `dependencies` - The dependencies of the configuration.
      Returns:
        The configuration.

    - #### public Configuration getAt(String name)

      {@inheritDoc}

    - #### public Configuration getByName(String name)

      {@inheritDoc}

    - #### public Configuration getByName(String name, groovy.lang.Closure configureClosure)

      {@inheritDoc}