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 highly readable due to its clear structure and delegation pattern. Each method performs a single, well-defined action, maintaining flat nesting and concise logic. The class and method names clearly communicate intent, and the Javadoc explains the adapter’s purpose. The `next()` method introduces a minimal null check without adding unnecessary complexity. Imports are specific, and the overall flow is natural and easy to follow.
Run 3
The code is highly readable. It has a clear, single-purpose class with a concise Javadoc explaining its backward-compatibility role. The structure is logical, following a standard adapter pattern. Nesting is minimal, with only one level inside the `next()` method. Intent is obvious from the class and method naming. The code is concise without being overly compact. Action granularity is appropriate, with one operation per line. The reading flow is natural, progressing from field declaration to constructor and then method implementations. The null check and conversion logic are straightforward. Minor deductions could be for the somewhat verbose generic type declarations, which are necessary but add visual noise.
Run 1
Code Structure: A focused adapter class cleanly separates construction, delegation, and value conversion. Nesting: Methods are flat, with only a single null-check branch in next(). Clarity of intent: Descriptive names and class documentation clearly explain the backward-compatibility purpose and header conversion. Code length: The implementation is concise; delegation methods contain no unnecessary logic. Action granularity: Each statement performs a distinct action, and the final expression combines closely related conversion and result construction naturally. Reading flow: Fields, constructor, and overridden methods follow a conventional order, making the class easy to scan. Minor formatting improvements, such as blank lines around the package declaration and static import group, would improve visual organization.
Run 2
Code Structure: A well-organized iterator adapter with a single responsibility and clearly separated methods. Nesting: Minimal; the only conditional is a straightforward null guard. Clarity of intent: Descriptive names and class documentation explain the compatibility purpose and value 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 progression. Minor formatting improvements, such as spacing between the package declaration and imports and separating the static import, would make the opening easier to scan.
Run 3
Code Structure: A well-organized adapter with a single responsibility and clearly separated iterator methods. Nesting: Minimal; the only conditional is a straightforward null guard. Clarity of intent: Descriptive class and field names, explanatory Javadoc, and explicit delegation make the purpose clear. Code length: Concise, with only necessary interface implementations and conversion logic. Action granularity: Each statement performs one clear action; the final return naturally combines conversion and pair construction. Reading flow: Documentation, field, constructor, and methods follow a conventional order, with the transformation isolated in next(). Minor formatting improvements, such as blank lines around the package and import groups, would improve readability further.