enterDirectory(directorySnapshot, treeDepth == 0);
        treeDepth++;
    }

    @Override
    public SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot) {
        return visitEntry(snapshot, treeDepth == 0);
    }

    @Override
    public final void leaveDirectory(DirectorySnapshot directorySnapshot) {
        treeDepth--;

        return visitor.visitEntry(this);
    }

    @Override
    default SnapshotVisitResult accept(RelativePathTracker pathTracker, RelativePathTrackingFileSystemSnapshotHierarchyVisitor visitor) {
        pathTracker.enter(getName());
        try {
            return visitor.visitEntry(this, pathTracker);
        } finally {
            pathTracker.leave();
        }

        def absolutePaths = []
        snapshot.accept(new RootTrackingFileSystemSnapshotHierarchyVisitor() {
            @Override
            SnapshotVisitResult visitEntry(FileSystemLocationSnapshot entrySnapshot, boolean isRoot) {
                if (includeRoots || !isRoot) {
                    absolutePaths << entrySnapshot.absolutePath
                }
                CONTINUE

    private final HashSet<String> processedEntries = new HashSet<>();

    @Override
    public final SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot, boolean isRoot) {
        if (!(snapshot.getType() == FileType.Missing && isRoot) && processedEntries.add(snapshot.getAbsolutePath())) {
            visitAcceptedEntry(snapshot, isRoot);

    private void visitEntries(ClasspathBuilder.EntryBuilder builder) throws IOException, FileException {
        classpathWalker.visit(source, entry -> {
            visitEntry(builder, entry);
        });
        finishProcessing(builder);
    }

    private void visitEntry(ClasspathBuilder.EntryBuilder builder, ClasspathEntryVisitor.Entry entry) throws IOException {
        try {
            if (isClassFile(entry)) {

        return other instanceof DirectorySnapshot;
    }

    @Override
    public SnapshotVisitResult accept(FileSystemSnapshotHierarchyVisitor visitor) {
        SnapshotVisitResult result = visitor.visitEntry(this);
        switch (result) {
            case CONTINUE:
                visitor.enterDirectory(this);
                children.stream()
                    .map(ChildMap.Entry::getValue)

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */
    SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot);

    /**
     * Called after all entries in the directory has been visited.
     */
    default void leaveDirectory(DirectorySnapshot directorySnapshot) {}

    /**
     * Called for each regular file/directory/missing/unavailable file.
     *
     * @return how to continue visiting the rest of the snapshot hierarchy.
     */
    SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot, RelativePathSupplier relativePath);

    /**
     * Called after all entries in the directory has been visited.
     */

        if (!leftLevelUnfiltered && directorySnapshot != null) {
            directorySnapshot.accept(new RootTrackingFileSystemSnapshotHierarchyVisitor() {

                @Override
                public SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot, boolean isRoot) {
                    if (isRoot) {
                        return SnapshotVisitResult.CONTINUE;
                    } else {

            builder.enterDirectory(directorySnapshot, INCLUDE_EMPTY_DIRS);
        }

        @Override
        public SnapshotVisitResult visitEntry(FileSystemLocationSnapshot snapshot, RelativePathSupplier relativePath) {
            boolean root = relativePath.isRoot();
            Iterable<String> relativePathForFiltering = root