artifact.getVersion(),
                artifact.getType(),
                artifact.getClassifier(),
                null,
                artifact.getDownloadUrl(),
                artifact.getDependencyTrail());
    }

    protected ArtifactNotFoundException(
            String message, Artifact artifact, List<ArtifactRepository> remoteRepositories, Throwable cause) {
        this(
                message,

                            if (node.isChildOfRootNode() || !artifact.isOptional()) {
                                artifact.setDependencyTrail(node.getDependencyTrail());

                                set.add(node);

                                // This is required right now.
                                result.addArtifact(artifact);
                            }

            children = new ArrayList<>(artifacts.size());

            for (Artifact a : artifacts) {
                if (parents.contains(a.getDependencyConflictId())) {
                    a.setDependencyTrail(getDependencyTrail());

                    throw new CyclicDependencyException("A dependency has introduced a cycle", a);
                }

                children.add(new ResolutionNode(a, remoteRepositories, this));
            }

            clone.setBaseVersion(artifact.getBaseVersion());
        }
        clone.setDependencyFilter(artifact.getDependencyFilter());
        clone.setDependencyTrail(copyList(artifact.getDependencyTrail()));
        clone.setDownloadUrl(artifact.getDownloadUrl());
        clone.setRepository(artifact.getRepository());

        return clone;
    }

    /**
     * Copy artifact to a collection.

    /** {@inheritDoc} */
    public ArtifactHandler getArtifactHandler() {
        return artifact.getArtifactHandler();
    }

    /** {@inheritDoc} */
    public List<String> getDependencyTrail() {
        return artifact.getDependencyTrail();
    }

    /** {@inheritDoc} */
    public void setDependencyTrail(List<String> dependencyTrail) {
        artifact.setDependencyTrail(dependencyTrail);
    }

                    artifact.getVersion(),
                    artifact.getType(),
                    artifact.getClassifier(),
                    artifact.getDownloadUrl(),
                    artifact.getDependencyTrail()));
        }

        buffer.append("----------").append(LS);

        int size = artifacts.size();

        buffer.append(size).append(" required artifact");

        if (size > 1) {

    ArtifactFilter getDependencyFilter();

    void setDependencyFilter(ArtifactFilter artifactFilter);

    ArtifactHandler getArtifactHandler();

    List<String> getDependencyTrail();

    void setDependencyTrail(List<String> dependencyTrail);

    void setScope(String scope);

    VersionRange getVersionRange();

    void setVersionRange(VersionRange newRange);

                    if (resolved != null) {
                        artifact.setFile(resolved.getFile());
                        artifact.setDependencyTrail(resolved.getDependencyTrail());
                        artifact.setResolvedVersion(resolved.getVersion());
                        artifact.setResolved(true);
                    }
                }
            }
        } finally {

                artifact.getVersion(),
                artifact.getType(),
                artifact.getClassifier(),
                remoteRepositories,
                artifact.getDependencyTrail(),
                t);
        this.artifact = artifact;
    }

    public Artifact getArtifact() {
        return artifact;
    }

    public String getGroupId() {
        return groupId;

                            message += "  " + relocation.getMessage();
                        }

                        if (artifact.getDependencyTrail() != null
                                && artifact.getDependencyTrail().size() == 1) {
                            logger.warn(
                                    "While downloading {}:{}:{}{}",