return DEFAULT.newHasher();
    }

    /**
     * Returns a new {@link PrimitiveHasher} based on the default hashing implementation.
     */
    public static PrimitiveHasher newPrimitiveHasher() {
        return DEFAULT.newPrimitiveHasher();
    }

    /**
     * Returns a hash code to use as a signature for a given type.
     */
    public static HashCode signature(Class<?> type) {

    /**
     * Returns the algorithm used for this hashing function.
     */
    String getAlgorithm();

    /**
     * Returns a primitive hasher using the hash function.
     */
    PrimitiveHasher newPrimitiveHasher();

    /**
     * Returns a prefixing hasher using the hash function.
     */
    Hasher newHasher();

    /**
     * Hash the given bytes using the hash function.
     */

        this.hashFunction = hashFunction;
    }

    @Override
    public HashCode hash(File file) {
        try {
            PrimitiveHasher hasher = hashFunction.newPrimitiveHasher();
            byte[] buffer = new byte[4096];
            int len;
            try (InputStream in = new FileInputStream(file)) {
                while ((len = in.read(buffer)) >= 0) {

    private final PrimitiveHasher hasher;

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

    @Override
    public void write(int b) throws IOException {
        hasher.putByte((byte) b);
        out.write(b);
    }

    @Override

        return new StringReader(content);
    }

    private void maybeFetch() {
        if (content == null) {
            content = resource.getText();
            PrimitiveHasher hasher = Hashing.newPrimitiveHasher();
            hasher.putHash(SIGNATURE);
            hasher.putString(content);
            contentHash = hasher.hash();
        }
    }

        return contents.toString();
    }

    @Override
    public HashCode getContentHash() throws ResourceException {
        if (contentHash == null) {
            PrimitiveHasher hasher = Hashing.newPrimitiveHasher();
            hasher.putHash(SIGNATURE);
            hasher.putString(getText());
            contentHash = hasher.hash();
        }
        return contentHash;
    }

    @Override

    }

    private HashCode doHash(InputStream inputStream, OutputStream outputStream) throws IOException {
        byte[] buffer = takeBuffer();
        try {
            PrimitiveHasher hasher = Hashing.newPrimitiveHasher();
            hasher.putHash(SIGNATURE);
            while (true) {
                int nread = inputStream.read(buffer);
                if (nread < 0) {
                    break;
                }

    }

    /**
     * Returns empty if the file is detected to be a binary file
     */
    private Optional<HashCode> hash(InputStream inputStream) throws IOException {
        PrimitiveHasher hasher = Hashing.newPrimitiveHasher();

        hasher.putHash(SIGNATURE);

        try (BufferedInputStream input = new BufferedInputStream(CloseShieldInputStream.wrap(inputStream), BUFFER_SIZE)) {
            int peekAhead = -1;

        }
    }

    @Override
    public HashCode getContentHash() throws ResourceException {
        PrimitiveHasher hasher = Hashing.newPrimitiveHasher();
        hasher.putHash(SIGNATURE);
        hasher.putString(getText());
        return hasher.hash();
    }

    @Override
    public Reader getAsReader() {
        assertNoDirectory();