import org.gradle.api.artifacts.component.ComponentArtifactIdentifier;

import javax.annotation.Nullable;
import java.io.File;

/**
 * Information about a resolved artifact.
 */
public interface ResolvedArtifact {
    /**
     * Returns the local file for this artifact. Downloads the artifact if not already available locally, blocking until complete.
     */
    File getFile();

    /**

        return children;
    }

    @Override
    public Set<ResolvedArtifact> getModuleArtifacts() {
        return sort(CompositeResolvedArtifactSet.of(moduleArtifacts));
    }

    @Override
    public Set<ResolvedArtifact> getAllModuleArtifacts() {
        if (allModuleArtifactsCache == null) {
            Set<ResolvedArtifact> allArtifacts = new LinkedHashSet<>(getModuleArtifacts());

import java.util.Set;

public class ArtifactCollectingVisitor implements ArtifactVisitor {
    private final Set<ResolvedArtifact> artifacts;
    private List<Throwable> failures;

    public ArtifactCollectingVisitor() {
        this(new LinkedHashSet<>());
    }

    public ArtifactCollectingVisitor(Set<ResolvedArtifact> artifacts) {
        this.artifacts = artifacts;
    }

    @Override

                ArtifactCollection artifacts = getResolvedArtifacts(configuration, visitor);
                for (ResolvedArtifactResult resolvedArtifact : artifacts) {
                    resolvedArtifacts.put(resolvedArtifact.getId(), resolvedArtifact);
                    configurations.put(resolvedArtifact.getId(), configuration);
                }
                if (artifacts.getFailures().isEmpty()) {
                    continue;

/**
 * Default implementation of {@link ResolvedArtifact}, the artifact type used by the legacy
 * {@link org.gradle.api.artifacts.ResolvedConfiguration} API. This class presents a file extension, type,
 * classifier via its {@link IvyArtifactName}. This name is tracked on a best-effort basis, and may not
 * always represent the actual file name.
 */
public class DefaultResolvedArtifact implements ResolvedArtifact {

        ResolvedArtifact artifact1 = artifact("a", null, "jar", "jar")
        ResolvedArtifact artifact2 = artifact("b", null, "jar", "jar")
        ResolvedArtifact artifact3 = artifact("b", "a-classifier", "jar", "jar")
        ResolvedArtifact artifact4 = artifact("b", "b-classifier", "b-type", "a-ext")
        ResolvedArtifact artifact5 = artifact("b", "b-classifier", "a-type", "b-ext")

    @Override
    public void visitDependencies(TaskDependencyResolveContext context) {
        for (ResolvedArtifact artifact : artifacts) {
            context.add(artifact);
        }
    }

    private static class Adapter implements ResolvableArtifact {
        private final ResolvedArtifact artifact;

        Adapter(ResolvedArtifact artifact) {
            this.artifact = artifact;
        }

        @Override

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact;

import org.gradle.api.artifacts.ResolvedArtifact;
import org.gradle.api.artifacts.component.ComponentArtifactIdentifier;
import org.gradle.api.internal.tasks.TaskDependencyContainer;
import org.gradle.internal.component.model.IvyArtifactName;

            try {
                ResolvedArtifact resolvedArtifact = artifact.toPublicView();
                files.add(resolvedArtifact.getFile());
                artifacts.add(resolvedArtifact);
            } catch (org.gradle.internal.resolve.ArtifactResolveException e) {
                //ignore
            } catch (Exception e) {
                visitFailure(e);

     * to a ResolvedDependency independent of a particular parent. Returns never null. 
     */
    Set<ResolvedArtifact> getModuleArtifacts();

    /**
     * Returns the module artifacts belonging to this ResolvedDependency and recursively to its children. Returns never null.
     *
     * @see #getModuleArtifacts()
     */
    Set<ResolvedArtifact> getAllModuleArtifacts();

    /**