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 well-structured, using a simple class that clearly extends a base event type. Fields are final and properly validated with null checks, ensuring immutability. Nesting is minimal, and the methods are flat and concise. Intent is clear: the class represents a current lag event with partition and isolation level information. Code length is appropriate—no unnecessary boilerplate. Action granularity is good, with one logical action per line. Reading flow is natural, with a clear progression from package and imports to class definition, fields, constructor, accessors, and toString. Minor deductions: the class lacks a default no-argument constructor (though likely intentional), and the import order is slightly non-standard (non-alphabetical grouping). Overall, it is highly readable and maintainable.
Run 3
The code is highly readable due to its clear structure, minimal nesting, and concise implementation. It follows a logical organization: package declaration, imports, class definition, fields, constructor, accessor methods, and a toString override. The nesting is flat with no conditional blocks or deep indentation. Intent is immediately clear—modeling a current lag event with a partition and isolation level. The code length is minimal and appropriate for the functionality. Each line performs a single logical action, such as super constructor invocation, null checks, or field assignment. The reading flow is natural, moving from fields to constructor to getters to string representation. The only minor deduction is that the class lacks Javadoc comments describing the event's purpose or usage context, which would slightly improve clarity for external readers.
Run 1
Code Structure: Logically organized into immutable fields, constructor, accessors, and string representation. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive class, field, and method names clearly communicate an event for querying current lag; constructor null checks make requirements explicit. Code length: Concise, with minimal boilerplate and no unnecessary logic. Action granularity: Each statement performs one clear action; the string concatenation forms a single coherent representation. Reading flow: Natural progression from state initialization to access and representation. Minor formatting improvements, such as separating the package declaration from imports and wrapping the long constructor signature, would improve scanning.
Run 2
Code Structure: Fields, constructor, accessors, and string representation are logically organized. Nesting: Entirely flat, with no nested control flow. Clarity of intent: Descriptive class, field, and method names clearly communicate the event's purpose; constructor null checks make required inputs explicit. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs one clear action; the string concatenation remains straightforward. Reading flow: Natural progression from state definition to initialization and accessors, followed by diagnostic output. Minor formatting issues, including tightly grouped package/import declarations and a long constructor signature, slightly reduce readability.
Run 3
Code Structure: Fields, constructor, accessors, and string representation are logically organized. Nesting: Methods are flat, with no nested control flow. Clarity of intent: Descriptive class, field, and method names clearly convey an event for obtaining current lag; constructor null checks make requirements explicit. Code length: The class is concise, with no unnecessary logic or duplication. Action granularity: Each statement performs a focused action; the string concatenation remains easy to follow. Reading flow: The progression from state definition to initialization, access, and representation is natural. Minor formatting issues, including the long constructor signature and lack of separation between package and imports, slightly reduce readability.