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 ? 0x0 : 0x1;
}
@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 with clear structure: a focused class with a single responsibility, well-named fields and methods, and logical organization. Nesting is minimal—only one shallow conditional in iterator(). Intent is obvious from naming conventions (nodeToOutEdge, targetNode, getConnectingEdge) and Javadoc documentation. Code length is appropriate and concise, avoiding unnecessary boilerplate. Action granularity is excellent, with one primary operation per line and clean separation of concerns. Reading flow follows a natural top-down progression from fields to constructor to overridden methods, then private helper. Minor deductions only for the slightly cryptic hex notation (0x0/0x1 instead of 0/1) and the repeated getConnectingEdge() calls, which are trivial trade-offs for clarity.
Run 2
The code is well-structured with clear purpose and minimal complexity. The class is focused, methods are concise, and naming is descriptive. Nesting is flat, with only minor conditional expressions. Action granularity is appropriate, and the reading flow is natural. Minor deductions include the use of hexadecimal literals (0x0, 0x1) which slightly obscure intent, and the iterator method could be marginally clearer by avoiding the ternary chain. Overall, the code is highly readable and maintainable.
Run 3
The code is well-structured with a clear class purpose documented in Javadoc. Methods are short, focused, and follow a logical organization. Nesting is minimal—only a couple of ternary expressions and one conditional in contains(). Intent is clear: retrieve the single connecting edge for a target node. Action granularity is good, with one primary action per line. The reading flow is natural, moving from constructor to standard collection methods to the private helper. Minor drawbacks: the ternary in iterator() spans multiple lines but remains readable, and the size() method uses hex literals (0x0, 0x1) which is unconventional and slightly reduces clarity. Nullness annotations add helpful context. Overall, the code is concise, maintainable, and readable, with only trivial style quirks preventing a perfect score.
Run 1
Code Structure: Well-organized class with focused fields, constructor, standard set operations, and a shared lookup helper. Nesting: Essentially flat; conditional expressions are simple and easy to follow. Clarity of intent: Descriptive names and class documentation clearly explain the purpose and restriction against parallel edges. Hexadecimal 0x0 and 0x1 in size() unnecessarily obscure ordinary counts. Code length: Concise, with minimal duplication and no unnecessary logic. Action granularity: Statements generally perform one clear action, while compact boolean and conditional expressions remain readable. Reading flow: Natural progression from state initialization to public operations and the private helper; missing spacing between the package declaration and imports slightly reduces visual organization.
Run 2
Code Structure: Fields, constructor, set operations, and a private lookup helper are logically organized. Nesting: Methods are flat, with simple conditional expressions and no nested blocks. Clarity of intent: Descriptive names and class documentation clearly explain the single-edge set abstraction and its restriction against parallel edges. The hexadecimal literals 0x0 and 0x1 unnecessarily obscure ordinary size values. Code length: The implementation is concise, with short methods and minimal duplication. Action granularity: Each statement performs a focused operation; conditional expressions remain simple enough to read easily. Reading flow: The progression from initialization through public operations to the helper is natural, although tightly packed imports and the multiline iterator ternary introduce minor visual friction.
Run 3
Code Structure: Fields, constructor, overridden set methods, and a lookup helper are logically organized. Nesting: There is no deep nesting; simple conditional expressions keep control flow flat. Clarity of intent: Descriptive names and class documentation clearly explain the single-edge set and its restriction against parallel edges. However, hexadecimal literals 0x0 and 0x1 obscure ordinary size values slightly. Code length: The implementation is concise, with a small helper avoiding repeated lookup details. Action granularity: Statements generally perform one action per line; the iterator's conditional expression remains easy to follow. Reading flow: The class progresses naturally from initialization to public behavior and then implementation details. Minor drawbacks include tightly packed imports and the unnecessary hexadecimal notation.