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 interface is highly readable, with clear method names and Javadoc comments explaining intent. Structure is logical and flat, with no nested code. Each method is concise and performs a single logical action. The import statements and package declaration follow standard conventions. Minor deductions for slightly verbose comments and lack of blank lines between methods, but overall the code is well-organized and easy to understand.
Run 3
The code is an interface with a clear, single-purpose contract. Each method is documented with Javadoc comments that explain intent, parameters, and return values. The structure is logical and straightforward—no complex nesting, no ambiguous names, and no redundant code. The reading flow is natural, with related methods grouped and comments enhancing understanding. The code is concise, with each method doing exactly what its name suggests. Only minor improvement could be adding a brief class-level explanation of the relationship between methods, but overall it is highly readable.
Run 1
Code Structure: The interface is logically organized, grouping restoration controls, status queries, and cleanup methods. Nesting: Flat declarations with no nested control flow make scanning easy. Clarity of intent: Descriptive method names, explicit return types, and Javadoc communicate responsibilities well; awkward wording such as “Transit to” and the unexplained “logical” end-offsets slightly reduce precision. Code length: Concise for the exposed API, though the allChangelogsCompleted documentation repeats its condition. Action granularity: Each method declaration occupies its own line and represents a distinct operation. Reading flow: Consistent spacing and documentation support a natural top-to-bottom reading order, although separating the package declaration and import groups with blank lines would improve presentation.
Run 2
Code Structure: A well-organized interface groups related changelog restoration operations, queries, and lifecycle methods. Nesting: No nested logic; all declarations are flat. Clarity of intent: Descriptive method names, explicit types, and Javadoc make responsibilities clear, though wording such as 'Transit' and 'logical changelog partitions end-offsets' could be improved. Code length: Concise declarations with proportionate documentation; the longer completion comment explains an important standby-task caveat. Action granularity: Each declaration occupies its own line and represents a single operation or query. Reading flow: Consistent spacing and documentation support natural scanning from restoration controls to status checks and cleanup. Minor drawbacks include the lack of separation between package and imports and inconsistent naming between enforceRestoreActive and transitToUpdateStandby.
Run 3
Code Structure: A well-organized interface groups restoration, mode transitions, progress queries, and lifecycle operations logically. Nesting: Flat method declarations impose no nesting burden. Clarity of intent: Descriptive names, explicit types, and Javadoc communicate responsibilities clearly, though phrases such as 'Transit to' and 'logical changelog partitions end-offsets' could be more precise. Code length: Concise declarations with proportionate documentation; the longer completion comment usefully explains standby behavior. Action granularity: Each declaration represents one operation, with no compound statements. Reading flow: Consistent formatting and documentation support natural scanning, although separating package and import sections with blank lines would improve presentation.