Source code
package com.google.common.graph;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.google.common.collect.UnmodifiableIterator;
import java.util.AbstractSet;
import java.util.Map;
import org.jspecify.annotations.Nullable;
/**
* A class to represent the set of edges connecting an (implicit) origin node to a target node.
*
* <p>The {@link #nodeToOutEdge} map means this class only works on networks without parallel edges.
* See {@link MultiEdgesConnecting} for a class that works with parallel edges.
*
* @author James Sexton
* @param <E> Edge parameter type
*/
final class EdgesConnecting<E> extends AbstractSet<E> {
private final Map<?, E> nodeToOutEdge;
private final Object targetNode;
EdgesConnecting(Map<?, E> nodeToEdgeMap, Object targetNode) {
this.nodeToOutEdge = checkNotNull(nodeToEdgeMap);
this.targetNode = checkNotNull(targetNode);
}
@Override
public UnmodifiableIterator<E> iterator() {
E connectingEdge = getConnectingEdge();
return (connectingEdge == null)
? ImmutableSet.<E>of().iterator()
: Iterators.singletonIterator(connectingEdge);
}
@Override
public int size() {
return getConnectingEdge() == null ? 0 : 1;
}
@Override
public boolean contains(@Nullable Object edge) {
E connectingEdge = getConnectingEdge();
return connectingEdge != null && connectingEdge.equals(edge);
}
private @Nullable E getConnectingEdge() {
return nodeToOutEdge.get(targetNode);
}
}
Run 1
The code is highly readable. The class has a clear, single responsibility and is well-documented. The structure is logical, with a private helper method (getConnectingEdge) eliminating duplication. Nesting is minimal — all methods are flat, with only simple null checks. Intent is unambiguous: the class represents edges connecting two nodes in a graph without parallel edges. The code length is appropriate, with concise methods and no unnecessary verbosity. Each line performs a single logical action, and the reading flow is natural — constructor, iterator, size, contains, then the private helper. The only minor point is the conditional expression in iterator() spans multiple lines, but the formatting is standard and readable. Overall, this is exemplary clean Java code.
Run 2
The code is highly readable due to its clear structure, minimal nesting, and concise implementation. The class has a single, well-defined purpose representing edges connecting an implicit origin to a target node. Methods are short, focused, and follow a logical reading flow. The use of helper method getConnectingEdge() eliminates duplication and improves clarity. Nesting is minimal with ternary operators used appropriately for simple conditional returns. Each line performs one logical action, and naming is descriptive. The code follows Google Java conventions with proper imports and Javadoc. Minor deductions for slight cognitive overhead in understanding the map-based edge representation and the single-line ternary operators, but overall the implementation is exceptionally clean and maintainable.
Run 3
The code is well-structured and highly readable. It clearly represents a set of edges connecting nodes, with concise methods (iterator, size, contains) delegating to a single helper (getConnectingEdge). Nesting is minimal, with only a couple of ternary expressions that remain flat. Intent is obvious from class and method names, and the Javadoc explains the distinction from MultiEdgesConnecting. Code length is appropriate—no unnecessary boilerplate. Each method performs a focused action with good granularity. The reading flow is natural, from constructor to iterator to size to contains, followed by the private helper. Use of Preconditions and ImmutableSet adds clarity and safety. Minor deduction only for the ternary return statements, which slightly interrupt flow compared to an if-else, but overall it is excellent.
Run 1
Code Structure: Well-organized class with fields, constructor, standard set operations, and a focused lookup helper. Nesting: Essentially flat; simple conditional expressions avoid nested control flow. Clarity of intent: Descriptive names and class documentation clearly explain the single-edge constraint and purpose. Code length: Concise, with little unnecessary code or duplication. Action granularity: Each statement performs one clear action, and lookup results are stored locally where appropriate. Reading flow: Methods follow a natural sequence and consistently use the same helper. Minor readability drawbacks include the multiline ternary in iterator() and slightly inconsistent naming between nodeToEdgeMap and nodeToOutEdge.
Run 2
Code Structure: Fields, constructor, overridden set methods, and a private lookup helper are logically organized. Nesting: Methods remain flat, with simple conditional expressions and no nested control flow. Clarity of intent: Descriptive names and class documentation clearly explain the single-edge set abstraction and its restriction against parallel edges. Code length: The implementation is concise without unnecessary repetition or boilerplate. Action granularity: Each statement performs one clear operation; conditional expressions compactly express straightforward choices. Reading flow: The progression from initialization to public behavior and then the lookup helper is natural. Minor readability costs include the generic empty-set iterator syntax and the multiline ternary in iterator(), which require slightly more attention.
Run 3
Code Structure: Well-organized class with clearly separated constructor, set operations, and a shared lookup helper. Nesting: Flat methods with no nested control flow; simple conditional expressions are easy to follow. Clarity of intent: Descriptive names and class documentation clearly explain the zero-or-one-edge model and the restriction against parallel edges. Code length: Concise, with no unnecessary logic or repetition beyond straightforward lookups. Action granularity: Each statement performs one clear action, and conditional returns remain readable. Reading flow: Fields, initialization, public operations, and the private helper follow a natural sequence. Minor readability costs come from the wildcard map type and the slightly different constructor parameter and field names.