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. Structure is logical: class declaration, fields, constructor, getters, and toString override follow standard Java conventions. Nesting is absent. Intent is clear from the class name and method signatures; each method has a single, obvious purpose. Lines are concise, with one action per statement. Reading flow is natural, progressing from field declarations through construction to behavior. Null checks via Objects.requireNonNull enhance robustness without harming clarity.
Run 3
The code is highly readable. It follows a clear, logical structure with a single class extending a base event. Nesting is minimal and flat. The intent is unambiguous: represent a request for current lag with partition and isolation level. The code is concise, with no unnecessary lines. Each action (field initialization, getter return, toString construction) occupies its own line, maintaining clear action granularity. Reading flow is natural, moving from class declaration to fields, constructor, getters, and overridden method. The use of `Objects.requireNonNull` adds clarity about invariants. Overall, this is an exemplary small class.
Run 1
Code Structure: Logically organized into fields, constructor, accessors, and string representation. Nesting: Flat methods with no nested control flow. Clarity of intent: Descriptive class, field, and method names clearly convey the event's purpose; explicit null checks clarify required inputs. Code length: Concise, with little unnecessary code. Action granularity: Each statement performs a single clear action; the string concatenation remains easy to follow. Reading flow: Natural progression from state to initialization to access and representation. Minor formatting improvements, such as separating the package declaration from imports and wrapping the long constructor signature, would improve readability.
Run 2
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 retrieving current lag; explicit null checks establish required inputs. Code length: Concise, with little unnecessary boilerplate. Action granularity: Each statement performs one clear action, and the constructor cleanly separates initialization steps. Reading flow: Natural progression from state declaration to initialization and access. Minor formatting drawbacks include the lack of spacing between package and imports and long constructor and string-concatenation lines.
Run 3
Code Structure: Fields, constructor, accessors, and string representation are logically organized. Nesting: Entirely flat, with no nested control flow. Clarity of intent: Descriptive class and member names, explicit types, and null checks clearly communicate the event's purpose and requirements. Code length: Concise, with minimal boilerplate and no unnecessary logic. Action granularity: Each statement performs one clear action; the string concatenation remains easy to understand. Reading flow: Natural progression from state declaration to initialization and accessors. Minor formatting improvements, such as separating package and import declarations and wrapping the long constructor signature, would improve readability further.