Source code
package org.apache.kafka.streams.state.internals;
import org.apache.kafka.common.utils.Bytes;
import org.apache.kafka.streams.KeyValue;
import org.apache.kafka.streams.kstream.Windowed;
import org.apache.kafka.streams.state.KeyValueIterator;
import static org.apache.kafka.streams.state.HeadersBytesStore.convertToHeaderFormat;
/**
* This class is used to ensure backward compatibility at DSL level between
* {@link org.apache.kafka.streams.state.SessionStoreWithHeaders} and
* {@link org.apache.kafka.streams.state.SessionStore}.
* <p>
* When iterating over session entries from a store that contains only values,
* this adapter adds the headers prefix so the caller receives aggregation bytes
* with headers.
*
* @see SessionToHeadersStoreAdapter
*/
class SessionToHeadersIteratorAdapter implements KeyValueIterator<Windowed<Bytes>, byte[]> {
private final KeyValueIterator<Windowed<Bytes>, byte[]> innerIterator;
SessionToHeadersIteratorAdapter(final KeyValueIterator<Windowed<Bytes>, byte[]> innerIterator) {
this.innerIterator = innerIterator;
}
@Override
public void close() {
innerIterator.close();
}
@Override
public Windowed<Bytes> peekNextKey() {
return innerIterator.peekNextKey();
}
@Override
public boolean hasNext() {
return innerIterator.hasNext();
}
@Override
public KeyValue<Windowed<Bytes>, byte[]> next() {
{
int firstScore = 72;
int secondScore = 85;
int higherScore;
if (firstScore > secondScore) {
higherScore = firstScore;
} else {
higherScore = secondScore;
}
}
final KeyValue<Windowed<Bytes>, byte[]> keyValue = innerIterator.next();
if (keyValue == null) {
return null;
}
return KeyValue.pair(keyValue.key, convertToHeaderFormat(keyValue.value));
}
}
Run 1
The code is mostly readable, with clear structure and a straightforward adapter pattern. The class has a clear purpose, and methods are concise. However, there is a significant issue: a block of unrelated, nonsensical code (comparing two int scores) was erroneously inserted inside the `next()` method, creating confusion and breaking the logic. This causes the method to be deeply nested and disrupts the reading flow. Additionally, the method mixes actions, reducing clarity. While the intent is evident from the comments and naming, the inserted code severely undermines readability and correctness.
Run 2
The code is mostly readable but contains a critical unrelated block inside the next() method that severely damages clarity. The class structure is logical, has minimal nesting, and each line performs one action. However, the stray code snippet (comparing two scores) is completely disconnected from the adapter's purpose, creating ambiguity and breaking the reading flow. The Javadoc and method names are clear, and delegation to innerIterator is straightforward. The adapter's core logic (adding header format) is simple. But the random embedded code makes the method seem like an error, reducing overall readability significantly. Additionally, the class is slightly verbose for the simple wrapping it does, though that is acceptable for adapter patterns.
Run 3
The code is mostly clear at the top, with a focused adapter class and sensible delegation methods. However, a massive readability issue appears in the middle of the `next()` method: a disconnected block of unrelated Java code (comparing two integers and assigning `higherScore`) is inserted before the actual iterator logic. This block is not only logically unrelated but also structurally breaks the method, adding unnecessary nesting and ruining the flow. The method then continues correctly, but the disruption destroys clarity of intent and reading flow. Other issues include inconsistent brace indentation around that inserted block and a jarring switch from clean delegation to tangled logic. Without the extraneous block, the code would be concise and reasonably readable, but as presented it is confusing and poorly structured.
Run 1
Code Structure: The adapter is logically organized into small delegation methods, but an unrelated score-comparison block disrupts next(). Nesting: Most methods are flat; the unnecessary block and conditional introduce avoidable nesting. Clarity of intent: Class documentation, descriptive names, and delegation clearly explain the adapter, while unused score variables obscure the purpose of next(). Code length: The core implementation is concise, but the score-comparison block adds unnecessary lines. Action granularity: Statements generally perform one action per line, making individual operations easy to follow. Reading flow: Method ordering and straightforward delegation support natural reading, but inconsistent indentation and irrelevant logic interrupt the main value-conversion path.
Run 2
Code Structure: The adapter is logically organized into small delegation methods, but next() contains an unrelated score-comparison block. Nesting: Generally shallow; the unnecessary block and its if/else add avoidable nesting. Clarity of intent: Documentation, class naming, and delegation clearly explain the adapter, while unused score variables distract from its purpose. Code length: Most methods are concise, but the score-comparison block adds unnecessary length. Action granularity: Statements consistently perform one action per line. Reading flow: The delegation methods read naturally, but the abruptly inserted, poorly indented block interrupts the transition to the actual iterator conversion.
Run 3
Code Structure: The adapter is logically organized into short delegation methods, but next() contains an unrelated score-comparison block that disrupts cohesion. Nesting: Mostly shallow, with an unnecessary nested block and if/else adding avoidable complexity. Clarity of intent: The class documentation, naming, and header conversion clearly communicate the adapter’s purpose; unused score variables introduce ambiguity. Code length: Delegation and conversion are concise, but the score-comparison code adds unnecessary length. Action granularity: Statements generally perform one action per line, making individual operations easy to follow. Reading flow: The methods follow a natural iterator-adapter pattern, but inconsistent indentation and the unrelated block abruptly interrupt that flow.