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() {
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 highly readable with clear structure and intent. The class serves a single purpose as a backward-compatibility adapter, and the Javadoc explains its role well. Nesting is minimal, code length is appropriate, and each method performs one action. The only minor issue is the null check in next(), which could be considered a slight defensive redundancy depending on the iterator contract, but it doesn't significantly impact readability.
Run 2
The code is well-structured and easy to read, with a clear purpose described in the Javadoc. The class is focused, with each method delegating to the inner iterator or performing a single transformation. Nesting is minimal, using only a simple null check. The action granularity is appropriate: each method does one thing, and the 'next' method separates retrieval, null check, and conversion into distinct steps. Variable names are expressive ('innerIterator', 'keyValue'), and the overall flow is natural. The only slight weakness is the repeated generic type declarations, which add verbosity but are unavoidable in Java. Overall, the code is concise, maintainable, and clearly conveys its intent.
Run 3
The code is well-structured and follows the Adapter pattern cleanly. It has flat nesting with only one level of conditional logic in the next() method. The purpose is clearly documented with a Javadoc explaining the backward compatibility intent. Methods are concise and delegate appropriately to the inner iterator. Each action is on its own line, and the reading flow is natural—constructor, close, peek, hasNext, then next. The only minor deductions are the null-check in next() which slightly obscures intent (though common for iterator adapters) and the lack of validation for the inner iterator parameter. Overall, this is highly readable code that would be easily understood by most Java developers.
Run 1
Code Structure: A small, cohesive adapter cleanly separates construction, iterator delegation, and value conversion. Nesting: Only one shallow conditional, with an early return keeping the main path flat. Clarity of intent: Descriptive class and method names plus focused documentation explain the compatibility purpose; convertToHeaderFormat clearly communicates the transformation. Code length: Concise, with little unnecessary code and appropriate interface boilerplate. Action granularity: Each statement performs one clear operation; the final return naturally combines conversion and pair construction. Reading flow: Methods follow a straightforward sequence, and next() reads naturally from retrieval to null handling to conversion. Minor formatting improvements, such as blank lines separating the package declaration and import groups, would improve visual organization.
Run 2
Code Structure: A well-organized iterator adapter cleanly separates delegation from value conversion. Nesting: Minimal nesting, with a single guard clause keeping next() easy to follow. Clarity of intent: Descriptive class and method names, explicit types, and useful documentation clearly explain the compatibility purpose. Code length: Concise implementation with no unnecessary logic; delegation methods are appropriate boilerplate. Action granularity: Each statement performs one clear action, and the final return naturally combines conversion with result construction. Reading flow: Constructor, delegation methods, and conversion logic form a predictable sequence. Minor formatting improvements, such as blank lines separating the package declaration and import groups, would improve visual readability.
Run 3
Code Structure: A well-organized adapter with a single responsibility and clearly separated methods. Nesting: Almost entirely flat, with only a simple null-check guard. Clarity of intent: Descriptive class and field names, explicit delegation, and useful documentation explain the compatibility purpose and value conversion. Code length: Concise, with minimal boilerplate required by the iterator interface. Action granularity: Each statement performs one clear action; the final return naturally combines conversion with result construction. Reading flow: The constructor, delegated methods, and transforming next() method follow a coherent sequence. Minor formatting improvements, such as separating the package declaration and import groups with blank lines, would improve scanning.