*
 * <p>The purpose of this type is to be a configuration-cache compatible representation of the thing
 * being resolved. This type should remain as minimal as possible.</p>
 */
public interface ResolutionHost {

    DisplayName displayName();

    default String getDisplayName() {
        return displayName().getDisplayName();
    }

    default DisplayName displayName(String type) {

    private final VisitedGraphResults graphResults;
    private final ResolutionHost resolutionHost;
    private final VisitedArtifactSet visitedArtifacts;
    private final LenientConfigurationInternal configuration;

    public DefaultResolvedConfiguration(
        VisitedGraphResults graphResults,
        ResolutionHost resolutionHost,
        VisitedArtifactSet visitedArtifacts,

import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class DefaultLenientConfiguration implements LenientConfigurationInternal {

    private final ResolutionHost resolutionHost;
    private final VisitedGraphResults graphResults;
    private final VisitedArtifactResults artifactResults;
    private final VisitedFileDependencyResults fileDependencyResults;

    public DefaultArtifactCollection(ResolutionBackedFileCollection files, boolean lenient, ResolutionHost resolutionHost, CalculatedValueFactory calculatedValueFactory) {
        this.fileCollection = files;
        this.lenient = lenient;
        this.result = calculatedValueFactory.create(resolutionHost.displayName("files"), () -> {
            ResolvedArtifactCollectingVisitor visitor = new ResolvedArtifactCollectingVisitor();

        this.taskDependencyFactory = taskDependencyFactory;
        this.buildOperationExecutor = buildOperationExecutor;
    }

    public ResolutionHost resolutionHost(String displayName) {
        return new NameBackedResolutionHost(displayName);
    }

    /**
     * Presents the contents of the given artifacts as a partial {@link FileCollectionInternal} implementation.

        ResolutionHost resolutionHost = resolveContext.getResolutionHost();
        ArtifactVariantSelector artifactVariantSelector = variantSelectorFactory.create(resolveContext.getDependenciesResolverFactory());
        VisitedArtifactSet visitedArtifacts = new DefaultVisitedArtifactSet(graphResults, resolutionHost, artifactsBuilder.complete(), artifactSetResolver, artifactVariantSelector);

package org.gradle.api.internal.artifacts.resolver;

import org.gradle.api.artifacts.ResolutionStrategy;
import org.gradle.api.internal.artifacts.ResolverResults;
import org.gradle.api.internal.artifacts.configurations.ResolutionHost;
import org.gradle.api.internal.artifacts.configurations.ResolutionResultProvider;
import org.gradle.api.internal.attributes.ImmutableAttributes;

/**

import org.gradle.api.internal.DomainObjectContext;
import org.gradle.api.internal.artifacts.configurations.DependencyMetaDataProvider;
import org.gradle.api.internal.artifacts.configurations.ResolutionHost;
import org.gradle.api.internal.artifacts.configurations.ResolutionStrategyInternal;
import org.gradle.api.internal.artifacts.ivyservice.moduleconverter.RootComponentMetadataBuilder;

    override suspend fun WriteContext.encode(value: ArtifactCollectionInternal) {
        val visitor = CollectingArtifactVisitor()
        value.visitArtifacts(visitor)
        writeString(value.resolutionHost.displayName)
        writeBoolean(value.isLenient)
        writeCollection(visitor.elements)
    }

    override suspend fun ReadContext.decode(): ArtifactCollectionInternal {
        val displayName = readString()

                elements.add(BeanSpec(fileCollection))
                false
            }

            is ResolutionBackedFileCollection -> {
                val displayName = fileCollection.resolutionHost.displayName
                val lenient = fileCollection.isLenient
                val nestedVisitor = ResolutionContentsCollectingVisitor(displayName, lenient)
                fileCollection.visitStructure(nestedVisitor)