}

        DisplayName displayName = names.get(parts);
        if (displayName == null) {
            displayName = variantName(parts);
            names.put(parts, displayName);
        }

        return displayName;
    }

    private static DisplayName variantName(List<String> parts) {
        if (parts.size() == 1) {
            return Describables.of(parts.get(0));
        }

        val variantName = readString()
        val identifier = readNonNull<VariantResolveMetadata.Identifier>()
        val attributes = readNonNull<ImmutableAttributes>()
        val artifacts = readList {
            readNonNull<PublishArtifactLocalArtifactMetadata>()
        }
        val displayName = Describables.of(variantName)

            }
        }

        for (Map.Entry<String, Object> variant : variants.entrySet()) {
            String variantName = GUtil.toWords(variant.getKey());
            builder.item(variantName, RendererUtils.displayValueOf(variant.getValue()));
        }
    }

    protected void renderDetails(T binary, TextReportBuilder builder) {
    }

        <title>Properties</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>variantName</td>
            </tr>
            <tr>
                <td>showAll</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>

        elements.add(failure)
    }

    override fun visitArtifact(variantName: DisplayName, variantAttributes: AttributeContainer, capabilities: ImmutableCapabilities, artifact: ResolvableArtifact) {
        if (artifacts.add(artifact)) {
            elements.add(FixedFileArtifactSpec(artifact.id, variantAttributes, capabilities, variantName, artifact.file))
        }
    }

            configurations.compileClasspath {
                resolutionStrategy.capabilitiesResolution.all { details ->
                    def selection =
                        details.candidates.find { it.variantName.endsWith('PrefApiElements') }
                    println("Selecting \$selection from \${details.candidates}")
                    details.select(selection)
                }
            }

        if (index == -1) {
            return null;
        }
        if (index == read.size()) {
            ComponentIdentifier owner = componentIdentifierSerializer.read(decoder);
            String variantName = decoder.readString();
            AttributeContainer attributes = attributeContainerSerializer.read(decoder);
            ImmutableCapabilities capabilities = readCapabilities(decoder);
            read.add(null);

        return visitor.prepareForVisit(source);
    }

    public void visitFile(File file) {
        visitor.visitFile(file);
    }

    @Override
    public void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact) {
        visitor.visitFile(artifact.getFile());
    }

    @Override
    public void visitFailure(Throwable failure) {

    private final Set<File> files = new LinkedHashSet<>();
    private final Set<Throwable> failures = new LinkedHashSet<>();

    @Override
    public void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact) {
        try {
            File file = artifact.getFile();
            this.files.add(file);

    void addCapability(Capability capability);

    ImmutableAttributes getAttributes();

    void setAttributes(ImmutableAttributes updatedAttributes);

    MutableComponentVariant copy(String variantName, ImmutableAttributes attributes, Capability capability);

    boolean isAvailableExternally();

    void setAvailableExternally(boolean availableExternally);