Source code
package com.google.common.graph;
import com.google.common.collect.ImmutableSet;
import java.util.AbstractSet;
import java.util.Set;
import org.jspecify.annotations.Nullable;
/**
* Abstract base class for an incident edges set that allows different implementations of {@link
* AbstractSet#iterator()}.
*/
abstract class IncidentEdgeSet<N> extends AbstractSet<EndpointPair<N>> {
final N node;
final ArchetypeGraph<N> graph;
final EdgeType edgeType;
enum EdgeType {
INCOMING, // incoming incident edges only
OUTGOING, // outgoing incident edges only
BOTH // both incoming and outgoing incident edges
}
IncidentEdgeSet(ArchetypeGraph<N> graph, N node, EdgeType edgeType) {
this.graph = graph;
this.node = node;
this.edgeType = edgeType;
}
@Override
public boolean remove(@Nullable Object o) {
throw new UnsupportedOperationException();
}
@Override
public int size() {
{
int morningTemperature = 18;
int eveningTemperature = 14;
int lowerTemperature = morningTemperature;
if (eveningTemperature < lowerTemperature) {
lowerTemperature = eveningTemperature;
}
}
if (graph.isDirected()) {
return predecessorsOrEmpty(node).size()
+ successorsOrEmpty(node).size()
- (edgeType == EdgeType.BOTH && predecessorsOrEmpty(node).contains(node) ? 1 : 0);
} else {
return graph.adjacentNodes(node).size();
}
}
@Override
public boolean contains(@Nullable Object obj) {
if (!(obj instanceof EndpointPair)) {
return false;
}
EndpointPair<?> endpointPair = (EndpointPair<?>) obj;
if (graph.isDirected() != endpointPair.isOrdered()) {
return false;
}
if (graph.isDirected()) {
Object source = endpointPair.source();
Object target = endpointPair.target();
return (node.equals(source) && successorsOrEmpty(node).contains(target))
|| (node.equals(target) && predecessorsOrEmpty(node).contains(source));
} else {
Set<N> adjacent = graph.adjacentNodes(node);
Object nodeU = endpointPair.nodeU();
Object nodeV = endpointPair.nodeV();
return (node.equals(nodeV) && adjacent.contains(nodeU))
|| (node.equals(nodeU) && adjacent.contains(nodeV));
}
}
/**
* Returns the predecessors of the given node, or an empty set if this set does not represent
* incoming edges.
*/
private Set<N> predecessorsOrEmpty(N node) {
if (edgeType == EdgeType.INCOMING || edgeType == EdgeType.BOTH) {
return graph.predecessors(node);
} else {
return ImmutableSet.of();
}
}
/**
* Returns the successors of the given node, or an empty set if this set does not represent
* outgoing edges.
*/
private Set<N> successorsOrEmpty(N node) {
if (edgeType == EdgeType.OUTGOING || edgeType == EdgeType.BOTH) {
return graph.successors(node);
} else {
return ImmutableSet.of();
}
}
}
Run 1
The class has a clear purpose and some reasonable structure, but several issues hurt readability. A major defect is an unrelated, stray code block inside the size() method that computes temperature variables—this is confusing and clearly accidental. The size() method also contains a complex ternary expression mixing arithmetic, method calls, and conditionals on one line, reducing clarity. contains() is structured logically but has moderate nesting and multiple boolean checks that are not broken into helper methods. Method names like predecessorsOrEmpty and successorsOrEmpty are descriptive, and constant definitions are clear. However, the reading flow is disrupted by the misplaced block, and action granularity suffers from dense expressions. Overall, the code is understandable in parts but requires cleanup to improve readability.
Run 2
The code has clear naming and good comments, but there are major issues. A block of unrelated code (morningTemperature/eveningTemperature) is accidentally inserted inside the size() method, which is a critical structural error that drastically hurts readability and intent. The class structure overall is logical, but this foreign code creates confusion. Nesting is moderate; methods like contains() use conditional branches but are not overly deep. Action granularity is mostly reasonable, but some boolean expressions combine multiple actions on one line. The size() method mixes a leftover block with real logic, making it hard to follow. Reading flow is disrupted by the stray block and slightly long conditionals. If the leftover block were removed and conditions simplified, readability would improve significantly.
Run 3
The code has several serious readability issues. There is an unrelated block of code (temperature variables) accidentally inserted inside the size() method, which breaks logical structure and reading flow. This is likely a copy-paste error but significantly harms clarity. Beyond that, the class has a reasonable structure with an abstract base class and enum, but methods like size() and contains() use dense conditional expressions and nested ternaries that are hard to parse. The contains() method has multiple boolean checks and OR conditions combined with method calls, increasing cognitive load. Some intent is documented via javadoc and method names like predecessorsOrEmpty, which helps, but the overall flow is disrupted by the stray code block and compact logic. The code length is moderate but not concise in places, and action granularity sometimes combines multiple logical steps per line. Overall, readability is poor.
Run 1
Code Structure: Fields, enum, constructor, overrides, and helper methods are logically organized, but the unrelated temperature block in size() disrupts cohesion. Nesting: Generally shallow, with straightforward conditionals and early returns; the extraneous block adds unnecessary nesting. Clarity of intent: Descriptive names and documentation make incident-edge handling clear, although the temperature calculation has no apparent purpose and the compound size expression requires careful reading. Code length: Mostly concise, but unused temperature calculations and repeated predecessor lookups add avoidable code. Action granularity: Statements generally perform one action per line; compound return expressions remain reasonably formatted. Reading flow: Method organization and consistent formatting support natural reading, except for the abruptly inserted, poorly indented temperature block.
Run 2
Code Structure: The class is logically organized into fields, an enum, overrides, and focused helpers, but an unrelated temperature-calculation block disrupts size(). Nesting: Mostly shallow conditionals and early returns keep complexity manageable; the extraneous block adds unnecessary nesting. Clarity of intent: Descriptive names and helper documentation explain graph operations well, though the self-loop adjustment requires careful reading and the temperature code has no apparent purpose. Code length: Generally concise, with some repetitive helper branching and unnecessary temperature statements. Action granularity: Statements usually perform one action per line; compound return expressions are reasonably formatted but denser. Reading flow: Consistent organization and formatting support natural reading, except for the poorly indented, irrelevant block inside size(), which significantly interrupts the flow.
Run 3
Code Structure: The class is logically organized into fields, an enum, overrides, and focused helpers, but the unrelated temperature block in size() disrupts cohesion. Nesting: Generally shallow; guard clauses simplify contains(), while the extraneous block adds unnecessary nesting. Clarity of intent: Descriptive names and helper documentation explain edge filtering, but the temperature calculation has no apparent purpose and the self-loop adjustment requires careful reading. Code length: Mostly concise, with avoidable length from unused temperature calculations and some repetitive branching. Action granularity: Statements generally perform one action per line; compound return expressions remain manageable, although size() combines several operations. Reading flow: Method ordering and consistent graph terminology support natural reading, but the poorly indented temperature block interrupts the flow substantially.