}

    @Override
    public CacheRecord get(Key key) throws PluginResolutionException {
        CacheRecord cacheRecord = cache.get(key);

        if (cacheRecord != null && cacheRecord.getException() != null) {
            throw cacheRecord.getException();
        }

        return cacheRecord;
    }

    @Override
    public CacheRecord put(Key key, List<Artifact> pluginArtifacts) {

        CacheRecord cacheRecord = cache.get(cacheKey);

        if (cacheRecord != null && !cacheRecord.isStale()) {
            Artifact pomArtifact = ArtifactUtils.copyArtifact(cacheRecord.getArtifact());
            Artifact relocatedArtifact = ArtifactUtils.copyArtifactSafe(cacheRecord.getRelocatedArtifact());

    }

    @Override
    public CacheRecord get(Key key) throws LifecycleExecutionException {
        CacheRecord cacheRecord = cache.get(key);
        if (cacheRecord != null && cacheRecord.getException() != null) {
            throw cacheRecord.getException();
        }
        return cacheRecord;
    }

    @Override
    public CacheRecord put(Key key, Set<Artifact> projectArtifacts) {

            List<RemoteRepository> repositories,
            RepositorySystemSession session);

    CacheRecord get(Key key);

    default CacheRecord get(Key key, PluginRealmSupplier supplier)
            throws PluginResolutionException, PluginContainerException {
        CacheRecord cr = get(key);
        if (cr == null) {
            CacheRecord tcr = supplier.load();
            cr = put(key, tcr.getRealm(), tcr.getArtifacts());
        }

            throw new IllegalStateException("Duplicate plugin realm for plugin " + key);
        }

        CacheRecord record = new CacheRecord(pluginRealm, pluginArtifacts);

        cache.put(key, record);

        return record;
    }

    @Override
    public void flush() {
        for (CacheRecord record : cache.values()) {
            ClassRealm realm = record.getRealm();
            try {

        }
    }

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();

    @Override
    public Key createKey(List<? extends ClassRealm> extensionRealms) {
        return new CacheKey(extensionRealms);
    }

    @Override
    public CacheRecord get(Key key) {
        return cache.get(key);
    }

    @Override

        }
    }

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();

    @Override
    public Key createKey(List<Artifact> extensionArtifacts) {
        return new CacheKey(extensionArtifacts);
    }

    @Override
    public CacheRecord get(Key key) {
        return cache.get(key);
    }

    @Override
    public CacheRecord put(

        } else {
            return new ArrayList<>();
        }
    }

    @Override
    public ProjectRealmCache.CacheRecord createProjectRealm(
            MavenProject project, Model model, ProjectBuildingRequest request) {
        return new ProjectRealmCache.CacheRecord(null, null);
    }

    @Override
    public void selectProjectRealm(MavenProject project) {}

        artifactRepositories = repositorySystem.getEffectiveRepositories(artifactRepositories);

        return artifactRepositories;
    }

    @Override
    public synchronized ProjectRealmCache.CacheRecord createProjectRealm(
            MavenProject project, Model model, ProjectBuildingRequest request)
            throws PluginResolutionException, PluginVersionResolutionException, PluginManagerException {

            pluginDescriptor.setArtifacts(new ArrayList<>(cacheRecord.getArtifacts()));
            for (ComponentDescriptor<?> componentDescriptor : pluginDescriptor.getComponents()) {
                componentDescriptor.setRealm(cacheRecord.getRealm());
            }

            pluginRealmCache.register(project, cacheKey, cacheRecord);
        }
    }