interface NodeHandler<T, RESULT> {
        RESULT handleAsDescendantOfChild(VfsRelativePath pathInChild, T child);
        RESULT handleAsAncestorOfChild(String childPath, T child);
        RESULT handleExactMatchWithChild(T child);
        RESULT handleUnrelatedToAnyChild();
    }

    <RESULT> ChildMap<RESULT> invalidate(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, InvalidationHandler<T, RESULT> handler);

        handler.handleAsAncestorOfChild(childPath, child);
        return withRemovedChild();
    }

    @Override
    public ChildMap<RESULT> handleExactMatchWithChild(T child) {
        handler.handleExactMatchWithChild(child);
        return withRemovedChild();
    }

    @Override
    public ChildMap<RESULT> handleUnrelatedToAnyChild() {
        handler.handleUnrelatedToAnyChild();

                return noChildFoundResult.get();
            }

            @Override
            public Optional<MetadataSnapshot> handleExactMatchWithChild(T child) {
                return child.getSnapshot();
            }

            @Override
            public Optional<MetadataSnapshot> handleUnrelatedToAnyChild() {

        T newChild = handler.handleAsAncestorOfChild(childPath, child);
        return withReplacedChild(targetPath.getAsString(), newChild);
    }

    @Override
    public ChildMap<T> handleExactMatchWithChild(VfsRelativePath targetPath, String childPath, T child) {
        T newChild = handler.mergeWithExisting(child);
        return withReplacedChild(newChild);
    }

    @Override

                        relativePath.get())
                    ));
                return "";
            }

            @Override
            public String handleExactMatchWithChild(ValuedVfsHierarchy<T> child) {
                child.visitAllValues(visitor);
                return "";
            }

            @Override
            public String handleUnrelatedToAnyChild() {

            public Long handleAsAncestorOfChild(String childPath, VersionHierarchy child) {
                return child.getMaxVersionInHierarchy();
            }

            @Override
            public Long handleExactMatchWithChild(VersionHierarchy child) {
                return child.getMaxVersionInHierarchy();
            }

            @Override
            public Long handleUnrelatedToAnyChild() {
                return version;

            public void handleAsAncestorOfChild(String childPath, FileSystemNode child) {
                diffListener.nodeRemoved(child);
            }

            @Override
            public void handleExactMatchWithChild(FileSystemNode child) {
                diffListener.nodeRemoved(child);
            }

            @Override
            public void handleUnrelatedToAnyChild() {
            }
        });

                throw new IllegalStateException("Can't have an ancestor of a single path element");
            }

            @Override
            public void handleExactMatchWithChild(FileSystemLocationSnapshot child) {
                diffListener.nodeRemoved(DirectorySnapshot.this);
                children.stream()
                    .map(ChildMap.Entry::getValue)