Source code
package org.apache.kafka.streams.processor.internals;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.streams.processor.TaskId;
import java.util.Map;
import java.util.Set;
/**
* See {@link StoreChangelogReader}.
*/
public interface ChangelogReader extends ChangelogRegister {
/**
* Restore all registered state stores by reading from their changelogs
*
* @return the total number of records restored in this call
*/
long restore(final Map<TaskId, Task> tasks);
/**
* Transit to restore active changelogs mode
*/
void enforceRestoreActive();
/**
* Transit to update standby changelogs mode
*/
void transitToUpdateStandby();
/**
* @return true if the reader is in restoring active changelog mode;
* false if the reader is in updating standby changelog mode
*/
boolean isRestoringActive();
/**
* @return the changelog partitions that have been completed restoring
*/
Set<TopicPartition> completedChangelogs();
/**
* @return the logical changelog partitions end-offsets
*/
Map<TopicPartition, Long> logicalChangelogEndOffsets();
/**
* Returns whether all changelog partitions were completely read.
*
* Since changelog partitions for standby tasks are never completely read, this method will always return
* {@code false} if the changelog reader registered changelog partitions for standby tasks.
*
* @return {@code true} if all changelog partitions were completely read and no standby changelog partitions are read,
* {@code false} otherwise
*/
boolean allChangelogsCompleted();
/**
* Clear all partitions
*/
void clear();
/**
* @return whether the changelog reader has just been cleared or is uninitialized
*/
boolean isEmpty();
}
Run 1
This interface is highly readable. It follows a logical structure, grouping related methods (restore/completion, state transitions, status checks) cleanly. There is no nesting; the code is entirely flat. Each method's intent is clearly expressed through descriptive names and Javadoc comments, including nuanced behavior like standby changelogs never being fully read. The code is concise—no method implementations clutter the interface, and comments are informative without being verbose. Action granularity is excellent: each method declaration occupies one line within a clear signature. Reading flow is natural, starting with the primary restoration method, then mode transitions, status queries, and cleanup. The only minor deduction is the slight redundancy in some Javadoc, but it does not hinder readability. Overall, this is an exemplary public API interface in terms of clarity and maintainability.
Run 2
The code is highly readable due to its clear structure as a well-documented interface. Each method is concise, with a single clear action per declaration, and logical grouping of related functionality. Minimal nesting is present (only the package/import/interface structure), and the reading flow is natural, moving from restoration to state queries to cleanup. Javadoc comments effectively clarify intent, especially for methods with non-obvious behavior like allChangelogsCompleted(). Minor deduction only for slightly verbose documentation on some methods, but overall this is exemplary readability.
Run 3
The code is highly readable due to its clear structure as a well-documented interface. Each method has a Javadoc comment explaining its purpose, contributing to strong clarity of intent. The organization is logical, following a natural grouping of lifecycle methods and queries. Nesting is nonexistent, and the code is concise—no method body introduces unnecessary complexity. Reading flow is natural, with method names like 'enforceRestoreActive' and 'isRestoringActive' conveying action and state. Minor deductions: the interface references types like Task and ChangelogRegister without showing their definitions, but this is typical for an interface. Overall, it is an exemplary model of clean, maintainable code.
Run 1
Code Structure: The interface is logically organized, grouping restoration controls, status queries, and lifecycle operations. Nesting: Completely flat, with no nested control flow. Clarity of intent: Descriptive method names, explicit types, and Javadocs make the contract clear, though 'Transit' is awkward wording and logical end-offset semantics could be explained better. Code length: Concise declarations with mostly useful documentation; the completion-method comment is somewhat repetitive. Action granularity: Each declaration occupies its own line and represents a single operation or query. Reading flow: Consistent spacing and documentation support natural scanning, although separating the package declaration and import groups would improve formatting.
Run 2
Code Structure: A focused interface logically groups restoration, mode switching, completion queries, and cleanup. Nesting: No nested control flow; declarations are flat and easy to scan. Clarity of intent: Descriptive method names, explicit types, and Javadoc make responsibilities clear, though 'Transit' wording is awkward and the meaning of logical end-offsets could be explained better. Code length: Concise declarations with proportionate documentation; the completion-method comment is longer but explains an important standby-task caveat. Action granularity: Each method declaration occupies its own line and represents a distinct operation. Reading flow: Consistent formatting and documentation support natural reading, although separating the package and import sections with blank lines and grouping imports consistently would improve presentation.
Run 3
Code Structure: A well-organized interface groups related changelog restoration, mode switching, status queries, and cleanup operations. Nesting: Flat declarations with no nested control flow make scanning effortless. Clarity of intent: Descriptive method names, precise return types, and Javadocs clearly communicate most contracts; wording such as 'Transit' and 'logical changelog partitions end-offsets' is slightly awkward. Code length: Concise signatures avoid unnecessary implementation detail, though some documentation repeats method names. Action granularity: Each declaration expresses one operation, with no crowded statements. Reading flow: Methods progress naturally from restoration to mode management, completion queries, and cleanup. Missing whitespace between the package declaration and imports, and between import groups, slightly reduces visual polish.