*       cryptographic hashes.)
 *   <li><b>fast:</b> perhaps self-explanatory, but often the most important consideration.
 * </ul>
 *
 * <h3>Providing input to a hash function</h3>
 *
 * <p>The primary way to provide the data that your hash function should act on is via a {@link
 * Hasher}. Obtain a new hasher from the hash function using {@link #newHasher}, "push" the relevant

 *       cryptographic hashes.)
 *   <li><b>fast:</b> perhaps self-explanatory, but often the most important consideration.
 * </ul>
 *
 * <h3>Providing input to a hash function</h3>
 *
 * <p>The primary way to provide the data that your hash function should act on is via a {@link
 * Hasher}. Obtain a new hasher from the hash function using {@link #newHasher}, "push" the relevant

    public static void putLongs(Hasher hasher, long[] array) {
        hasher.putInt(array.length);
        for (long l : array) {
            hasher.putLong(l);
        }
    }

    public static void putInts(Hasher hasher, int[] array) {
        hasher.putInt(array.length);
        for (int i : array) {
            hasher.putInt(i);
        }
    }

    public static void putShorts(Hasher hasher, short[] array) {

#include "tensorflow/core/platform/path.h"

namespace tensorflow {

Asset::Asset(ImmediateTensorHandlePtr handle)
    : TensorHandleConvertible(std::move(handle)) {}

Status Asset::Create(ImmediateExecutionContext* ctx,
                     const std::string& saved_model_dir,
                     const std::string& asset_filename,
                     std::unique_ptr<Asset>* output) {
  std::string abs_path =

namespace tensorflow {

class Asset : public TensorHandleConvertible {
 public:
  static Status Create(ImmediateExecutionContext* ctx,
                       const std::string& saved_model_dir,
                       const std::string& asset_filename,
                       std::unique_ptr<Asset>* output);

  // Asset is movable, but not copyable.
  Asset(Asset&& other) = default;
  Asset& operator=(Asset&& other) = default;

/**
 * Output stream decorator that hashes data written to the stream.
 * Inspired by the Google Guava project.
 */
public final class HashingOutputStream extends FilterOutputStream {
    private final PrimitiveHasher hasher;

    public HashingOutputStream(HashFunction hashFunction, OutputStream out) {
        super(checkNotNull(out));
        this.hasher = checkNotNull(hashFunction.newPrimitiveHasher());
    }

	r.Read(b) // can't fail
}

// A hashSet measures the frequency of hash collisions.
type hashSet struct {
	list []uint64 // list of hashes added
}

func newHashSet() *hashSet {
	return &hashSet{list: make([]uint64, 0, 1024)}
}
func (s *hashSet) add(h uint64) {
	s.list = append(s.list, h)
}
func (s *hashSet) addS(x string) {
	s.add(stringHash(x))
}
func (s *hashSet) addB(x []byte) {
	s.add(bytesHash(x))
}

    public FallbackHandlingResourceHasher(ResourceHasher delegate) {
        this.delegate = delegate;
    }

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

    @Nullable
    @Override
    public HashCode hash(RegularFileSnapshotContext snapshotContext) throws IOException {

        this.cacheService = cacheService;
        this.stringInterner = stringInterner;
        this.zipHasher = zipHasher;

        Hasher hasher = Hashing.newHasher();
        zipHasher.appendConfigurationToHasher(hasher);
        this.zipHasherConfigurationHash = hasher.hash();
    }

    public static ClasspathFingerprintingStrategy runtimeClasspath(
        ResourceFilter classpathResourceFilter,

 *
 * @author Qian Huang
 * @since 16.0
 */
@Beta
@ElementTypesAreNonnullByDefault
public final class HashingInputStream extends FilterInputStream {
  private final Hasher hasher;

  /**
   * Creates an input stream that hashes using the given {@link HashFunction} and delegates all data
   * read from it to the underlying {@link InputStream}.
   *