* byte-based hashcode. Otherwise it returns {@link HashCode#asBytes}. Do <i>not</i> mutate this
   * array or else you will break the immutability contract of {@code HashCode}.
   */
  byte[] getBytesInternal() {
    return asBytes();
  }

  /**
   * Returns whether this {@code HashCode} and that {@code HashCode} have the same value, given that

   * byte-based hashcode. Otherwise it returns {@link HashCode#asBytes}. Do <i>not</i> mutate this
   * array or else you will break the immutability contract of {@code HashCode}.
   */
  byte[] getBytesInternal() {
    return asBytes();
  }

  /**
   * Returns whether this {@code HashCode} and that {@code HashCode} have the same value, given that

 * This implementation also requires GC to track two separate objects (the {@code HashCode} object and its {@code byte[]}).
 * <p>
 * Because Gradle uses a lot of MD5 hashes, for 128-bit hashes we have a more efficient implementation.
 * {@link HashCode128} uses two longs to store the bits of the hash, and does not need to cache the {@link #hashCode()} either.

    bytesB[4] = (byte) 0xef;

    HashCode hashCodeA = HashCode.fromBytes(bytesA);
    HashCode hashCodeB = HashCode.fromBytes(bytesB);

    // They aren't equal...
    assertFalse(hashCodeA.equals(hashCodeB));

    // But they still have the same Object#hashCode() value.
    // Technically not a violation of the equals/hashCode contract, but...?
    assertEquals(hashCodeA.hashCode(), hashCodeB.hashCode());
  }

        HashCode hashCode = implementationHash != null
            ? implementationHash
            : calculateClassLoaderHash(classPath);
        ClassLoader classLoader = super.doCreateClassLoader(name, parent, classPath);
        hashCodes.put(classLoader, hashCode);
        return classLoader;
    }

    @Override

    private static final HashCode NO_HASH = Hashing.signature(CachingResourceHasher.class.getName() + " : no hash");
    private final IndexedCache<HashCode, HashCode> indexedCache;

    public DefaultResourceSnapshotterCacheService(IndexedCache<HashCode, HashCode> indexedCache) {
        this.indexedCache = indexedCache;
    }

    @Nullable
    @Override

import org.gradle.internal.hash.HashCode;

public class DefaultBuildCacheKey implements BuildCacheKeyInternal {
    private final HashCode hashCode;

    public DefaultBuildCacheKey(HashCode hashCode) {
        this.hashCode = hashCode;
    }

    @Override
    public String getHashCode() {
        return hashCode.toString();
    }

    @Override
    public HashCode getHashCodeInternal() {

package org.gradle.caching.internal;

import org.gradle.internal.hash.HashCode;

public class SimpleBuildCacheKey implements BuildCacheKeyInternal {
    private final HashCode hashCode;

    public SimpleBuildCacheKey(HashCode hashCode) {
        this.hashCode = hashCode;
    }

    @Override
    public HashCode getHashCodeInternal() {
        return hashCode;
    }

    @Override
    public String getHashCode() {

import org.gradle.internal.hash.HashCode
import org.gradle.internal.hash.TestHashCodes

class TestBuildCacheKey implements BuildCacheKeyInternal {
    private final HashCode hashCode

    TestBuildCacheKey(long hashCode) {
        this(TestHashCodes.hashCodeFrom(hashCode))
    }

    TestBuildCacheKey(HashCode hashCode) {
        this.hashCode = hashCode
    }

    @Override
    String getHashCode() {

            @Nullable
            @Override
            HashCode handle(RegularFileSnapshot fileSnapshot, IoFunction<RegularFileSnapshot, HashCode> function) throws IOException {
                return function.apply(fileSnapshot);
            }

            @Nullable
            @Override
            HashCode handle(ZipEntryContent zipEntry, IoFunction<ZipEntryContent, HashCode> function) throws IOException {