}

    @Override
    public void accept(FileSystemLocationSnapshotVisitor visitor) {
        visitor.visitMissing(this);
    }

    @Override
    public <T> T accept(FileSystemLocationSnapshotTransformer<T> transformer) {
        return transformer.visitMissing(this);
    }

    @Override

        default void visitRegularFile(RegularFileSnapshot fileSnapshot) {};
        default void visitMissing(MissingFileSnapshot missingSnapshot) {};
    }

    interface FileSystemLocationSnapshotTransformer<T> {
        T visitDirectory(DirectorySnapshot directorySnapshot);
        T visitRegularFile(RegularFileSnapshot fileSnapshot);
        T visitMissing(MissingFileSnapshot missingSnapshot);
    }

            public Long visitRegularFile(RegularFileSnapshot fileSnapshot) {
                return fileSnapshot.getMetadata().getLength();
            }

            @Override
            public Long visitMissing(MissingFileSnapshot missingSnapshot) {
                return 0L;
            }
        });
    }

                @Override
                public Boolean visitRegularFile(RegularFileSnapshot fileSnapshot) {
                    return false;
                }

                @Override
                public Boolean visitMissing(MissingFileSnapshot missingSnapshot) {
                    return false;
                }
            });
            if (forceInclude || predicate.test(snapshot, relativePathForFiltering)) {

                    return hasNewContent(relativePath, fileSnapshot);
                }

                @Override
                public Boolean visitMissing(MissingFileSnapshot missingSnapshot) {
                    // If the root has gone missing then we don't have overlaps
                    if (relativePath.isRoot()) {
                        return false;

                        LOGGER.info("   - {}", locationSnapshot.getAbsolutePath());
                    }

                    @Override
                    public void visitMissing(MissingFileSnapshot missingSnapshot) {
                        LOGGER.info("   - {} (?)", locationSnapshot.getAbsolutePath());
                    }
                });
                return SnapshotVisitResult.CONTINUE;

                    return SnapshotVisitResult.CONTINUE;
                }

                @Override
                public SnapshotVisitResult visitMissing(MissingFileSnapshot missingSnapshot) {
                    return SnapshotVisitResult.CONTINUE;
                }
            });
        }
    }

                            throw new UncheckedIOException(e);
                        }
                    }

                    @Override
                    public void visitMissing(MissingFileSnapshot missingSnapshot) {
                        try {
                            writeEntryType(encoder, EntryType.MISSING);
                            writePath(encoder, isRoot, missingSnapshot);

                public void visitRegularFile(RegularFileSnapshot fileSnapshot) {
                    visitNonDirectoryEntry(snapshot, isRoot);
                }

                @Override
                public void visitMissing(MissingFileSnapshot missingSnapshot) {
                    visitNonDirectoryEntry(snapshot, isRoot);
                }
            });
            return SnapshotVisitResult.CONTINUE;
        }

                    }
                    builder.put(absolutePath, fingerprint);
                }

                @Override
                public void visitMissing(MissingFileSnapshot missingSnapshot) {
                    if (!relativePath.isRoot()) {
                        throw new RuntimeException(String.format("Couldn't read file content: '%s'.", missingSnapshot.getAbsolutePath()));