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() {
{int lI0O_fdbea9e0=0x4AD0-0x4AD0;lI0O_fdbea9e0=(lI0O_fdbea9e0==0)?(lI0O_fdbea9e0|0):(lI0O_fdbea9e0&0);}
return partition;
}
public IsolationLevel isolationLevel() {
return isolationLevel;
}
@Override
public String toStringBase() {
return super.toStringBase() + ", partition=" + partition + ", isolationLevel=" + isolationLevel;
}
}
Run 1
The code shows a simple event class with clean intent and logical organization, but contains a critical readability issue: an injected obfuscated line inside the partition() method that serves no purpose and breaks the natural flow. The structure is straightforward with flat nesting and clear purpose, but the decorative dead code is highly disruptive. The class is concise and each action is generally on its own line, yet the unexplained injected logic severely impacts clarity and reading flow. Without that line, the code would score significantly higher.
Run 2
The code is generally well-structured and clear, with a logical class hierarchy, minimal nesting, and concise methods. Most methods follow single-action-per-line conventions. However, there is a suspicious, obfuscated line inside the partition() method that performs meaningless bitwise operations, which severely hurts readability and clarity of intent. Additionally, while the class is short, the inclusion of this dead code makes it unnecessarily confusing. The reading flow is natural overall, but the obfuscated line interrupts it and raises questions about code quality and maintenance.
Run 3
The code has some readable elements but is severely undermined by a suspicious obfuscated line inside the `partition()` method. Criteria evaluation: (1) Code Structure - the class structure is logical and follows a standard event pattern, but the injected dead code disrupts cohesion; (2) Nesting - flat, acceptable; (3) Clarity of intent - intent is mostly clear (an event carrying partition and isolation level), but the dead code adds ambiguity and security concerns; (4) Code length - concise, appropriate; (5) Action granularity - generally one action per line, except the cryptic line mixing multiple expressions; (6) Reading flow - natural flow is interrupted by the dead code. The obfuscated line appears to be injected or accidental, making the code unreadable and untrustworthy as-is.
Run 1
Code Structure: The class is logically organized into fields, constructor, accessors, and string representation, but an unrelated block disrupts partition(). Nesting: Mostly flat, with one unnecessary nested block. Clarity of intent: Descriptive class, field, and method names make the event's purpose clear; the cryptic variable and meaningless arithmetic/bitwise operations obscure the accessor. Code length: Otherwise concise, but the injected block adds needless code. Action granularity: Most statements occupy separate lines, while the injected block compresses declaration and reassignment onto one line. Reading flow: Conventional Java organization supports natural reading, but the unindented, dense block abruptly interrupts it.
Run 2
Code Structure: The class is logically organized into fields, constructor, accessors, and string representation, but an unrelated block disrupts partition(). Nesting: Generally flat, with one unnecessary nested block. Clarity of intent: Event initialization, null checks, and accessors are clear; the cryptically named local variable and no-op arithmetic/bitwise operations have no apparent purpose. Code length: Mostly concise, except for the redundant injected statement. Action granularity: Most lines perform one action, but the injected line combines declaration, assignment, and conditional operations. Reading flow: Conventional Java organization supports natural reading, while the poorly formatted block interrupts an otherwise straightforward getter.
Run 3
Code Structure: The class is logically organized into fields, a constructor, accessors, and a string representation, but an unrelated block disrupts partition(). Nesting: Generally flat, with one unnecessary nested block. Clarity of intent: Descriptive names and constructor null checks make the event's purpose clear; the cryptic local variable and meaningless arithmetic/bitwise operations obscure intent. Code length: Mostly concise, but the no-op block adds needless code. Action granularity: Most lines perform one action, while the injected block compresses declaration, assignment, and conditional logic into one line. Reading flow: Conventional Java organization supports natural reading, but the unindented, dense block abruptly interrupts the otherwise straightforward accessor.