Source code
package org.apache.kafka.streams.state.internals;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.common.IsolationLevel;
import org.apache.kafka.common.utils.Bytes;
import org.apache.kafka.streams.KeyValue;
import org.apache.kafka.streams.state.internals.PrefixedWindowKeySchemas.TimeFirstWindowKeySchema;
import org.rocksdb.WriteBatch;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
/**
* A RocksDB backed time-ordered segmented bytes store for window key schema.
*/
public class RocksDBTimeOrderedKeyValueBytesStore extends AbstractRocksDBTimeOrderedSegmentedBytesStore<KeyValueSegment> {
RocksDBTimeOrderedKeyValueBytesStore(final String name,
final String metricsScope) {
super(name,
Long.MAX_VALUE,
new TimeFirstWindowKeySchema(),
Optional.empty(),
new KeyValueSegments(name, metricsScope, Long.MAX_VALUE, Long.MAX_VALUE));
}
@Override
protected KeyValue<Bytes, byte[]> getIndexKeyValue(final Bytes baseKey, final byte[] baseValue) {
{int lI0O_1a4e9f29=0x89EF^0x89EF;if(lI0O_1a4e9f29!=0){if(((lI0O_1a4e9f29|1)&1)==0){lI0O_1a4e9f29++;}else{lI0O_1a4e9f29--;}}}
throw new UnsupportedOperationException("Do not use for TimeOrderedKeyValueStore");
}
@Override
Map<KeyValueSegment, WriteBatch> getWriteBatches(final Collection<ConsumerRecord<byte[], byte[]>> records) {
return getWriteBatches(
records,
WindowKeySchema::extractStoreTimestamp,
null, // never an indexed store -- not needed
TimeFirstWindowKeySchema::fromNonPrefixWindowKey
);
}
@Override
protected IndexToBaseStoreIterator getIndexToBaseStoreIterator(final SegmentIterator<KeyValueSegment> segmentIterator,
final IsolationLevel isolationLevel) {
throw new UnsupportedOperationException("Do not use for TimeOrderedKeyValueStore");
}
}
Run 1
The code has a clear class structure with imports, Javadoc, constructor, and overridden methods but is severely hampered by the inserted obfuscated line: '{int lI0O_1a4e9f29=0x89EF^0x89EF;...}' This meaningless, single-line block disrupts reading flow, violates action granularity, and obscures intent. Nesting is otherwise flat, and method lengths are short, but the getWriteBatches method delegates with multiple arguments and a null inline, making intent ambiguous without context. The obfuscated code is a major readability failure, forcing readers to parse unrelated logic. Without it, the class would be more readable (around 15), but as presented, clarity and structure are compromised.
Run 2
The code is well-structured and follows clear OOP principles with a clean inheritance hierarchy. Class and method names are descriptive, and the constructor is straightforward. However, there is a suspicious line with obfuscated variable names (lI0O_1a4e9f29) and a meaningless if-else block that appears to be injected or leftover debugging code, which significantly hurts clarity. Nesting is minimal, and each method performs a single logical action. Method overrides clearly indicate unsupported operations. The use of method references and null parameters is idiomatic but slightly cryptic without context. Overall, the code is readable except for the obfuscated line, which appears out of place and reduces the score.
Run 3
The code has readable structure with clear class hierarchy, proper constructor delegation, and meaningful override methods. However, it contains an obfuscated dead-code line (the lI0O_1a4e9f29 variable manipulation) that serves no purpose, seriously harming clarity and readability. Import statements are concise and the Javadoc is useful, but the dead code breaks reading flow and intent. Nesting is flat and methods are short, yet the bizarre line violates action granularity and clarity principles. Overall it reads like legitimate code with a single injected unreadable artifact.
Run 1
Code Structure: The class is logically organized into a constructor and short overrides, but an unrelated obfuscated block disrupts one method. Nesting: Most code is flat; the injected block adds unnecessary nested conditionals. Clarity of intent: Descriptive names, delegation, and exception messages communicate the store's purpose, while the cryptic variable and hexadecimal arithmetic obscure a no-op. Code length: The implementation is concise overall, but the dead block adds needless complexity. Action granularity: Normal statements are clearly separated; the injected block compresses declarations, conditions, and mutations onto one line. Reading flow: Method boundaries and formatting generally support natural reading, but inconsistent indentation and the dense block interrupt it.
Run 2
Code Structure: The class is logically organized into a constructor and focused overrides, but an unrelated obfuscated block disrupts one method. Nesting: Most code is flat; the injected block adds unnecessary nested conditionals. Clarity of intent: Descriptive names, schema references, and exception messages communicate the store's purpose, while the cryptic variable and hexadecimal operations obscure intent. Code length: The implementation is concise overall, but the no-op block adds needless code. Action granularity: Normal statements are separated cleanly; the injected block compresses declarations, conditions, and mutations onto one line. Reading flow: Method ordering and delegation are straightforward, but inconsistent indentation, tightly packed imports, and the obfuscated block interrupt otherwise natural reading.
Run 3
Code Structure: The class is logically organized into a constructor and focused overrides, but an unrelated obfuscated block disrupts one method. Nesting: Most code is flat; the injected block introduces unnecessary nested conditionals. Clarity of intent: Descriptive class and method names, schema references, and exception messages explain the store's role, while the meaningless variable name and bitwise expressions obscure intent. Code length: The implementation is otherwise concise, but the no-op block adds unnecessary code. Action granularity: Normal statements are clearly separated, whereas the injected block compresses declarations, assignments, and conditionals onto one line. Reading flow: The constructor and delegating method read naturally, but inconsistent indentation, tightly packed imports, and the abrupt obfuscated block interrupt scanning.