* limitations under the License.
 */

package org.gradle.internal.snapshot;

import java.util.Optional;
import java.util.stream.Stream;

public interface ChildMap<T> {

    boolean isEmpty();

    int size();

    Stream<Entry<T>> stream();

    <RESULT> RESULT withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, RESULT> handler);

    public static <T> ChildMap<T> childMap(CaseSensitivity caseSensitivity, Collection<ChildMap.Entry<T>> entries) {
        List<ChildMap.Entry<T>> sortedEntries = new ArrayList<>(entries);
        sortedEntries.sort(Comparator.comparing(ChildMap.Entry::getPath, PathUtil.getPathComparator(caseSensitivity)));
        return childMapFromSorted(sortedEntries);
    }

            public ChildMap<T> withReplacedChild(T newChild) {
                return withReplacedChild(entry.getPath(), newChild);
            }

            @Override
            public ChildMap<T> withReplacedChild(String newChildPath, T newChild) {
                return SingletonChildMap.this.withReplacedChild(newChildPath, newChild);
            }

            @Override

        }
    }

    ChildMap<CHILD> createChildren(List<String> pathsToParent) {
        return ChildMapFactory.childMapFromSorted(pathsToParent.stream()
            .sorted(PathUtil.getPathComparator(CASE_SENSITIVE))
            .map { childPath -> new ChildMap.Entry(childPath, mockChild()) }
            .collect(Collectors.toList()))
    }

    ChildMap<CHILD> childrenWithSelectedChildReplacedBy(CHILD replacement) {

        ChildMap.Entry<T> sibling = new ChildMap.Entry<>(siblingPath, handler.createChild());
        ChildMap<T> newChildren = ChildMapFactory.childMap(caseSensitivity, newChild, sibling);
        return withReplacedChild(commonPrefix, handler.createNodeFromChildren(newChildren));
    }

    @Override
    public ChildMap<T> handleUnrelatedToAnyChild(VfsRelativePath targetPath) {
        String path = targetPath.getAsString();

    private final ChildMap.InvalidationHandler<T, RESULT> handler;

    public AbstractInvalidateChildHandler(ChildMap.InvalidationHandler<T, RESULT> handler) {
        this.handler = handler;
    }

    public abstract ChildMap<RESULT> getChildMap();

    public abstract ChildMap<RESULT> withReplacedChild(RESULT newChild);

                }

                @Override
                public ChildMap<RESULT> withReplacedChild(RESULT newChild) {
                    return withReplacedChild(childPath, newChild);
                }

                @Override
                public ChildMap<RESULT> withReplacedChild(String newChildPath, RESULT newChild) {

import java.util.stream.Stream;

public abstract class AbstractIncompleteFileSystemNode implements FileSystemNode {
    protected final ChildMap<FileSystemNode> children;

    @SuppressWarnings("unchecked")
    public AbstractIncompleteFileSystemNode(ChildMap<? extends FileSystemNode> children) {
        this.children = (ChildMap<FileSystemNode>) children;
    }

    @Override

    private final ChildMap<FileSystemLocationSnapshot> children;
    private final HashCode contentHash;

    public DirectorySnapshot(String absolutePath, String name, AccessType accessType, HashCode contentHash, List<FileSystemLocationSnapshot> children) {
        this(absolutePath, name, accessType, contentHash, childMapFromSorted(children.stream()
            .map(it -> new ChildMap.Entry<>(it.getName(), it))

    private final ChildMap<ValuedVfsHierarchy<T>> children;
    private final CaseSensitivity caseSensitivity;

    public static <T> ValuedVfsHierarchy<T> emptyHierarchy(CaseSensitivity caseSensitivity) {
        return new ValuedVfsHierarchy<>(PersistentList.of(), EmptyChildMap.getInstance(), caseSensitivity);
    }