request.getArtifact(),
                    toList(result.getArtifacts()),
                    result.getMissingArtifacts(),
                    request.getRemoteRepositories());
        }

        // this should never happen since we checked all possible error sources before but better be sure
        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(

        repositoryRequest.setLocalRepository(localRepository);

        return this;
    }

    @Override
    public List<ArtifactRepository> getRemoteRepositories() {
        return repositoryRequest.getRemoteRepositories();
    }

    @Override
    public DefaultMetadataResolutionRequest setRemoteRepositories(List<ArtifactRepository> remoteRepositories) {

        return this;
    }

    /**
     * @deprecated instead use {@link #getRemoteRepositories()}
     */
    @Deprecated
    public List<ArtifactRepository> getRemoteRepostories() {
        return remoteRepositories;
    }

    public List<ArtifactRepository> getRemoteRepositories() {
        return getRemoteRepostories();
    }

    /**

    }

    @Override
    public List<ArtifactVersion> retrieveAvailableVersions(MetadataResolutionRequest request)
            throws ArtifactMetadataRetrievalException {
        return retrieveAvailableVersions(
                request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }

            return artifacts;
        }

        public Map<String, Artifact> getManagedVersions() {
            return managedVersions;
        }

        public List<ArtifactRepository> getRemoteRepositories() {
            return remoteRepositories;
        }

        public boolean isStale() {
            File pomFile = pomArtifact.getFile();
            if (pomFile != null) {

        ResolutionNode root = new ResolutionNode(originatingArtifact, repositoryRequest.getRemoteRepositories());

        try {
            root.addDependencies(artifacts, repositoryRequest.getRemoteRepositories(), filter);
        } catch (CyclicDependencyException e) {
            result.addCircularDependencyException(e);

            return result;

        // nothing here
    }

    public ArtifactResolutionRequest(RepositoryRequest request) {
        setLocalRepository(request.getLocalRepository());
        setRemoteRepositories(request.getRemoteRepositories());
        setOffline(request.isOffline());
        setForceUpdate(request.isForceUpdate());
    }

    public Artifact getArtifact() {
        return artifact;
    }

    }

    @Override
    public ResolutionGroup retrieve(MetadataResolutionRequest request) throws ArtifactMetadataRetrievalException {
        return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }

        // as well as its dependencies.

        if (request.isResolveRoot() /* && rootArtifact.getFile() == null */) {
            try {
                resolve(rootArtifact, request.getRemoteRepositories(), session);
            } catch (ArtifactResolutionException e) {
                result.addErrorArtifactException(e);
                return result;
            } catch (ArtifactNotFoundException e) {

    }

    @Override
    public ResolutionGroup retrieve(MetadataResolutionRequest request) {
        return retrieve(request.getArtifact(), request.getLocalRepository(), request.getRemoteRepositories());
    }