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
The code is an interface with relatively simple methods, but formatting choices severely harm readability. Multiple methods appear on the same line (e.g., predecessors() and successors()), making the structure feel tangled and creating unnaturally high information density. Nesting is not a major issue (it is an interface), but the flow is disrupted by method declarations being squashed together and Javadoc comments being placed on the same line as annotations or code. Action granularity is violated: several logical declarations occupy a single line. The intent of individual methods is mostly clear from names, but the overall messy layout obscures the interface's purpose. While the code is not deeply nested or excessively long, the poor formatting and disorganized reading flow make it difficult to scan quickly. Overall, it falls well below average readability, earning a low score despite straightforward content.
Run 2
The code has several readability issues. Methods like predecessors() and successors() are crammed onto one line, making it harder to scan. Javadoc comments are merged with method declarations in a few places, which obscures the separation between documentation and code. 'Reading flow' feels disjointed and unnatural. However, method names are clear and the interface declares logical operations. The lack of whitespace and inconsistent formatting significantly reduce readability.
Run 3
The code is poorly structured with inconsistent indentation, collapsed method definitions, and cramped spacing. Methods like `Set<N> predecessors(); Set<N> successors();` are placed on the same line, violating one-action-per-line. Javadoc and annotations are compressed into single lines with method signatures, making the code hard to scan. Imports lack spacing, and the interface body is inconsistently formatted. While the method names are reasonably clear, the overall layout disrupts reading flow and obscures intent. Deep documentation merging reduces clarity despite the relatively flat nesting. Concise? Yes, but at the expense of readability.
Run 1
Code Structure: The interface logically groups node queries, edge queries, and mutation methods, though cramped formatting weakens separation. Nesting: Flat method declarations with no nested control flow make it easy to scan. Clarity of intent: Descriptive method names, types, and useful Javadoc clearly convey purpose and edge-case behavior. Code length: Concise and appropriate for an interface, without unnecessary implementation detail. Action granularity: Several declarations, annotations, comments, and closing braces share lines, obscuring individual elements. Reading flow: The overall ordering is natural, but inconsistent line breaks and comments attached to imports or preceding declarations interrupt reading.
Run 2
Code Structure: The interface logically groups node queries, edge queries, and mutation operations. Nesting: Flat declarations with no nested control flow make it easy to scan. Clarity of intent: Descriptive method names, generic types, and useful documentation clearly convey purpose and behavior. Code length: Concise and appropriate for an interface, with little unnecessary content. Action granularity: Several method declarations, annotations, and documentation boundaries share lines, reducing visual separation. Reading flow: The conceptual ordering is natural, but inconsistent formatting—such as Javadoc starting beside an import, declarations following comment endings, and the closing brace sharing a method line—interrupts scanning. Consistent line breaks and spacing would substantially improve readability.
Run 3
Code Structure: The interface logically groups adjacency queries, edge queries, and mutation methods, but inconsistent formatting weakens visual organization. Nesting: Flat declarations with no nested control flow make scanning easy. Clarity of intent: Descriptive method names, generic types, and useful documentation clearly convey graph operations and special cases. Code length: Concise and appropriate for an interface, with no unnecessary implementation detail. Action granularity: Several declarations, annotations, comments, and closing braces share lines, notably predecessors/successors and the removal methods, obscuring method boundaries. Reading flow: The ordering is natural, but comments attached to imports or declarations and compressed annotation placement interrupt smooth reading. Conventional line breaks and consistent spacing would substantially improve readability.