Source code
package org.apache.kafka.clients.consumer.internals.events;
import org.apache.kafka.common.IsolationLevel;
import org.apache.kafka.common.TopicPartition;
import java.util.Objects;
import java.util.OptionalLong;
public class CurrentLagEvent extends CompletableApplicationEvent<OptionalLong> {
private final TopicPartition partition;
private final IsolationLevel isolationLevel;
public CurrentLagEvent(final TopicPartition partition, final IsolationLevel isolationLevel, final long deadlineMs) {
super(Type.CURRENT_LAG, deadlineMs);
this.partition = Objects.requireNonNull(partition);
this.isolationLevel = Objects.requireNonNull(isolationLevel);
}
public TopicPartition partition() {
return partition;
}
public IsolationLevel isolationLevel() {
return isolationLevel;
}
@Override
public String toStringBase() {
return super.toStringBase() + ", partition=" + partition + ", isolationLevel=" + isolationLevel;
}
}
Run 1
The code is well-structured with clear separation of concerns: imports, field declarations, constructor, accessors, and toString override. It is flat with no nested logic. Purpose is unambiguous: a completion event carrying partition and isolation level data. The length is concise with no unnecessary code. Each action (assignment, null check, return) is on its own line. Reading flow is natural, progressing from fields to construction to access. Minor deduction for the long class declaration line and the chained `Objects.requireNonNull` calls reducing slightly the one-action-per-line granularity.
Run 2
The code is highly readable. It follows a clear, logical structure with a single class definition, straightforward imports, and well-organized fields, constructors, and methods. Nesting is minimal—there are no deep conditionals or blocks. Intent is explicit: the class represents a current lag event with partition and isolation level, and inheritance from CompletableApplicationEvent is clear. The code is concise, with no unnecessary repetition or boilerplate beyond what is idiomatic. Each line performs a single action, such as assignment or method return, improving clarity. Reading flow is natural: imports, fields, constructor, accessors, and toString override appear in a predictable order. The use of Objects.requireNonNull communicates validation clearly. Overall, it is clean, maintainable, and easy to understand with almost no ambiguity.
Run 3
The code demonstrates excellent readability. It has a logical structure with clear class hierarchy and standard constructor/getter organization. Nesting is minimal and linear. The intent is explicit: representing a current lag event with partition and isolation level. Code length is concise with no unnecessary methods. Each line performs one clear action, especially in the constructor with null checks and field assignments. The reading flow is natural, following conventional Java patterns. Minor deductions could be for missing class-level documentation, but the code is self-documenting through clear naming.
Run 1
Code Structure: Fields, constructor, accessors, and string representation are logically organized. Nesting: Flat methods with no nested control flow make the code easy to scan. Clarity of intent: Descriptive class, field, and method names clearly communicate the event's purpose; explicit null checks establish required inputs. Code length: Concise, with no unnecessary logic or duplication. Action granularity: Each statement performs one clear action; the string concatenation remains straightforward. Reading flow: Natural progression from state to initialization to accessors and representation. Minor formatting issues, including the lack of spacing between the package and imports and a long constructor signature, slightly reduce readability.
Run 2
Code Structure: Logically organized into immutable fields, constructor, accessors, and a string representation override. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive class, field, and method names make the current-lag event's purpose clear; explicit null checks communicate required inputs. Code length: Concise, with no unnecessary implementation or repetition. Action granularity: Each statement performs a single clear action; the string concatenation remains straightforward. Reading flow: Natural top-to-bottom progression and consistent formatting support easy scanning. Minor drawbacks are the long constructor signature and the lack of visual separation between the package declaration and imports.
Run 3
Code Structure: Logically organized into fields, constructor, accessors, and a string representation override. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive class, field, and method names clearly convey an event for querying current lag; constructor null checks make required inputs explicit. Code length: Concise, with no unnecessary logic or duplication. Action granularity: Each statement performs a single clear action; the string concatenation remains straightforward. Reading flow: Natural progression from state definition to initialization and access. Minor formatting issues, including limited separation around imports and a long constructor signature, slightly reduce readability.