*
     * @see #getModuleNames()
     */
    private final Map<Path, String> descriptors;

    /**
     * Whether module hierarchy was detected. If false, then package hierarchy is assumed.
     * In a package hierarchy, the {@linkplain #descriptors} map has either zero or one entry.
     * In a module hierarchy, the descriptors map may have an arbitrary number of entries,
     * including one (so the map size cannot be used as a criterion).
     *

 * indeed receives file system events from the operating system.
 * This is to avoid trusting locations where OSs silently not send any events, despite watchers being registered.
 *
 * When the hierarchy is first registered via {@link #registerProbe(File)}, we don't yet create the probe.
 * That only happens when the hierarchy is actually read or written by Gradle, in which case

    }

    ImmutableList<ModuleComponentArtifactMetadata> filterArtifacts(String name, Collection<String> hierarchy) {
        Set<ModuleComponentArtifactMetadata> artifacts = new LinkedHashSet<>();
        collectArtifactsFor(name, artifacts);
        for (String parent : hierarchy) {
            collectArtifactsFor(parent, artifacts);
        }
        return ImmutableList.copyOf(artifacts);
    }

		}
		return r
	}, uid))
}

// Cgroup represents a linux cgroup.
type Cgroup struct {
	HierarchyID    string
	ControllerList string
	GroupPath      string
}

// GetCGroups returns a slice of cgroups for pid using fs for filesystem calls.
//
// The expected cgroup format is "hierarchy-ID:controller-list:cgroup-path", and
// this function will return an error if every cgroup does not meet that format.
//

import org.gradle.internal.snapshot.VfsRelativePath;

import javax.annotation.CheckReturnValue;

/**
 * Structure for tracking modifications in a hierarchy.
 *
 * Allows doing optimistic locking to check whether anything in a hierarchy changed.
 */
public class VersionHierarchyRoot {
    private final CaseSensitivity caseSensitivity;
    private final VersionHierarchy rootNode;

    ) {
        this(componentId, name, transitive, visible, hierarchy, artifacts, excludes, componentLevelAttributes, capabilities, null, addedByRule, externalVariant);
    }

    public RealisedConfigurationMetadata(
            ModuleComponentIdentifier componentId,
            String name,
            boolean transitive,
            boolean visible,
            ImmutableSet<String> hierarchy,

 */

package org.gradle.internal.hash;

import javax.annotation.Nullable;

/**
 * Provides a combined hash for a hierarchy of classloaders.
 */
public interface ClassLoaderHierarchyHasher {
    /**
     * Returns a hash for the given classloader hierarchy, or {@code null}
     * if the hierarchy contains any classloaders that are not known to Gradle.
     */
    @Nullable
    HashCode getClassLoaderHash(ClassLoader classLoader);

    }

    /**
     * Visits all types in a type hierarchy in breadth-first order, super-classes first and then implemented interfaces.
     *
     * @param clazz the type of whose type hierarchy to visit.
     * @param excludedTypes the types not to walk when encountered in the hierarchy.
     * @param visitor the visitor to call for each type in the hierarchy.
     */

/**
 * Node in a structure for tracking modifications in a hierarchy.
 *
 * Allows doing optimistic locking to check whether anything in a hierarchy changed.
 */
public class VersionHierarchy {
    private final long version;
    // We store the maximum version as a performance optimization, so we don't need
    // to query the children every time we query the version for a hierarchy.
    private final long maxVersionInHierarchy;

        immutable.getConfiguration("compile").hierarchy as List == ["compile"]
        immutable.getConfiguration("runtime").hierarchy as List == ["runtime", "compile"]
        immutable.getConfiguration("master").hierarchy as List == ["master"]
        immutable.getConfiguration("test").hierarchy as List == ["test", "runtime", "compile"]
        immutable.getConfiguration("default").hierarchy as List == ["default", "runtime", "compile", "master"]