Source code
package com.google.common.collect;
import com.google.common.annotations.GwtCompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.DoNotMock;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.jspecify.annotations.Nullable;
@DoNotMock("Use Iterators.peekingIterator")
@GwtCompatible
public interface PeekingIterator<E extends @Nullable Object> extends Iterator<E> {
@ParametricNullness
E peek();
@CanIgnoreReturnValue
@Override
@ParametricNullness
E next();
@Override
void remove();
}
Run 1
The code is a simple interface declaration, so it is generally readable. The structure is clear, with imports grouped logically and annotations placed appropriately. Nesting is not an issue. The intent of the interface is evident: it defines a `PeekingIterator` with `peek()`, `next()`, and `remove()` methods. Code length is appropriate for the task. However, readability is hampered by excessive whitespace—multiple blank lines between imports and methods feel inconsistent and unnecessarily long. The reading flow is disrupted by these gaps. Action granularity is fine, as each method declaration stands alone. Overall, the code is understandable but not optimally formatted.
Run 2
The code is highly readable for an interface definition. It has clear structure with logical imports and annotations. Nesting is minimal (nonexistent beyond the interface itself). Intent is clear: it defines a PeekingIterator contract with peek, next, and remove methods. Code length is concise and appropriate for the purpose. Action granularity is fine—each method is declared on one line. Reading flow is natural: annotations, method declarations, and documentation comments are organized logically. Minor deductions for excessive blank lines and unnecessary vertical whitespace, which slightly disrupt flow, and the missing import for @ParametricNullness, though this may be implied by package context. Overall, it is exemplary clean code.
Run 3
The code is highly readable. It has a clear interface declaration with proper imports, meaningful annotations, and well-chosen method names. The structure is logical: interface PeekingIterator extends Iterator, with peek() clearly documented as the key addition. Nesting is flat, and each method is separated by blank lines or comments. Clarity of intent is excellent—annotations like @DoNotMock and @CanIgnoreReturnValue convey important usage constraints. However, the code contains excessive empty comment templates (e.g., '/** */') spanning multiple lines, which increase length unnecessarily. The generic type parameter 'E extends @Nullable Object' adds slight complexity but is standard for Guava's nullness annotations. Reading flow is natural, with the intuitive ordering of peek, next, and remove. Overall, it is concise and well-organized, with minor redundancy from empty comment blocks preventing a perfect score.
Run 1
Code Structure: The package, imports, annotations, and interface methods are logically organized, though excessive blank lines disrupt the layout. Nesting: Minimal nesting makes the interface easy to scan. Clarity of intent: PeekingIterator and its method names convey purpose, but peek's behavior and its interaction with remove are undocumented; NoSuchElementException is imported but unused. Code length: The declarations are concise, but unnecessary whitespace greatly inflates the snippet. Action granularity: Each declaration and annotation occupies its own line, keeping responsibilities distinct. Reading flow: The order peek, next, remove is natural, although large gaps interrupt continuity.
Run 2
Code Structure: The package, imports, annotations, and interface methods are logically organized, although the unused NoSuchElementException import adds clutter. Nesting: There is only one interface scope, making the code easy to scan. Clarity of intent: PeekingIterator, peek(), and inherited iterator methods communicate the purpose clearly, but peek/remove interaction semantics are undocumented. Code length: The functional code is concise, but excessive blank lines unnecessarily inflate its visual length. Action granularity: Each declaration and annotation occupies its own line, with no bundled actions. Reading flow: Declaration order is natural, but large whitespace gaps interrupt the flow.
Run 3
Code Structure: The package, imports, annotations, and interface methods are logically organized, though unused NoSuchElementException import adds clutter. Nesting: Minimal nesting makes the interface easy to scan. Clarity of intent: PeekingIterator and its method names communicate the general purpose, but missing documentation leaves peek semantics and remove restrictions unclear. Code length: The actual declarations are concise, but excessive blank lines unnecessarily stretch the file. Action granularity: Each declaration and annotation occupies its own line, keeping responsibilities distinct. Reading flow: The method order is natural, but large whitespace gaps interrupt continuity.