}

    public ArtifactCollectingVisitor(Set<ResolvedArtifact> artifacts) {
        this.artifacts = artifacts;
    }

    @Override
    public void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact) {
        this.artifacts.add(artifact.toPublicView());
    }

    @Override

        // Instead, the resolution result should expose the project coordinates via getExternalVariant.
        String variantName = variant.getDisplayName();
        ModuleVersionIdentifier coordinates = projectDependencyResolver.resolveVariant(ModuleVersionIdentifier.class, identityPath, variantName);

        if (coordinates == null) {
            throw new InvalidUserDataException(String.format(

        String variantName,
        @Nullable String featureName,
        String docsType,
        Set<Capability> capabilities,
        String jarTaskName,
        Object artifactSource,
        ProjectInternal project
    ) {

     *
     * <p>Note that a given artifact may be visited multiple times. The implementation is required to filter out duplicates.</p>
     */
    void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact);

    /**

        );
    }

    @Nullable
    @Override
    public <T> T resolveVariant(Class<T> coordsType, Path identityPath, String variantName) {
        return withCoordinateResolver(coordsType, identityPath, resolver ->
            resolver.getVariantCoordinates(variantName)
        );
    }

    /**
     * Execute the action with a resolver for the given project.
     */

                default:
                    consumeAny(reader);
                    break;
            }
        }
        assertDefined(reader, "name", variantName);
        reader.endObject();

        MutableComponentVariant variant = metadata.addVariant(variantName, attributes);
        variant.setAvailableExternally(availableExternally);
        if (availableExternally) {
            if (!dependencyConstraints.isEmpty()) {

    MutableModuleSources getSources();

    void setSources(ModuleSources moduleSources);

    MutableComponentVariant addVariant(MutableComponentVariant variant);

    MutableComponentVariant addVariant(String variantName, ImmutableAttributes attributes);

    AttributeContainer getAttributes();

    void setAttributes(AttributeContainer attributes);

    boolean isExternalVariant();

                components.java.withVariantsFromConfiguration(configurations.${MavenJavaModule.variantName(it, 'runtimeElements')}) { skip() }
                if (${withDocs()}) {
                    components.java.withVariantsFromConfiguration(configurations.${MavenJavaModule.variantName(it, 'javadocElements')}) { skip() }

     *
     * Warnings are emitted when Gradle features are used that cannot be mapped completely to Maven POM.
     *
     * @param variantName the variant to silence warning for
     *
     * @since 6.0
     */
    void suppressPomMetadataWarningsFor(String variantName);


    /**
     * Silences all the compatibility warnings for the Maven publication.
     *

        Map<String, List<GradleDependencyMetadata>> variantsToDependencies = Maps.newHashMapWithExpectedSize(variantsCount);
        for (int i = 0; i < variantsCount; i++) {
            String variantName = decoder.readString();
            int dependencyCount = decoder.readSmallInt();
            List<GradleDependencyMetadata> dependencies = Lists.newArrayListWithExpectedSize(dependencyCount);