Source code
package com.google.common.graph;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.Set;
import org.jspecify.annotations.Nullable;
interface NetworkConnections<N, E> {
Set<N> adjacentNodes();
Set<N> predecessors();
Set<N> successors();
Set<E> incidentEdges();
Set<E> inEdges();
Set<E> outEdges();
Set<E> edgesConnecting(N node);
N adjacentNode(E edge);
@CanIgnoreReturnValue
@Nullable N removeInEdge(E edge, boolean isSelfLoop);
@CanIgnoreReturnValue
N removeOutEdge(E edge);
void addInEdge(E edge, N node, boolean isSelfLoop);
void addOutEdge(E edge, N node);
}
Run 1
The code is a well-structured interface with a clear, logical organization. It defines related methods in a cohesive manner, and the methods are grouped by functionality (adjacency, edges, mutations), making the intent easy to understand. Nesting is flat—there are no nested conditionals or deep control structures. The purpose of each method is evident from its name, and the use of generic types and annotations adds clarity without clutter. Code length is concise: no unnecessary code or comments, just the essential API. Each method declaration is a single action, contributing to high action granularity. The reading flow is natural, following a logical progression from query methods to mutation methods. Minor deductions are for slightly excessive blank lines and sparse documentation, but these do not significantly hinder readability.
Run 2
The code is a well-structured Java interface with clear purpose and excellent readability. It logically groups related methods (adjacent nodes, predecessors/successors, incident/in/out edges) and maintains consistent naming conventions. Nesting is minimal, and each method signature is concise with one action per declaration. The use of annotations (@CanIgnoreReturnValue, @Nullable) adds clarity about method behavior without clutter. The interface is appropriately short, avoiding unnecessary complexity. Minor spacing inconsistencies and blank lines between method groups slightly disrupt flow, but overall the code is highly readable, with natural organization and unambiguous intent.
Run 3
The code is highly readable due to its well-structured interface definition. Methods are logically grouped by functionality (node queries, edge queries, mutations), and the flat hierarchy avoids unnecessary nesting. Naming conventions clearly communicate intent, making the purpose of each method unambiguous. The code is concise, with one method per line and no redundant logic. Action granularity is appropriate, with each method representing a single, focused action. Reading flow is natural, moving from general queries to specific mutations. Minor deductions for excessive blank lines and the absence of Javadoc comments, which slightly impact polish but do not hinder comprehension.
Run 1
Code Structure: The interface logically groups node queries, edge queries, and mutation operations. Nesting: No nested control flow; declarations are flat and easy to scan. Clarity of intent: Descriptive method names and typed parameters communicate purpose, though generic type names and self-loop handling lack explanatory documentation. Code length: Declarations are concise, but excessive blank lines unnecessarily lengthen the listing. Action granularity: Each method declaration represents a single operation, with annotations clearly associated with relevant methods. Reading flow: Ordering is natural, moving from queries to removals and additions, but inconsistent whitespace interrupts scanning.
Run 2
Code Structure: The interface logically groups node queries, edge queries, and mutation operations. Nesting: Entirely flat aside from the interface body, making it easy to scan. Clarity of intent: Descriptive method names and generic node/edge types communicate purpose, though self-loop handling and nullable return semantics lack explanatory documentation. Code length: Declarations are concise, but excessive blank lines unnecessarily lengthen the snippet. Action granularity: Each method declaration occupies its own line, with annotations clearly associated with methods. Reading flow: Method ordering is natural, but inconsistent spacing and large blank gaps interrupt the flow.
Run 3
Code Structure: The interface logically groups node queries, edge queries, and mutation methods. Nesting: Entirely flat apart from the interface declaration, making it easy to scan. Clarity of intent: Descriptive method names and generic types communicate purpose, though the self-loop flag and nullable return behavior lack explanatory documentation. Code length: Declarations are concise, but excessive blank lines unnecessarily lengthen the file. Action granularity: Each method declaration occupies its own line, with annotations clearly associated with the relevant methods. Reading flow: Method ordering is natural and consistent, but irregular spacing interrupts the visual flow.