import javax.annotation.Nullable;
import java.util.Map;

/**
 * A repository of module components.
 *
 * @param <T> the component resolution result type
 */
public interface ModuleComponentRepository<T> {
    /**
     * A unique identifier for this repository, based on its type and attributes.
     * Two repositories with the same configuration will share the same id.

    }

    @Override
    public CachedMetadata getCachedModuleDescriptor(ModuleComponentRepository<?> repository, ModuleComponentIdentifier id) {
        final ModuleComponentAtRepositoryKey key = createKey(repository, id);
        return get(key);
    }

    @Override
    public CachedMetadata cacheMissing(ModuleComponentRepository<?> repository, ModuleComponentIdentifier id) {

import java.util.Map;

public class BaseModuleComponentRepository<T> implements ModuleComponentRepository<T> {
    protected final ModuleComponentRepository<T> delegate;
    private final ModuleComponentRepositoryAccess<T> localAccess;
    private final ModuleComponentRepositoryAccess<T> remoteAccess;

            moduleComponentRepository = filterRepository(repository, moduleComponentRepository);
            moduleComponentRepository = maybeApplyDependencyVerification(moduleComponentRepository, dependencyVerificationEnabled);

            moduleResolver.add(moduleComponentRepository);
            parentModuleResolver.add(moduleComponentRepository);
        }

public interface ModuleMetadataCache {
    CachedMetadata cacheMissing(ModuleComponentRepository<?> repository, ModuleComponentIdentifier id);

    CachedMetadata cacheMetaData(ModuleComponentRepository<?> repository, ModuleComponentIdentifier id, ModuleComponentResolveMetadata metaData);

    CachedMetadata getCachedModuleDescriptor(ModuleComponentRepository<?> repository, ModuleComponentIdentifier id);

    interface CachedMetadata {

 */
package org.gradle.api.internal.artifacts.ivyservice.modulecache.dynamicversions;

import org.gradle.api.artifacts.ModuleIdentifier;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ModuleComponentRepository;
import org.gradle.util.internal.BuildCommencedTimeProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Set;

    static File dependencyVerificationsFile(File gradleDirectory) {
        return new File(gradleDirectory, VERIFICATION_METADATA_XML);
    }

    ModuleComponentRepository<ModuleComponentGraphResolveState> overrideDependencyVerification(ModuleComponentRepository<ModuleComponentGraphResolveState> original);

    default void buildFinished(GradleInternal model) {
    }

    /**

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ModuleComponentRepository;
import org.gradle.internal.component.model.ComponentArtifactMetadata;
import org.gradle.internal.hash.HashCode;

import java.util.Collection;

public interface ModuleArtifactsCache {

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.ModuleComponentRepository;

import java.time.Duration;
import java.util.Set;

public interface ModuleVersionsCache {

    void cacheModuleVersionList(ModuleComponentRepository<?> repository, ModuleIdentifier moduleId, Set<String> listedVersions);

    CachedModuleVersionList getCachedModuleResolution(ModuleComponentRepository<?> repository, ModuleIdentifier moduleId);

    private final Map<String, ModuleComponentRepository<?>> repositories = new LinkedHashMap<>();
    private final CalculatedValueFactory calculatedValueFactory;

    RepositoryChainArtifactResolver(CalculatedValueFactory calculatedValueFactory) {
        this.calculatedValueFactory = calculatedValueFactory;
    }

    void add(ModuleComponentRepository<?> repository) {