@Nullable
    File getDestinationDir();

    /**
     * Listener triggered when a spec is added to the hierarchy.
     */
    interface CopySpecListener {
        void childSpecAdded(CopySpecAddress path, CopySpecInternal spec);
    }

    /**
     * A visitor to traverse the spec hierarchy.
     */
    interface CopySpecVisitor {
        void visit(CopySpecAddress address, CopySpecInternal spec);
    }

//   - Names may contain at most one ':'. In the counter "foo:bar", we refer to
//     "foo" as the "chart name" and "bar" as the "bucket name".
//
//   - The '/' character should partition counter names into a hierarchy. The
//     root of this hierarchy should identify the logical entity that "owns"
//     the counter. This could be an application, such as "gopls" in the case
//     of "gopls/client:vscode", or a shared library, such as "crash" in the

     */
    Optional<HashCode> readRegularFileContentHash(String location);

    /**
     * Reads the hierarchy of files at the given location.
     */
    FileSystemLocationSnapshot read(String location);

    /**
     * Visits the hierarchy of files which match the filter at the given location.
     *
     * Returns empty {@link Optional} if filter doesn't match anything.
     */

    }

    def "findSnapshot returns root node when queried at the root"() {
        def rootNode = Mock(FileSystemNode)
        def hierarchy = DefaultSnapshotHierarchy.from(rootNode, CASE_SENSITIVE)

        when:
        def foundSnapshot = hierarchy.findMetadata("/")
        then:
        foundSnapshot.present
        1 * rootNode.snapshot >> Optional.of(Mock(MetadataSnapshot))
        0 * _
    }

import org.gradle.internal.file.impl.DefaultFileMetadata
import org.gradle.internal.hash.TestHashCodes

class DirectorySnapshotTest extends AbstractFileSystemLocationSnapshotTest {
    def "snapshot hierarchy accessed directly is relocated"() {
        def testDirectory = temporaryFolder.createDir("test")
        def sourceDir = testDirectory.createDir("source-directory")
        def childDir = sourceDir.createDir("child")

 */
public interface TypeMetadataWalker<T, V extends TypeMetadataWalker.TypeMetadataVisitor<T>> {

    /**
     * A factory method for a walker that can visit the property hierarchy of an instance.
     *
     * When visiting a nested property, child properties are discovered using the type of the
     * return property value. This can be a more specific type than the return type of the property's

 *
 * @since 8.8
 */
@Incubating
public interface IsolatedProject {

    /**
     * <p>Returns the name of this project. The project's name is not necessarily unique within a project hierarchy. You
     * should use the {@link #getPath()} method for a unique identifier for the project.
     * If the root project is unnamed and is located on a file system root it will have a randomly-generated name
     * </p>
     *

        ImmutableSet<String> hierarchy = ImmutableSet.copyOf(readStringSet(decoder));
        List<ExcludeMetadata> excludeMetadata = readMavenExcludes(decoder);
        RealisedConfigurationMetadata realized = new RealisedConfigurationMetadata(
            resolveMetadata.getId(),
            name,
            transitive,
            visible,
            hierarchy,
            artifacts,

            .expectLegacyDeprecationWarning("Mutating the hierarchy of configuration ':apiElements' after it has been resolved or consumed. This behavior has been deprecated. This will fail with an error in Gradle 9.0. After a Configuration has been resolved, consumed as a variant, or used for generating published...

     * hierarchy containing a symlink, as we can't be sure if the snapshot would still be valid of
     * the relocated link.
     *
     * If performance around symlinks becomes more important, we can improve this in multiple ways:
     * - keep symlinks that don't point outside the relocated snapshot hierarchy,
     * - re-snapshot relocated locations pointed to by snapshots,