// caching, etc. that a normal dependency resolution would use.
        ResolutionStrategyInternal resolutionStrategy = resolutionStrategyFactory.create();

        ComponentResolvers componentResolvers = externalResolverFactory.createResolvers(
            filteredRepositories,
            metadataHandler.getComponentMetadataProcessorFactory(),
            resolutionStrategy.getComponentSelection(),

    }

    /**
     * Get component resolvers that resolve local and external components.
     */
    private ComponentResolvers getResolvers(ResolveContext resolveContext, List<ResolutionAwareRepository> repositories) {
        List<ComponentResolvers> resolvers = new ArrayList<>(3);
        for (ResolverProviderFactory factory : resolverFactories) {
            factory.create(resolvers, localComponentRegistry);

import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.artifacts.component.ProjectComponentIdentifier;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ComponentResolvers;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionSelector;
import org.gradle.api.internal.component.ArtifactType;
import org.gradle.internal.component.local.model.DefaultProjectComponentSelector;

    private final ComponentResolvers mainResolvers;
    private final FileResourceRepository fileResourceRepository;
    private final MutableModuleSources sources = new MutableModuleSources();
    private final ChecksumService checksumService;

    private final String name;
    private final ImmutableList<ResourcePattern> ivyPatterns;
    private final ImmutableList<ResourcePattern> artifactPatterns;
    private ComponentResolvers componentResolvers;

    private final ExternalResourceRepository repository;
    private final boolean local;
    private final CacheAwareExternalResourceAccessor cachingResourceAccessor;

import java.util.Collection;

public interface ResolverProviderFactory {
    /**
     * Create any applicable resolvers and add to the given collection.
     */
    void create(Collection<ComponentResolvers> resolvers, LocalComponentRegistry localComponentRegistry);

import org.gradle.StartParameter;
import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.internal.artifacts.ImmutableModuleIdentifierFactory;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ComponentResolvers;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ResolverProviderFactory;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionComparator;

import org.gradle.api.internal.artifacts.GlobalDependencyResolutionRules
import org.gradle.api.internal.artifacts.configurations.ResolutionStrategyFactory
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ComponentResolvers
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ExternalModuleComponentResolverFactory
import org.gradle.api.internal.component.ComponentTypeRegistration

import org.gradle.internal.resolve.resolver.ComponentMetaDataResolver;
import org.gradle.internal.resolve.resolver.DependencyToComponentIdResolver;

public class UserResolverChain implements ComponentResolvers {
    private final RepositoryChainDependencyToComponentIdResolver componentIdResolver;
    private final RepositoryChainComponentMetaDataResolver componentResolver;

        this.componentMetadataSupplierRuleExecutor = componentMetadataSupplierRuleExecutor;
    }

    /**
     * Creates component resolvers for the given repositories.
     */
    public ComponentResolvers createResolvers(
        Collection<? extends ResolutionAwareRepository> repositories,
        ComponentMetadataProcessorFactory metadataProcessor,
        ComponentSelectionRulesInternal componentSelectionRules,