Source code
package com.google.common.graph;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import java.util.Set;
import org.jspecify.annotations.Nullable;
/**
* An interface for representing and manipulating an origin node's adjacent nodes and incident edges
* in a {@link Network}.
*
* @author James Sexton
* @param <N> Node parameter type
* @param <E> Edge parameter type
*/
interface NetworkConnections<N, E> {
Set<N> adjacentNodes();
Set<N> predecessors();
Set<N> successors();
Set<E> incidentEdges();
Set<E> inEdges();
Set<E> outEdges();
/**
* Returns the set of edges connecting the origin node to {@code node}. For networks without
* parallel edges, this set cannot be of size greater than one.
*/
Set<E> edgesConnecting(N node);
/**
* Returns the node that is adjacent to the origin node along {@code edge}.
*
* <p>In the directed case, {@code edge} is assumed to be an outgoing edge.
*/
N adjacentNode(E edge);
/**
* Remove {@code edge} from the set of incoming edges. Returns the former predecessor node.
*
* <p>In the undirected case, returns {@code null} if {@code isSelfLoop} is true.
*/
@CanIgnoreReturnValue
@Nullable N removeInEdge(E edge, boolean isSelfLoop);
/** Remove {@code edge} from the set of outgoing edges. Returns the former successor node. */
@CanIgnoreReturnValue
N removeOutEdge(E edge);
/**
* Add {@code edge} to the set of incoming edges. Implicitly adds {@code node} as a predecessor.
*/
void addInEdge(E edge, N node, boolean isSelfLoop);
/** Add {@code edge} to the set of outgoing edges. Implicitly adds {@code node} as a successor. */
void addOutEdge(E edge, N node);
}
Run 1
This interface is highly readable and well-structured. The code organization is logical, with method declarations grouped into sections (adjacent nodes, incident edges, edge operations) and separated by whitespace. Nesting is minimal - only the class/interface declaration and method bodies are nested, making the code flat and easy to scan. Intent is crystal clear through descriptive method names and purposeful Javadoc comments that explain each method's behavior and edge cases. The code length is concise - no unnecessary boilerplate or redundant annotations. Action granularity is appropriate for an interface, with each method declaration on its own line. Reading flow is natural, moving from basic accessor methods to more complex edge operations in a progressive manner. The only minor deduction is for the slightly verbose Javadoc on some methods, but this actually enhances understanding rather than hindering readability. Overall, this is exceptionally clean, well-documented Java code.
Run 2
The code is highly readable. It uses a clean interface structure with clear method grouping and comprehensive Javadoc that explains intent, especially for non-obvious behavior like self-loops. Nesting is minimal (none beyond the class body), and each method is a single, focused action. Naming is descriptive, and parameter/return types are straightforward. Minor deductions are for slight verbosity in repetitive documentation and the implicit contract of 'isSelfLoop' requiring external context.
Run 3
The code is highly readable due to its clean interface structure, clear separation of concerns, and concise method signatures. The logical organization groups related methods (adjacent nodes, predecessors/successors, edge sets) in a natural reading flow. Nesting is non-existent since this is an interface. Intent is evident from method names and Javadoc comments, especially for nuanced behaviors like self-loops. Action granularity is optimal—one method per line in declarations. Javadoc clarifies edge cases without being verbose. Minor deductions: some methods lack explanatory comments for selfLoop parameter usage, and ordering could group inEdges/outEdges consistently with predecessors/successors. Overall, this is exemplary interface design that balances conciseness with clarity.
Run 1
Code Structure: Logically groups node queries, edge queries, removals, and additions in a compact interface. Nesting: No nested control flow; declarations are flat and easy to scan. Clarity of intent: Descriptive method names, generic types, and focused documentation clearly communicate graph operations and special cases. Some basic query methods lack documentation, and addInEdge does not explain isSelfLoop. Code length: Concise, with no unnecessary implementation or repetition. Action granularity: Each method declaration represents one focused operation, with annotations clearly separated. Reading flow: Consistent formatting and progression from queries to mutations make reading natural. Minor documentation gaps prevent a perfect score.
Run 2
Code Structure: The interface logically groups node queries, edge queries, and mutation methods. Nesting: Flat declarations with no nested control flow make scanning easy. Clarity of intent: Descriptive method names, generic types, annotations, and focused documentation clearly communicate purpose and behavior. However, the basic query methods lack documentation, and the isSelfLoop parameter's meaning in addInEdge is not explained. Code length: Concise and appropriate for an interface, with useful rather than excessive comments. Action granularity: Each declaration occupies its own line and represents a distinct operation. Reading flow: Consistent spacing and progression from queries to removals and additions support natural reading; a blank line after the package declaration would slightly improve formatting.
Run 3
Code Structure: Logically groups node queries, edge queries, removals, and additions within a focused interface. Nesting: Flat declarations with no nested control flow make scanning easy. Clarity of intent: Descriptive method names and targeted Javadoc explain purpose, directionality, and special cases; the first six methods and the addInEdge self-loop parameter could use brief documentation. Code length: Concise, with useful comments rather than unnecessary verbosity. Action granularity: Each declaration occupies its own line and represents one operation. Reading flow: Consistent formatting and progression from queries to mutations support natural reading, though a blank line after the package declaration would improve visual separation.