this(new LinkedHashSet<>());
    }

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

    @Override
    public void visitArtifact(DisplayName variantName, AttributeContainer variantAttributes, ImmutableCapabilities capabilities, ResolvableArtifact artifact) {
        this.artifacts.add(artifact.toPublicView());
    }

    @Override

            }

            @Override
            public void visitArtifacts(ArtifactVisitor visitor, boolean continueOnSelectionFailure) {
                ResolvedArtifactSet filteredArtifacts = resolveFilteredArtifacts(dependencySpec, artifactResults);
                getDelegate(filteredArtifacts).visitArtifacts(visitor, continueOnSelectionFailure);
            }

     */
    void visit(Visitor visitor);

    void visitTransformSources(TransformSourceVisitor visitor);

    interface TransformSourceVisitor {
        void visitArtifact(ResolvableArtifact artifact);

        void visitTransform(TransformStepNode source);
    }

    /**
     * Visits the external artifacts of this set.
     */

    }

    override fun requireArtifactFiles(): Boolean {
        return true
    }

    override fun visitFailure(failure: Throwable) {
        elements.add(failure)
    }

    override fun visitArtifact(variantName: DisplayName, variantAttributes: AttributeContainer, capabilities: ImmutableCapabilities, artifact: ResolvableArtifact) {
        if (artifacts.add(artifact)) {

    public void visit(Visitor visitor) {
        visitor.visitArtifacts(this);
    }

    @Override
    public void startFinalization(BuildOperationQueue<RunnableBuildOperation> actions, boolean requireFiles) {
    }

    @Override
    public void visit(ArtifactVisitor visitor) {
        for (final ResolvedArtifact artifact : artifacts) {

            visitor.visitArtifacts(this)
        }

        override fun startFinalization(actions: BuildOperationQueue<RunnableBuildOperation>, requireFiles: Boolean) {
        }

        override fun visit(visitor: ArtifactVisitor) {
            val displayName = Describables.of(ownerId)
            for (artifact in artifacts) {

                        if (visitor.prepareForVisit(FileCollectionInternal.OTHER) == FileCollectionStructureVisitor.VisitType.Visit) {
                            visitor.visitArtifact(variantDisplayName, variantAttributes, capabilities, new ResolvableArtifact() {
                                @Override
                                public ComponentArtifactIdentifier getId() {

        ImmutableList.Builder<TransformStepNode> builder = ImmutableList.builder();
        sourceArtifacts.visitTransformSources(new ResolvedArtifactSet.TransformSourceVisitor() {
            @Override
            public void visitArtifact(ResolvableArtifact artifact) {
                TransformUpstreamDependencies upstreamDependencies = dependenciesResolver.dependenciesFor(transformStep);

            listener.visitArtifacts(new EndCollection(this));
            return;
        }

        ComponentIdentifier componentIdentifier = dependencyMetadata.getComponentId();
        if (componentIdentifier != null && !componentFilter.isSatisfiedBy(componentIdentifier)) {
            listener.visitArtifacts(new EndCollection(this));
            return;
        }

    /**
     * Visits the artifacts introduced by a particular edge in the graph. Called for every edge in the graph.
     * The nodes are visited in consumer-first order.
     */
    default void visitArtifacts(DependencyGraphNode from, DependencyGraphNode to, int artifactSetId, ArtifactSet artifacts) {}

    /**
     * Visits the artifacts introduce by a particular node in the graph. Called *zero or more* times for each node.