public abstract boolean equals(@CheckForNull Object obj);

  /**
   * The hashcode of an ordered {@link EndpointPair} is equal to {@code Objects.hashCode(source(),
   * target())}. The hashcode of an unordered {@link EndpointPair} is equal to {@code
   * nodeU().hashCode() + nodeV().hashCode()}.
   */
  @Override
  public abstract int hashCode();

  private static final class Ordered<N> extends EndpointPair<N> {

    return super.equals(obj);
  }

  /**
   * By default delegates to {@link Object#hashCode}. The dynamic proxies' {@code hashCode()} will
   * delegate to this method. Subclasses can override this method to provide custom equality.
   */
  @Override
  public int hashCode() {
    return super.hashCode();
  }

  /**

import com.google.common.collect.ImmutableSet;
import org.gradle.internal.hash.HashCode;

/**
 * Immutable snapshot of the state of a source file.
 */
public class SourceFileState {
    private final HashCode hash;
    private final boolean hasUnresolved;
    private final ImmutableSet<IncludeFileEdge> resolvedIncludes;

    public SourceFileState(HashCode hash, boolean hasUnresolved, ImmutableSet<IncludeFileEdge> resolvedIncludes) {

  private final transient int hashCode;
  // the same values as `elements` in hashed positions (plus nulls)
  @VisibleForTesting final transient @Nullable Object[] table;
  // 'and' with an int to get a valid table index.
  private final transient int mask;
  private final transient int size;

  RegularImmutableSet(
      @Nullable Object[] elements, int hashCode, @Nullable Object[] table, int mask, int size) {

        this.strictVersion = "";
        this.rejectedVersions = ImmutableList.of();
        this.requiredBranch = null;
        this.hashCode = super.hashCode();
    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    @Nullable
    @Override
    public String getBranch() {
        return requiredBranch;
    }

    @Override

import org.gradle.internal.hash.HashCode;

import java.util.Set;

class DefaultCachedArtifacts implements CachedArtifacts {
    private final Set<ComponentArtifactMetadata> artifacts;
    private final HashCode descriptorHash;
    private final long ageMillis;

    DefaultCachedArtifacts(Set<ComponentArtifactMetadata> artifacts, HashCode descriptorHash, long ageMillis) {
        this.ageMillis = ageMillis;

import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.hash.HashCode;

import java.io.Serializable;

/**
 * Immutable classpath with it's precomputed hash.
 */
public class HashedClasspath implements Serializable {
    private final ClassPath classpath;
    private final HashCode hash;

    public HashedClasspath(ClassPath classpath, HashCode hash) {
        this.classpath = classpath;
        this.hash = hash;

import java.io.File;

@ServiceScope(Scope.BuildSession.class)
public interface ChecksumService {
    HashCode md5(File file);

    HashCode sha1(File file);

    HashCode sha256(File file);

    HashCode sha512(File file);

    HashCode hash(File src, String algorithm);

        hasher.putString(getClass().getName());
    }

    @Override
    Optional<HashCode> tryHash(RegularFileSnapshotContext snapshotContext) {
        return Optional.of(snapshotContext)
            .flatMap(IoFunction.wrap(this::hashContent));
    }

    @Override
    Optional<HashCode> tryHash(ZipEntryContext zipEntryContext) {
        return Optional.of(zipEntryContext)

        this.componentIdentifier = componentIdentifier;
        this.name = artifact;
        this.hashCode = 31 * name.hashCode() + componentIdentifier.hashCode();
    }

    @Override
    public String getFileName() {
        String classifier = StringUtils.isNotEmpty(name.getClassifier()) ? "-" + name.getClassifier() : "";