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 a clear, logical structure. The class has a single responsibility, and methods are short with descriptive names. Nesting is minimal—only simple ternary expressions are used, avoiding deep indentation. Intent is explicit through method names like getConnectingEdge and contains, and the Javadoc explains the class's purpose and limitation. Code length is concise without sacrificing clarity. Action granularity is appropriate: each line performs one logical operation. Reading flow is natural, with fields, constructor, and overridden methods ordered logically. Minor deductions: the ternary in iterator() could be slightly clearer, and the wildcard generic Map<?, E> is understandable but slightly less explicit than ideal.
Run 3
The code is well-structured with clear logical organization: fields are declared first, followed by a constructor, then public API methods (iterator, size, contains), and a private helper at the end. Nesting is minimal with flat conditional expressions using ternary operators. Intent is clear—the class represents edges between implicit origins and a target node, supported by useful Javadoc and null checks. Length is concise; no unnecessary code or redundant logic exists. Action granularity is excellent, with one primary action per line, especially within the iterator method where the ternary is broken across lines for readability. Reading flow is natural, following a top-down progression from fields to constructor to public methods to private helper. Minor improvements could include an inline comment explaining why getConnectingEdge may return null, and perhaps breaking the size() ternary for consistency, but overall the code is highly readable.
Run 1
Code Structure: A focused class with logically organized fields, constructor, set operations, and a shared lookup helper. Nesting: Essentially flat; simple conditionals avoid nested control flow. Clarity of intent: Descriptive names and documentation clearly explain the single-edge constraint and purpose, though the implicit origin node requires some graph context. Code length: Concise without unnecessary abstraction or repetition. Action granularity: Each statement performs one clear action; ternary expressions compactly represent straightforward alternatives. Reading flow: Natural progression from initialization to public behavior and the private helper. The multiline iterator ternary and generic factory syntax add slight visual complexity, but overall readability is excellent.
Run 2
Code Structure: Fields, constructor, overridden set operations, and a private lookup helper are logically organized. Nesting: There are no nested blocks; simple conditional expressions keep control flow flat. Clarity of intent: Descriptive names and class documentation clearly explain the edge-set abstraction and its restriction to networks without parallel edges. Code length: The implementation is concise, with a helper centralizing the lookup and no unnecessary logic. Action granularity: Statements generally perform one action each; conditional returns remain easy to understand. Reading flow: Methods follow a natural sequence and consistently use the same lookup pattern. Minor readability drawbacks are the tightly packed imports and the multiline ternary with explicit generic syntax in iterator(), which is slightly less immediate than the other methods.
Run 3
Code Structure: Fields, constructor, set-operation overrides, and a private 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 connecting-edge set and its restriction against parallel edges; nullability annotations clarify absence handling. Code length: The implementation is concise, with minimal boilerplate and a shared helper avoiding repeated lookup details. Action granularity: Each statement performs a focused action, although conditional expressions combine selection and return. Reading flow: Methods follow familiar collection conventions and are easy to scan. Minor readability drawbacks are the densely grouped imports and the multiline ternary with an explicit generic type in iterator(), which is slightly less immediate than the other methods.