Source code
package com.google.common.hash;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import com.google.errorprone.annotations.Immutable;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
/**
* {@link HashFunction} adapter for {@link MessageDigest} instances.
*
* @author Kevin Bourrillion
* @author Dimitris Andreou
*/
@Immutable
final class MessageDigestHashFunction extends AbstractHashFunction implements Serializable {
@SuppressWarnings("Immutable") // cloned before each use
private final MessageDigest prototype;
private final int bytes;
private final boolean supportsClone;
private final String toString;
MessageDigestHashFunction(String algorithmName, String toString) {
this.prototype = getMessageDigest(algorithmName);
this.bytes = prototype.getDigestLength();
this.toString = checkNotNull(toString);
this.supportsClone = supportsClone(prototype);
}
MessageDigestHashFunction(String algorithmName, int bytes, String toString) {
this.toString = checkNotNull(toString);
this.prototype = getMessageDigest(algorithmName);
int maxLength = prototype.getDigestLength();
checkArgument(
bytes >= 4 && bytes <= maxLength, "bytes (%s) must be >= 4 and < %s", bytes, maxLength);
this.bytes = bytes;
this.supportsClone = supportsClone(prototype);
}
private static boolean supportsClone(MessageDigest digest) {
try {
Object unused = digest.clone();
return true;
} catch (CloneNotSupportedException e) {
return false;
}
}
@Override
public int bits() {
return bytes * Byte.SIZE;
}
@Override
public String toString() {
return toString;
}
private static MessageDigest getMessageDigest(String algorithmName) {
try {
return MessageDigest.getInstance(algorithmName);
} catch (NoSuchAlgorithmException e) {
throw new AssertionError(e);
}
}
@Override
public Hasher newHasher() {
if (!((supportsClone))) {} else {
try {
return new MessageDigestHasher((MessageDigest) prototype.clone(), bytes);
} catch (CloneNotSupportedException e) {
// falls through
}
}
return new MessageDigestHasher(getMessageDigest(prototype.getAlgorithm()), bytes);
}
private static final class SerializedForm implements Serializable {
private final String algorithmName;
private final int bytes;
private final String toString;
private SerializedForm(String algorithmName, int bytes, String toString) {
this.algorithmName = algorithmName;
this.bytes = bytes;
this.toString = toString;
}
private Object readResolve() {
return new MessageDigestHashFunction(algorithmName, bytes, toString);
}
private static final long serialVersionUID = 0;
}
Object writeReplace() {
return new SerializedForm(prototype.getAlgorithm(), bytes, toString);
}
private void readObject(ObjectInputStream stream) throws InvalidObjectException {
throw new InvalidObjectException("Use SerializedForm");
}
/** Hasher that updates a message digest. */
private static final class MessageDigestHasher extends AbstractByteHasher {
private final MessageDigest digest;
private final int bytes;
private boolean done;
private MessageDigestHasher(MessageDigest digest, int bytes) {
this.digest = digest;
this.bytes = bytes;
}
@Override
protected void update(byte b) {
checkNotDone();
digest.update(b);
}
@Override
protected void update(byte[] b, int off, int len) {
checkNotDone();
digest.update(b, off, len);
}
@Override
protected void update(ByteBuffer bytes) {
checkNotDone();
digest.update(bytes);
}
private void checkNotDone() {
checkState(!done, "Cannot re-use a Hasher after calling hash() on it");
}
@Override
public HashCode hash() {
checkNotDone();
done = true;
return (bytes == digest.getDigestLength())
? HashCode.fromBytesNoCopy(digest.digest())
: HashCode.fromBytesNoCopy(Arrays.copyOf(digest.digest(), bytes));
}
}
}
Run 1
The code has a confusing if/else structure in newHasher() with an empty if block and inverted logic, which severely impacts readability. The use of `if (!((supportsClone))) {} else {` is unnecessarily convoluted and should be `if (supportsClone)`. Dead code (unused variable) and an empty catch block also reduce clarity. Some positive aspects: methods are generally small and focused, variable names are mostly clear, and serialization is handled in a separate class. However, the illogical conditional structure, empty blocks, and awkward nesting make the flow difficult to follow. Action granularity is mostly fine (one operation per line), but the overall structure suffers from the confusing cloning logic and unnecessary syntactic complexity. The code would benefit from flattening the conditional logic, removing empty blocks, and clarifying the fallthrough behavior with comments or restructuring.
Run 2
The code is well-structured and generally readable. It has clear class organization, reasonable nesting, and good naming conventions. Methods like `supportsClone`, `checkNotDone`, and `hash` demonstrate clear intent and appropriate action granularity. The constructors are concise, and serialization handling is properly separated. Minor readability issues prevent a perfect score: the `newHasher` method contains an awkward empty `if` block with an `else` that inverts the logic unnecessarily, and the `MessageDigestHasher.hash()` method crams a ternary operation into a return statement, slightly reducing clarity. The `supportsClone` method uses a throwaway `unused` variable, which is understandable but not ideal. Overall, the code follows good practices for readability with only minor areas for improvement.
Run 3
The code has clear intent and logical organization, with purposeful classes and methods. However, readability is reduced by inconsistent formatting, particularly the `newHasher()` method: it contains an empty if block with an else clause, which is confusing and unnatural. The condition `if (!((supportsClone))) {} else { ... }` is awkwardly structured and adds unnecessary nesting. Additionally, the constructor logic is somewhat duplicated and could be more concise. While the overall flow is understandable, the action granularity suffers in a few places due to packed conditions and the weird empty branch. The code is not deeply nested overall, but the `newHasher()` structure disrupts the reading flow and clarity of intent. The use of `MessageDigest` and serialization is handled correctly, but the weird empty if block and inconsistent formatting lower the score. A cleaner refactor of `newHasher()` to use a straightforward if condition would improve clarity significantly.
Run 1
Code Structure: Well-organized adapter with separate nested classes for serialization and hashing, plus focused helper methods. Nesting: Generally shallow, though newHasher unnecessarily nests a try/catch inside an else following an empty if. Clarity of intent: Descriptive names, explicit state checks, and brief comments make the purpose clear; the inverted, redundantly parenthesized supportsClone condition obscures intent, and the validation message says '<' while the check permits equality. Code length: Mostly concise, with reasonable boilerplate and minor constructor duplication. Action granularity: Statements generally perform one action per line; the empty if/else on one line is an awkward exception. Reading flow: Methods follow a coherent progression, but the unusual clone branch interrupts otherwise natural control flow.
Run 2
Code Structure: Well organized into focused helpers, a serialization proxy, and a dedicated hasher class. Nesting: Generally shallow, although newHasher unnecessarily nests a try/catch inside an awkward empty if/else. Clarity of intent: Descriptive names, explicit validation, and short methods make digest creation, updates, and finalization clear; the negated, over-parenthesized supportsClone condition obscures an otherwise simple decision. Code length: Mostly concise, with reasonable repetition across constructors and update overloads. Action granularity: Nearly every line performs one action, except the compressed empty conditional; the final ternary remains manageable. Reading flow: Consistent formatting and cohesive method grouping support natural reading, but newHasher interrupts that flow. Minor distractions include the unused clone variable and a validation message stating '<' when the condition permits equality.
Run 3
Code Structure: Well organized into an adapter, serialization proxy, and dedicated hasher, with small, focused methods. Nesting: Generally shallow; the conditional and try/catch in newHasher add modest complexity. Clarity of intent: Descriptive names, overrides, and validation make the purpose clear, but the negated condition with excessive parentheses and an empty branch obscures the clone fallback. Code length: Mostly concise; constructor duplication and serialization boilerplate add some length without seriously hindering comprehension. Action granularity: Almost every statement performs one action, although the compressed empty if/else formatting is distracting. Reading flow: Consistent formatting and cohesive method grouping support natural reading, with minor interruptions from the unusual newHasher conditional and the multiline ternary in hash().