*
     * @param path Path of the file
     * @param relativePath RelativePath of the file
     * @param attrs attributes of the path, null if not available
     * @param stopFlag transient flag to stop visiting
     * @param fileSystem for Chmod and Stat
     * @return FileVisitDetails
     */
    public static FileVisitDetails getRootFileVisitDetails(
        Path path,
        RelativePath relativePath,

     */
    void visitFile(File file);

    /**
     * Called when some problem occurs visiting some element of the set. Visiting may continue.
     */
    void visitFailure(Throwable failure);

    /**
     * Called after a set of artifacts has been visited.
     */

     *
     * Returns true here allows the collection to preemptively resolve the files in parallel.
     */
    boolean requireArtifactFiles();

    /**
     * Called when some problem occurs visiting some element of the set. Visiting may continue.
     */
    void visitFailure(Throwable failure);

    /**
     * Called after a set of artifacts has been visited.
     */

@UsesNativeServices
class GeneratedSingletonFileTreeSpec extends Specification {
    @Rule
    TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def fileSystem = Stub(FileSystem)

    def "visiting creates file if visitor queries the file location"() {
        def contentWriter = Mock(Action)
        def generationListener = Mock(Action)
        def tmpDir = tmpDir.createDir("dir")

import org.gradle.api.artifacts.result.ResolvedVariantResult;

import javax.annotation.Nullable;
import java.util.List;

public interface ResolvedComponentVisitor {
    /**
     * Starts visiting a component.
     */
    void startVisitComponent(Long id, ComponentSelectionReason selectionReason, @Nullable String repoName);

    /**
     * Visit graph independent details of the component.
     */

import javax.annotation.Nullable;

/**
 * A builder for {@link DirectorySnapshot}.
 *
 * In order to build a directory snapshot, you need to call the methods for entering/leaving a directory
 * and for visiting leaf elements.
 * The visit methods need to be called in depth-first order.
 * When leaving a directory, the builder will create a {@link DirectorySnapshot} for the directory,
 * calculating the combined hash of the entries.
 */

    private int treeDepth;

    /**
     * Called before visiting the contents of a directory.
     */
    public void enterDirectory(DirectorySnapshot directorySnapshot, boolean isRoot) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */

                eachFile { fcd ->
                    println("visiting ${fcd.path}")
                    fcd.path = "sub/${fcd.path}"
                }
            }
        '''

        when:
        run 'copy'

        then:
        output.count('visiting ') == 2
        outputContains('visiting a.txt')
        outputContains('visiting dir/b.txt')
        file('dest').assertHasDescendants(

            generateArchiveContents(archiveContentsDir)
        }
    }

    @RunFor(
        @Scenario(type = PER_COMMIT, operatingSystems = [LINUX], testProjects = ["archivePerformanceProject"])
    )
    def "visiting zip trees"() {
        given:
        runner.tasksToRun = ['visitZip']
        runner.addBuildMutator { createArchive(it, "archive.zip") { contents, output -> contents.zipTo(output) } }

        when:

                    if (!visiting.contains(successor)) {
                        insertPoint.add(successor);
                    }
                }
            } else {
                // Have visited this node's dependencies - add it to the graph
                queue.removeFirst();
                visiting.remove(node);
                node.dependenciesProcessed();