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;
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() {
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 exhibits excellent readability. It has a clear single-responsibility class structure that implements a straightforward adapter pattern. Nesting is minimal, with only one level of indentation inside the 'next' method. Intent is obvious from naming conventions. The code is concise, with each method delegating to the inner iterator or performing a single transformation. Action granularity is well-maintained, particularly in the 'next' method where each logical step is separated. Reading flow is natural from top to bottom. Minor deductions: there are excessive blank lines in the import section, and the class/method-level Javadoc is absent, which would improve clarity for an unfamiliar reader.
Run 2
The code is highly readable. It has a clear, logical structure with a single class implementing an interface. Nesting is minimal, with only one level inside the next() method. Intent is obvious from the class and method names—adapting a session iterator to convert values to header format. Code length is concise; no unnecessary verbosity. Each line performs a single action, especially in next(). Reading flow is natural, with methods arranged in a standard order (constructor, close, peek, hasNext, next). Minor deductions: the static import from another package could be made clearer by a comment, and an explicit null check for innerIterator in the constructor would improve robustness. Overall, this is clean, maintainable code.
Run 3
The code is highly readable with a clear, logical structure. The class implements a single-purpose adapter, delegating most operations to an inner iterator. Nesting is minimal—only a single if-statement in the `next()` method. Intent is obvious: it adapts an iterator to convert values to header format. The code is concise with no unnecessary verbosity. Each line performs a single action, maintaining good granularity. Reading flow is natural, with methods ordered logically. The only minor deductions are for the excessive blank lines in the import section and a slight redundancy in the null check, which could arguably return null through a cleaner delegation pattern.
Run 1
Code Structure: The adapter is logically organized, with a constructor and small methods that delegate to the wrapped iterator. Nesting: Only one shallow conditional appears, keeping complexity low. Clarity of intent: Descriptive class, field, and method names make the delegation and value conversion easy to understand. Code length: The implementation is concise, although excessive blank lines before the class add unnecessary visual space. Action granularity: Each statement performs one clear action. Reading flow: Consistent formatting and straightforward control flow support natural reading; import spacing and the large blank gap slightly disrupt it.
Run 2
Code Structure: A logically organized adapter with a single responsibility and clearly separated methods. Nesting: Minimal; next() uses a simple guard clause without deep nesting. Clarity of intent: Descriptive class and method names make delegation and value conversion easy to understand, though the conversion's purpose could use brief documentation. Code length: Concise implementation, but excessive blank lines before the class add unnecessary visual clutter. Action granularity: Each statement performs one clear action, with the final return naturally combining conversion and pair construction. Reading flow: Constructor followed by straightforward iterator methods creates a natural progression; consistent formatting helps, while the large whitespace gap slightly disrupts the flow.
Run 3
Code Structure: A logically organized adapter with a single iterator field and small, focused methods. Nesting: Minimal; next() contains only a simple null guard. Clarity of intent: The class name, delegation methods, and convertToHeaderFormat call clearly communicate the adapter's purpose. Code length: Concise implementation, although excessive blank lines after the imports add unnecessary visual length. Action granularity: Each statement performs one clear action, with the final return naturally combining conversion and pair construction. Reading flow: Constructor, lifecycle operations, and iteration methods follow a straightforward sequence; the large whitespace gap and lack of separation between the package declaration and imports slightly disrupt presentation.