*
 * It is not allowed to have two attributes with the same name but different types in
 * the container.
 *
 * @since 3.3
 */
@HasInternalProtocol
@UsedByScanPlugin
public interface AttributeContainer extends HasAttributes {

    /**
     * Returns the set of attribute keys of this container.
     * @return the set of attribute keys.
     */
    Set<Attribute<?>> keySet();

    /**

    private final DomainObjectSet<SoftwareComponent> variants;
    private final AttributeContainer attributeContainer;

    public MainLibraryVariant(String name, Configuration dependencies, AttributeContainer attributeContainer, ObjectFactory objectFactory) {
        this.name = name;
        this.dependencies = dependencies;
        this.attributeContainer = attributeContainer;
        this.variants = objectFactory.domainObjectSet(SoftwareComponent.class);

    private final List<VariantMetadataRules.VariantAction<? super AttributeContainer>> actions = new LinkedList<>();

    public VariantAttributesRules(ImmutableAttributesFactory attributesFactory) {
        this.attributesFactory = attributesFactory;
    }

    public void addAttributesAction(VariantMetadataRules.VariantAction<? super AttributeContainer> action) {
        actions.add(action);
    }

import org.gradle.api.attributes.AttributeContainer;
import org.gradle.internal.component.external.model.ImmutableCapabilities;

/**
 * Identifier of a variant of a component.
 */
public class ComponentVariantIdentifier {

    private final ComponentIdentifier componentId;
    private final AttributeContainer attributes;
    private final ImmutableCapabilities capabilities;

        return builder.build();
    }

    private static String getAttributeValueAsString(AttributeContainer attributeContainer, Attribute<?> attribute) {
        // We use the same algorithm that Gradle uses when desugaring these on the build op, so that we don't end up
        // with unexpectedly different values due to arrays or Named objects being converted to Strings differently.
        // See LazyDesugaringAttributeContainer in the gradle/gradle codebase.

    private final Set<ExcludeRule> globalExcludes;

    public DefaultSoftwareComponentVariant(String name, AttributeContainer attributes) {
        this(name, attributes, Collections.emptySet());
    }

    public DefaultSoftwareComponentVariant(String name, AttributeContainer attributes, Set<? extends PublishArtifact> artifacts) {

    public T because(String reason) {
        this.reason = reason;
        return Cast.uncheckedCast(this);
    }

    public void setAttributes(AttributeContainer attributes) {
        this.attributes = attributes;
    }

    @Override
    public AttributeContainer getAttributes() {
        return attributes;
    }

    @Override
    public String toString() {

    private Action<? super AttributeContainer> attributesMutator;
    private Action<? super ModuleDependencyCapabilitiesHandler> capabilitiesMutator;
    private String classifier;
    private String artifactType;

    public DefaultMinimalDependencyVariant(MinimalExternalModuleDependency delegate,
                                           @Nullable Action<? super AttributeContainer> attributesMutator,

    private static final class LazyDesugaringAttributeContainer implements ImmutableAttributes {

        private final AttributeContainer source;
        private final ImmutableAttributesFactory attributesFactory;
        private ImmutableAttributes desugared;

        private LazyDesugaringAttributeContainer(@Nullable AttributeContainer source, ImmutableAttributesFactory attributesFactory) {
            this.source = source;

    private final AttributeContainer attributes;
    private final ImmutableCapabilities capabilities;
    private final ResolvedVariantResult externalVariant;
    private final int hashCode;

    public DefaultResolvedVariantResult(ComponentIdentifier owner,
                                        DisplayName displayName,
                                        AttributeContainer attributes,