* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.time;

public interface Timer {

    /**
     * @return A human-consumable description of the elapsed time.
     */
    String getElapsed();

    /**
     * Return the elapsed time in ms. Returned value is always >= 0.
     * @return The elapsed time, in ms.
     */

@ServiceScope(Scope.Project.class)
public interface RoleBasedConfigurationContainerInternal extends ConfigurationContainer {

    /**
     * Creates a consumable configuration which can change roles.
     */
    Configuration consumableUnlocked(String name);

    /**
     * Creates a consumable configuration which can change roles and executes the provided
     * {@code action} against the configuration.
     */

`assemble` — _lifecycle task_::
Plugins and build authors should attach tasks that produce distributions and other consumable artifacts to this lifecycle task. For example, `jar` produces the consumable artifact for Java libraries. Attach tasks to this lifecycle task using `assemble.dependsOn(__task__)`.

`build` — _lifecycle task_::
_Depends on_: `check`, `assemble`
+

 */
public interface ConfigurationMetadataFactory {

    /**
     * Visit all configurations in this component that can be selected in a dependency graph.
     *
     * <p>This includes all consumable configurations with and without attributes. Configurations visited
     * by this method may not be suitable for selection via attribute matching.</p>
     */

        return convertToId(getDisplayName());
    }

    static String convertToId(String displayName) {
        return displayName.replaceAll("[^a-zA-Z0-9]", "-");
    }

    /**
     * A human consumable display name for this performance test.
     */
    default String getDisplayName() {
        return getExperiment().getDisplayName();
    }

    PerformanceExperiment getExperiment();

    /**

        """

        producer.file('build.gradle') << """
            plugins {
                id('java-library')
            }

            configurations {
                consumable("nonLibrary") {
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.class, Category.VERIFICATION))
                    }
                }
            }

        }
    }
    repositories {
        maven {
            name = "test"
            url = testRepoLocation.get().asFile.toURI()
        }
    }
}

val testRepoElements = configurations.consumable("testRepoElements") {
    outgoing.artifact(testRepoLocation) {
        builtBy( "publishMavenPublicationToTestRepository")
    }
    // TODO: De-duplicate this. See publish-public-libraries
    attributes {

     * A cache of the defined dependencies for dependency configurations. This tracks the cached internal
     * dependency representations for these types so when constructing leaf configuration metadata
     * (resolvable and consumable), these conversions do not need to be executed multiple times.
     */
    class DependencyCache {
        private final Map<String, DefaultLocalConfigurationMetadataBuilder.DependencyState> cache = new HashMap<>();

                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }
                consumable("cons") {
                    attributes {
                        attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category, "foo"))
                    }
                }
            }

     * Returns the role used to create this configuration and set its initial allowed usage.
     */
    ConfigurationRole getRoleAtCreation();

    /**
     * Indicates if the allowed usages of this configuration (consumable, resolvable, declarable) can be changed.
     *
     * @return {@code true} if so; {@code false} otherwise
     */
    boolean usageCanBeMutated();

    /**