override fun getView(viewType: Class<*>): Any {
            val viewBuilder = ProtocolToModelAdapter().builder(viewType)
            return viewBuilder.build(parameter)!!
        }

        override fun getHash(): HashCode {
            val unpacked = ToolingParameterProxy.unpackProperties(parameter)
            return Hashing.hashHashable(valueSnapshotter.snapshot(unpacked))
        }
    }

      Entry<K, V> entry = requireNonNull(entryArray[i]);
      K key = entry.getKey();
      V value = entry.getValue();
      checkEntryNotNull(key, value);
      int keyHash = key.hashCode();
      int valueHash = value.hashCode();
      int keyBucket = Hashing.smear(keyHash) & mask;
      int valueBucket = Hashing.smear(valueHash) & mask;

      ImmutableMapEntry<K, V> nextInKeyBucket = keyTable[keyBucket];

        this(classpath, hasher.hash(classpath));
    }

    public ClassPath getClasspath() {
        return classpath;
    }

    public HashCode getHash() {
        return hash;
    }

 */
public interface CurrentFileCollectionFingerprint extends FileCollectionFingerprint {
    /**
     * Returns the combined hash of the contents of this {@link CurrentFileCollectionFingerprint}.
     */
    HashCode getHash();

    /**
     * An identifier for the strategy.
     *
     * Used to select a compare strategy.
     */
    String getStrategyIdentifier();

    /**

    @Override
    public ClassSetAnalysisData analyzeClasspathEntry(final File classpathEntry) {
        FileSystemLocationSnapshot snapshot = fileSystemAccess.read(classpathEntry.getAbsolutePath());
        return cache.get(snapshot.getHash(), hash -> delegate.analyzeClasspathEntry(classpathEntry));
    }

    @Override
    public ClassSetAnalysisData analyzeOutputFolder(File outputFolder) {
        return delegate.analyzeOutputFolder(outputFolder);
    }

public class RuntimeClasspathResourceHasher implements ResourceHasher {

    @Nullable
    @Override
    public HashCode hash(RegularFileSnapshotContext fileSnapshotContext) {
        return fileSnapshotContext.getSnapshot().getHash();
    }

    @Override
    public HashCode hash(ZipEntryContext zipEntryContext) throws IOException {
        return zipEntryContext.getEntry().withInputStream(Hashing::hashStream);
    }

    @Override

    FileSystemLocationSnapshotHasher DEFAULT = new FileSystemLocationSnapshotHasher() {
        @Nullable
        @Override
        public HashCode hash(FileSystemLocationSnapshot snapshot) {
            return snapshot.getHash();
        }

        @Override
        public void appendConfigurationToHasher(Hasher hasher) {
            hasher.putString(getClass().getName());
        }
    };

}

func addLabelToCache(c *lru.Cache, transformationType, providerName, keyID, apiServerID string) (string, string) {
	keyIDHash := getHash(keyID)
	apiServerIDHash := getHash(apiServerID)
	c.Add(metricLabels{
		transformationType: transformationType,
		providerName:       providerName,
		keyIDHash:          keyIDHash,
		apiServerIDHash:    apiServerIDHash,
	}, nil) // value is irrelevant, this is a set and not a map

    int hash = original.getHash();
    return segmentFor(hash).copyEntry(original, newNext);
  }

  int hash(Object key) {
    int h = keyEquivalence.hash(key);
    return rehash(h);
  }

  void reclaimValue(WeakValueReference<K, V, E> valueReference) {
    E entry = valueReference.getEntry();
    int hash = entry.getHash();

    private final String identifier;

    public EmptyCurrentFileCollectionFingerprint(String identifier) {
        this.identifier = identifier;
    }

    @Override
    public HashCode getHash() {
        return SIGNATURE;
    }

    @Override
    public boolean isEmpty() {
        return true;
    }

    @Override
    public Map<String, FileSystemLocationFingerprint> getFingerprints() {