Source code
package org.apache.kafka.common.network;
import java.util.Objects;
public class ReauthenticationContext {
private final NetworkReceive networkReceive;
private final Authenticator previousAuthenticator;
private final long reauthenticationBeginNanos;
public ReauthenticationContext(Authenticator previousAuthenticator, NetworkReceive networkReceive, long nowNanos) {
this.previousAuthenticator = Objects.requireNonNull(previousAuthenticator);
this.networkReceive = networkReceive;
this.reauthenticationBeginNanos = nowNanos;
}
public NetworkReceive networkReceive() {
return networkReceive;
}
public Authenticator previousAuthenticator() {
return previousAuthenticator;
}
public long reauthenticationBeginNanos() {
return reauthenticationBeginNanos;
}
}
Run 1
The code is concise and well-structured, with clear naming and a single, obvious responsibility. Constructors and accessor methods are simple and flat, with no deep nesting. Action granularity is ideal—one operation per line. The use of Objects.requireNonNull enforces invariants cleanly. Minor issues: excessive blank lines (likely for Javadoc placeholders) disrupt reading flow and add unnecessary length. Otherwise, intent is clear and readability is high.
Run 2
The code is generally readable, with a clear class structure, simple getter methods, and flat nesting. Each action is on its own line, and the intent is straightforward. However, the excessive blank lines between methods reduce readability by disrupting the natural reading flow and making the file feel unnecessarily long. The constructor and methods are concise but could benefit from tighter formatting.
Run 3
The code is generally readable with a clear, logical structure: a simple class with three fields, a constructor, and three getters. Naming is descriptive (e.g., 'previousAuthenticator', 'reauthenticationBeginNanos') and each action has its own line, making the flow natural. However, readability is negatively impacted by excessive blank lines and comment placeholders scattered throughout, which disrupt the visual flow. The class is concise and not deeply nested, which is good. The use of Objects.requireNonNull shows clear intent for validating input. Overall, the code is understandable and maintainable, but the formatting could be tightened for better readability.
Run 1
Code Structure: Fields, constructor, and accessors are logically organized. Nesting: Minimal nesting makes the class easy to follow. Clarity of intent: Descriptive names and final fields clearly convey a reauthentication context, though networkReceive nullability is undocumented. Code length: The implementation is concise, but excessive blank lines unnecessarily lengthen its presentation. Action granularity: Each assignment and return occupies its own line. Reading flow: The constructor and accessors follow a natural sequence, but large whitespace gaps interrupt scanning.
Run 2
Code Structure: Fields, constructor, and accessors are logically organized. Nesting: There is no unnecessary nesting; each method is straightforward. Clarity of intent: Descriptive class, field, and method names clearly convey a reauthentication context, although nowNanos is less specific than the field it initializes. Code length: The implementation is concise, but excessive blank lines unnecessarily inflate its visual length. Action granularity: Each assignment and return occupies its own line. Reading flow: The conventional organization supports easy reading, but large whitespace gaps repeatedly interrupt the flow.
Run 3
Code Structure: The class is logically organized into fields, a constructor, and accessors. Nesting: There is no nested control flow, making it easy to follow. Clarity of intent: Descriptive names and final fields clearly convey a context object holding reauthentication state; the constructor also explicitly validates the previous authenticator. Code length: The implementation is concise, but excessive blank lines unnecessarily inflate its visual length. Action granularity: Each assignment and return occupies its own line. Reading flow: The ordering is natural, but large whitespace gaps interrupt scanning and obscure the class's otherwise compact structure.