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 has clear intent and is logically organized, but readability is significantly reduced by inconsistent formatting and multiple statements on single lines. The class declaration, constructor, method signatures, and several method bodies are compressed onto single lines, violating action granularity and disrupting reading flow. Nesting is minimal and code length is concise, but the formatting makes the structure harder to parse quickly. Standard Java conventions (line breaks between fields, methods, and braces) are not followed consistently.
Run 2
The code is functional but poorly formatted and structured. It has severe readability issues: multiple statements and method declarations are crammed onto single lines, making it difficult to scan. The class-level structure is reasonable, but the formatting destroys clarity. There is minimal nesting, which is good, but the lack of line breaks negates that benefit. The intent is somewhat clear from the Javadoc, but the implementation is hard to follow due to compressed lines. The code length is concise, but this is achieved at the expense of readability. Action granularity is poor—multiple actions per line (e.g., field declaration and constructor body on one line). Reading flow is disorganized and unnatural, forcing the reader to mentally parse dense lines. Overall, the code is technically correct but reads like minified source, not production-grade code.
Run 3
The code is functionally simple but poorly formatted. Multiple methods and fields are crammed onto single lines, which severely hurts readability. The class structure is logical, but the lack of indentation and line breaks makes it look tangled. Nesting is minimal (one if statement), which is good. Intent is somewhat clear from the Javadoc and class name, but the formatting obscures it. Code length is concise, but this conciseness comes at the cost of readability. Many lines contain multiple actions or declarations, violating the 'one action per line' principle. Reading flow is disorganized because the eye must parse dense, multi-statement lines. Overall, while the logic itself is straightforward, the poor formatting makes it much less readable than it could be.
Run 1
Code Structure: The adapter has a logical organization, with a wrapped iterator and straightforward delegation, but compressed declarations and method boundaries obscure that structure. Nesting: Minimal nesting; only a simple null check appears in next(). Clarity of intent: Descriptive names and useful class documentation clearly explain the compatibility purpose and value conversion. Code length: Appropriately concise, without unnecessary logic. Action granularity: Several imports, declarations, annotations, and method statements share lines, making individual operations harder to distinguish. Reading flow: Inconsistent line breaks and closing braces disrupt scanning, particularly between delegated methods. The underlying implementation is easy to understand, but poor formatting significantly reduces readability.
Run 2
Code Structure: A coherent iterator adapter with straightforward delegation, but compressed declarations and method boundaries obscure its organization. Nesting: Very shallow, with only one simple null check. Clarity of intent: The class documentation, descriptive names, and explicit conversion clearly explain its compatibility purpose. Code length: Concise, with little unnecessary logic. Action granularity: Several imports, declarations, annotations, and method statements share lines, reducing visual separation despite simple individual operations. Reading flow: Inconsistent line breaks and closing braces interrupt scanning and make method transitions harder to follow. Overall, the logic is easy to understand, but poor formatting substantially reduces readability.
Run 3
Code Structure: The adapter logically groups iterator delegation and value conversion, but compressed declarations and method boundaries obscure that organization. Nesting: Minimal nesting, with only a simple null check, makes control flow easy to understand. Clarity of intent: Descriptive class and variable names, explicit delegation, and helpful documentation clearly explain the compatibility purpose. Code length: The implementation is appropriately concise without unnecessary logic. Action granularity: Multiple imports, declarations, annotations, and method boundaries share lines, reducing visual separation despite generally simple statements. Reading flow: Inconsistent line breaks and cramped formatting interrupt an otherwise straightforward progression through iterator methods. Standard formatting would substantially improve readability.