* to attempt to locate a matching role by its usage characteristics.
 *
 * @since 8.1
 */
public final class ConfigurationRoles {

    private ConfigurationRoles() {
        // Private to prevent instantiation.
    }

    /**
     * An unrestricted configuration, which can be used for any purpose.
     *

        role                                            || name
        ConfigurationRoles.DEPENDENCY_SCOPE             || "Dependency Scope"
        ConfigurationRoles.CONSUMABLE                   || "Consumable"
        ConfigurationRoles.RESOLVABLE                   || "Resolvable"
        ConfigurationRoles.RESOLVABLE_DEPENDENCY_SCOPE  || "Resolvable Dependency Scope"
        ConfigurationRoles.LEGACY                       || "Legacy"
    }

        ConfigurationRoles.LEGACY                       || [UsageDescriber.CONSUMABLE, UsageDescriber.RESOLVABLE, UsageDescriber.DECLARABLE_AGAINST]
        ConfigurationRoles.CONSUMABLE                   || [UsageDescriber.CONSUMABLE]
        ConfigurationRoles.RESOLVABLE                   || [UsageDescriber.RESOLVABLE]

        then:
        thrown(InvalidUserDataException)

        where:
        role << [
            ConfigurationRoles.LEGACY,
            ConfigurationRoles.RESOLVABLE,
            ConfigurationRoles.CONSUMABLE,
            ConfigurationRoles.CONSUMABLE_DEPENDENCY_SCOPE,
            ConfigurationRoles.RESOLVABLE_DEPENDENCY_SCOPE
        ]
    }

    @SuppressWarnings("deprecation")
    private static final Set<ConfigurationRole> VALID_MAYBE_CREATE_ROLES = new HashSet<>(Arrays.asList(ConfigurationRoles.CONSUMABLE, ConfigurationRoles.RESOLVABLE, ConfigurationRoles.DEPENDENCY_SCOPE, ConfigurationRoles.RESOLVABLE_DEPENDENCY_SCOPE));

    private final AtomicInteger detachedConfigurationDefaultNameCounter = new AtomicInteger(1);

    /**
     * A legacy configuration that will become a consumable configuration in the next major version.
     */
    @SuppressWarnings("deprecation")
    public static final ConfigurationRole LEGACY_TO_CONSUMABLE = difference(ConfigurationRoles.LEGACY, ConfigurationRoles.CONSUMABLE);

    /**

        "configurations.consumableUnlocked('additionalRuntimeClasspath')"               | ConfigurationRoles.CONSUMABLE | true      | "internal unlocked role-based configuration"

import org.gradle.api.internal.artifacts.configurations.RoleBasedConfigurationCreationRequest;
import org.gradle.api.internal.artifacts.configurations.ConfigurationRole;
import org.gradle.api.internal.artifacts.configurations.ConfigurationRoles;
import org.gradle.api.internal.artifacts.configurations.RoleBasedConfigurationContainerInternal;
import org.gradle.api.internal.artifacts.configurations.UsageDescriber;
import org.gradle.api.internal.file.FileTreeInternal;

import org.gradle.api.artifacts.Configuration;

/**
 * Defines how a {@link org.gradle.api.artifacts.Configuration} is intended to be used.
 *
 * Standard roles are defined in {@link ConfigurationRoles}.
 *
 * @since 8.1
 */
public interface ConfigurationRole {
    /**
     * Returns a human-readable name for this role.
     */
    String getName();

    boolean isConsumable();

            workerThreadRegistry,
            domainObjectCollectionFactory,
            calculatedValueContainerFactory,
            defaultConfigurationFactory,
            taskDependencyFactory,
            ConfigurationRoles.RESOLVABLE,
            true
        );

        setVisible(false);
    }