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 highly readable. It clearly implements the KeyValueIterator interface with a clean adapter pattern. The class has a focused responsibility (adding header format during iteration), which is evident from the concise Javadoc. Methods are flat and each performs a single, clearly defined action, maintaining excellent action granularity. The reading flow is natural — methods are logically ordered and straightforward. Nesting is minimal, limited to a single null check. The one-line null check within next() slightly impacts code length but is acceptable given its simplicity. Naming conventions are strong, with clear parameter names like innerIterator. Imports are properly organized. Overall, the code balances conciseness with clarity, uses appropriate delegation, and maintains a clean structure with no unnecessary complexity.
Run 3
The code demonstrates excellent readability through clear structure and intent. It follows a simple adapter pattern with a single responsibility, delegating to an inner iterator and transforming values. Nesting is minimal with only one conditional check. Each method performs a single action, and the class has appropriate documentation explaining its purpose. The code is concise without being cryptic, and the reading flow is natural - constructor, then simple delegating methods, then the transformation method. Variable and method names are self-explanatory. The only minor deductions are for the null check in next() which could be slightly more explicit, and the lack of @Override annotations on some methods that implement interface methods (though this is a minor style concern).
Run 1
Code Structure: A focused adapter class cleanly separates construction, iterator delegation, and value conversion. Nesting: Methods are flat, with only a simple null guard in next(). Clarity of intent: Descriptive class and method names, a clear Javadoc explanation, and convertToHeaderFormat make the compatibility purpose explicit. Code length: Concise, with minimal delegation boilerplate and no unnecessary logic. Action granularity: Each statement performs a distinct action; the final return combines conversion and pair creation without becoming difficult to follow. Reading flow: The code progresses naturally from initialization through iterator operations to the adapted next() behavior. Minor formatting improvements, such as separating the package declaration and import groups with blank lines, would improve scanability.
Run 2
Code Structure: A well-organized iterator adapter cleanly separates delegation from value conversion. Nesting: Minimal nesting, with a single guard clause in next(). Clarity of intent: Descriptive names and class documentation clearly explain the compatibility purpose and headers conversion. Code length: Concise; delegation methods are necessary rather than redundant clutter. Action granularity: Each statement performs one clear action, with the final return naturally combining conversion and pair construction. Reading flow: Constructor, delegation methods, and conversion logic follow a straightforward progression. Minor formatting improvements, such as blank lines between the package declaration and import groups, would improve visual separation.
Run 3
Code Structure: A well-organized iterator adapter separates delegation from value conversion into small methods. Nesting: Nearly flat, with only a simple null-check guard in next(). Clarity of intent: Descriptive class and variable names, explicit interface implementation, and useful documentation clearly explain the compatibility purpose. 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: Documentation, field, constructor, and iterator methods follow a natural progression. Minor readability improvements would include blank lines separating the package declaration, regular imports, and static import.