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 due to its clear structure, minimal nesting, and explicit purpose. The class adapter pattern is straightforward: wrapping an existing iterator and transforming values. Each method has a single responsibility and follows a natural delegation flow. Nesting is minimal, with only one conditional check in the `next()` method. The use of final fields and parameters enhances clarity. Naming is precise and communicates intent well. The Javadoc provides helpful context. The only minor drawbacks are the fully qualified types in the class signature, which could be simplified with imports, and the lack of import for the static method is already handled. Overall, the code is concise, logical, and easy to follow.
Run 2
The code is highly readable with clear separation of concerns, flat structure, and concise methods that delegate to an inner iterator. Each method has a single responsibility, and the adapter’s purpose is documented with a class-level comment. The one conditional in `next()` is straightforward and necessary. Flow is natural and easy to follow; no deep nesting or ambiguous intent is present. Minor nitpicks include the slightly long generic type declarations, but they are not detrimental to readability.
Run 3
The code is highly readable due to its clear, logical structure and flat nesting. The class implements a single-purpose adapter with a well-documented reason for existence. Each method is concise, delegating to an inner iterator, and follows the expected iterator pattern with clear intent. The `next()` method has minimal nesting and performs one logical action per line except for the straightforward null check. The import list is minimal and specific. The only minor deductions are the import of a static method which slightly obscures its origin, and the `next()` method contains a couple of actions in a short method but remains perfectly clear. Overall, the code is easy to follow, well-structured, and maintainable.
Run 1
Code Structure: A focused adapter class cleanly separates constructor, delegation methods, and value conversion. Nesting: Minimal nesting, with a single null guard and early return. Clarity of intent: Descriptive names and class documentation clearly explain the backward-compatibility purpose and header conversion. Code length: Concise; delegation boilerplate is necessary to implement the iterator interface. Action granularity: Each statement performs a single clear action, and retrieval is separated from conversion. Reading flow: Methods follow a natural progression, with the distinctive conversion behavior isolated in next(). Minor formatting improvements, such as separating the package declaration and import groups with blank lines, would improve visual organization.
Run 2
Code Structure: A well-organized adapter with a single responsibility and clearly separated iterator methods. Nesting: Minimal; the only conditional uses an early return. Clarity of intent: The class name, descriptive field name, and documentation explain the compatibility purpose and value transformation. Code length: Concise, with necessary delegation methods and no unnecessary logic. Action granularity: Each statement performs one clear action; the final return naturally combines conversion with pair construction. Reading flow: Constructor, delegation methods, and transformation logic follow a predictable progression. Minor formatting improvements, such as separating the package declaration and import groups with blank lines, would improve visual readability.
Run 3
Code Structure: A well-organized adapter with a single responsibility and clearly separated iterator methods. Nesting: Minimal nesting; the null guard keeps next() straightforward. Clarity of intent: Descriptive class and field names, explicit delegation, and helpful Javadoc explain the compatibility conversion. Code length: Concise, with only necessary delegation and transformation logic. Action granularity: Each statement performs one clear action; the final return naturally combines conversion with pair construction. Reading flow: Documentation, field, constructor, and iterator methods follow a logical sequence. Minor formatting improvements, such as separating the package declaration and import groups with blank lines, would improve visual readability.