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;

/**
 * Searches an ObjectOrigin receiver hierarchy to find the parent software type or throws an error if a software type
 * is not in the hierarchy.
 */
private
fun getSoftwareType(objectOrigin: ObjectOrigin): ObjectOrigin.AccessAndConfigureReceiver =
    findSoftwareType(objectOrigin) ?: error("Could not discover softwareType for $objectOrigin")


/**

    ) {
        this.name = name;
        this.description = description;
        this.componentId = componentId;
        this.visible = visible;
        this.transitive = transitive;
        this.hierarchy = ImmutableSet.copyOf(hierarchy);
        this.attributes = attributes;
        this.capabilities = capabilities;
        this.canBeConsumed = canBeConsumed;
        this.deprecatedForConsumption = deprecatedForConsumption;

    }

    def "builds and caches hierarchy for a configuration"() {
        given:
        configuration("a")
        configuration("b", ["a"])
        configuration("c", ["a"])
        configuration("d", ["b", "c"])

        when:
        def md = metadata

        then:
        md.getConfiguration("a").hierarchy as List == ["a"]
        md.getConfiguration("b").hierarchy as List  == ["b", "a"]

 * limitations under the License.
 */

package org.gradle.internal.classloader;

import java.io.Serializable;

/**
 * An immutable description of a ClassLoader hierarchy that can be used to recreate the hierarchy in a different process.
 *
 * Subclasses should implement equals() and hashCode(), so that the spec can be used as a hashmap key.
 */
public abstract class ClassLoaderSpec implements Serializable {

 * limitations under the License.
 */

/**
 * Exceptions thrown when variant selection fails.
 *
 * The hierarchy of exceptions here should be kept small, and in sync with the 2
 * main branches of the {@link org.gradle.internal.component.resolution.failure.type.ResolutionFailure ResolutionFailure}
 * hierarchy, which represent a failure to select a variant of a component, and a failure to select
 * a configuration by name.
 *