import javax.annotation.Nullable;
import java.io.File;
import java.io.Serializable;
import java.util.Collection;
import java.util.List;

/**
 * Represents a Gradle project, isolated from the project hierarchy.
 * <p>
 * <b>This model is internal, and is NOT part of the public Tooling API.</b>
 */
@NonNullApi
public class IsolatedGradleProjectInternal implements Serializable {

            buildscript { dependencies { classpath(files('${someLib.toURI()}')) } }
        """

        // Load the StaticData class in the different sub-sub-projects
        // for a more interesting ClassLoader hierarchy.
        for (projectDir in ['foo/foo', 'bar/bar']) {
            file("$projectDir/build.gradle") << """
                buildscript { dependencies { classpath(files('${staticDataLib.toURI()}')) } }

    /**
     * Returns the metadata stored at the absolute path if it exists.
     */
    Optional<MetadataSnapshot> findMetadata(String absolutePath);

    /**
     * Returns all root snapshots in the hierarchy below {@code absolutePath}.
     */
    Stream<FileSystemLocationSnapshot> findRootSnapshotsUnder(String absolutePath);

    /**
     * Snapshots and stores the result in the VFS.
     *

        this.id = id;
        this.origin = origin;
        this.classLoaderCache = classLoaderCache;
        this.listener = listener;
    }

    /**
     * Unique identifier of this scope in the hierarchy.
     */
    @Override
    public ClassLoaderScopeId getId() {
        return id;
    }

    @Nullable
    @Override
    public ClassLoaderScopeOrigin getOrigin() {
        return origin;
    }

     *
     * <p><b>This will prevent the task's outputs from being shared across different workspaces via the build cache.</b></p>
     */
    ABSOLUTE,

    /**
     * Use the location of the file related to a hierarchy.
     *
     * <p>
     *     For files in the root of the file collection, the file name is used as the normalized path.
     *     For directories in the root of the file collection, an empty string is used as normalized path.

    public DefaultSerializerRegistry() {
        this(true);
    }

    public DefaultSerializerRegistry(boolean supportClassHierarchy) {
        this.classMatcher = supportClassHierarchy ? SerializerClassMatcherStrategy.HIERARCHY : SerializerClassMatcherStrategy.STRICT;
    }

    @Override
    public <T> void register(Class<T> implementationType, final Serializer<T> serializer) {

import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * A collection of files in Xcode's virtual filesystem hierarchy.
 */
public class PBXGroup extends PBXReference {
    private final List<PBXReference> children;
    private final LoadingCache<String, PBXGroup> childGroupsByName;

        taskA.project == project

        project.tasks.find { it.name == 'b' && it.path == ':b' }
        project.tasks.find { it.name == 'c' && it.path == ':c' }
    }

    def "provides hierarchy"() {
        file('settings.gradle') << "include 'a', 'a:b', 'a:c', 'a:c:d'"
        file('build.gradle') << '''
task rootTask
project (':a') { description = 'A rocks!' }
'''

        when:

        withValidityAssertion { analysisSession.symbolDeclarationOverridesProvider.getDirectlyOverriddenSymbols(this) }

    /**
     * Checks if [this] class has [superClass] as its superclass somewhere in the inheritance hierarchy.
     *
     * N.B. The class is not considered to be a subclass of itself, so `myClass.isSubClassOf(myClass)` is always `false`.
     */

import javax.annotation.Nullable;
import java.util.HashSet;
import java.util.Map;

/**
 * Fingerprint file system snapshots normalizing the path to the relative path in a hierarchy.
 *
 * File names for root directories are ignored. For root files, the file name is used as normalized path.
 */
public class RelativePathFingerprintingStrategy extends AbstractDirectorySensitiveFingerprintingStrategy {