subRequest.setArtifact(artifact.setVersion(result.getVersion()));
                    if (result.getRepository() instanceof RemoteRepository) {
                        RemoteRepository r = (RemoteRepository) result.getRepository();
                        subRequest.setRepositories(Collections.singletonList(r));
                    } else {

    }

    public void artifactDownloading(RepositoryEvent event) {
        println("artifactDownloading", event.getArtifact() + " from " + event.getRepository());
    }

    public void artifactDownloaded(RepositoryEvent event) {
        println("artifactDownloaded", event.getArtifact() + " from " + event.getRepository());
    }

    }

    public int getNature() {
        return isSnapshot() ? SNAPSHOT : RELEASE;
    }

    public ArtifactRepository getRepository() {
        return artifact.getRepository();
    }

    public void setRepository(ArtifactRepository remoteRepository) {
        artifact.setRepository(remoteRepository);
    }

        String context = request.getContext();
        RemoteRepository remote = request.getRepository();

        if (remote != null) {
            path = getPathForRemoteMetadata(metadata, remote, context);
        } else {
            path = getPathForLocalMetadata(metadata);
        }

        File file = new File(getRepository().getBasedir(), path);
        if (file.isFile()) {
            result.setFile(file);

        Metadata metadata = request.getMetadata();

        String path;
        if (request.getRepository() == null) {
            path = getPathForLocalMetadata(metadata);
        } else {
            path = getPathForRemoteMetadata(metadata, request.getRepository(), request.getContext());
        }

        File file = new File(getRepository().getBasedir(), path);

        LocalMetadataResult result = new LocalMetadataResult(request);

            for (String version : versions) {
                versionIndex.put(version, workspace.getRepository());
            }
        }

        for (MetadataResult metadataResult : metadataResults) {
            result.addException(metadataResult.getException());

            ArtifactRepository repository = metadataResult.getRequest().getRepository();
            if (repository == null) {

 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface ArtifactDeployerRequest {

    @Nonnull
    Session getSession();

    @Nonnull
    RemoteRepository getRepository();

    @Nonnull
    Collection<ProducedArtifact> getArtifacts();

    int getRetryFailedDeploymentCount();

    @Nonnull
    static ArtifactDeployerRequestBuilder builder() {

        return artifact.getMetadataList();
    }

    /** {@inheritDoc} */
    public void setRepository(ArtifactRepository remoteRepository) {
        artifact.setRepository(remoteRepository);
    }

    /** {@inheritDoc} */
    public ArtifactRepository getRepository() {
        return artifact.getRepository();
    }

    /** {@inheritDoc} */

                String message = artifact.getArtifactId() + ": resolved to version " + version;
                if (artifact.getRepository() != null) {
                    message += " from repository " + artifact.getRepository().getId();
                } else {
                    message += " from local repository";
                }
                getLogger().debug(message);

    }

    /**
     * Gets the repository that causes this error (if any).
     *
     * @return The repository that causes this error or {@code null} if not known.
     */
    public Repository getRepository() {
        return repository;
    }