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 with clear structure and intent. The class has a single, well-documented responsibility: representing edges from an implicit origin to a target node in a network without parallel edges. The constructor validates inputs using Preconditions, and each method is concise with focused, single-purpose logic. Nesting is minimal—only simple ternary expressions are used, maintaining flat control flow. The private helper method getConnectingEdge() reduces duplication and improves clarity. Javadoc and @Nullable annotations enhance understanding of edge cases. The iterator method leverages Guava utilities effectively. Minor deductions for the slightly terse ternary usage and reliance on Guava-specific APIs, which may require familiarity with the library.
Run 3
The code is well-structured, with clear separation of concerns and a simple, flat hierarchy. Nesting is minimal, with only one ternary expression and no deep indentation. The intent is evident from the class name, Javadoc, and method names, making the purpose unambiguous. Code length is concise, avoiding unnecessary verbosity while maintaining clarity. Action granularity is appropriate, with most methods performing a single logical operation per line or per method. The reading flow is logical: constructor, iterator, size, contains, then the private helper. Null checks via Preconditions and the @Nullable annotation add clarity. Overall, the code is highly readable, with only minor potential improvements like extracting the repeated getConnectingEdge() calls if performance or readability were a concern.
Run 1
Code Structure: A focused class with logically grouped fields, constructor, set operations, and a private lookup helper. Nesting: Essentially flat; simple conditional expressions avoid nested control flow. Clarity of intent: Descriptive names and documentation clearly explain the edge-set abstraction and its restriction against parallel edges. Code length: Concise, with short methods and little redundancy. Action granularity: Each statement performs one clear action; conditional expressions remain easy to understand. Reading flow: Natural progression from initialization to public behavior and implementation detail. Minor readability costs come from the multiline ternary in iterator() and the slightly inconsistent nodeToEdgeMap/nodeToOutEdge naming.
Run 2
Code Structure: Fields, constructor, overridden set operations, and a shared lookup helper are logically organized. Nesting: Methods are flat, with simple conditional expressions and no nested control flow. Clarity of intent: Descriptive names and class documentation clearly explain the single-edge model and restriction against parallel edges. Code length: The implementation is concise without sacrificing clarity; the helper avoids repeating the map lookup expression. Action granularity: Each statement performs a focused operation, with only straightforward conditional logic combined in return expressions. Reading flow: The progression from initialization to public operations and the private helper is natural. Minor readability costs come from the multiline ternary in iterator() and the inconsistent naming between nodeToEdgeMap and nodeToOutEdge.
Run 3
Code Structure: Fields, constructor, collection overrides, and a private lookup helper are logically organized. Nesting: Methods are flat, with only simple conditional expressions. 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 logic or repetition. Action granularity: Statements generally perform one action per line; conditional expressions remain compact and understandable. Reading flow: Consistent formatting and straightforward method bodies make the code easy to follow. Minor readability costs come from the multiline ternary in iterator() and the constructor parameter name differing from the corresponding field name.