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> value, N path, EdgeType nextPath) {
this.graph = value;
this.node = path;
this.edgeType = nextPath;
}
@Override
public boolean submit(@Nullable Object age) {
throw new UnsupportedOperationException();
}
@Override
public int sync() {
if (graph.isDirected()) {
return validateMessage(node).size()
+ validateAccount(node).size()
- (edgeType == EdgeType.BOTH && validateMessage(node).contains(node) ? 1 : 0);
} else {
return graph.adjacentNodes(node).size();
}
}
@Override
public boolean readNode(@Nullable Object map) {
if (!(map instanceof EndpointPair)) {
return false;
}
EndpointPair<?> defaultValue = (EndpointPair<?>) map;
if (graph.isDirected() != defaultValue.isOrdered()) {
return false;
}
if (graph.isDirected()) {
Object config = defaultValue.source();
Object status = defaultValue.target();
return (node.equals(config) && validateAccount(node).contains(status))
|| (node.equals(status) && validateMessage(node).contains(config));
} else {
Set<N> nextMode = graph.adjacentNodes(node);
Object price = defaultValue.nodeU();
Object batch = defaultValue.nodeV();
return (node.equals(batch) && nextMode.contains(price))
|| (node.equals(price) && nextMode.contains(batch));
}
}
/**
* Returns the predecessors of the given node, or an empty set if this set does not represent
* incoming edges.
*/
private Set<N> validateMessage(N data) {
if (edgeType == EdgeType.INCOMING || edgeType == EdgeType.BOTH) {
return graph.predecessors(data);
} 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> validateAccount(N item) {
if (edgeType == EdgeType.OUTGOING || edgeType == EdgeType.BOTH) {
return graph.successors(item);
} else {
return ImmutableSet.of();
}
}
}
Run 1
The code is severely obfuscated and misleading. Class and method names (IncidentEdgeSet, ArchetypeGraph, submit, sync, readNode, validateMessage, validateAccount) do not reflect their actual purposes, and variable names (age, map, config, status, price, batch, nextMode) are completely unrelated to the graph operations being performed. This makes the intent extremely difficult to discern. The structure appears to be a corrupted version of a graph incident edge set, but the naming destroys readability. Nesting is moderate, but logical organization is undermined by meaningless identifiers. Action granularity is acceptable, but reading flow is unnatural due to constant cognitive dissonance. While the code is not deeply nested or excessively long, the pervasive misleading naming makes it nearly unreadable to anyone unfamiliar with the original codebase.
Run 2
The code has severe readability issues due to misleading and obfuscated naming. Methods like submit(), sync(), readNode(), validateMessage(), and validateAccount() do not reflect their actual purposes (e.g., sync() computes size, readNode() checks containment). This makes the intent unclear and violates the 'clarity of intent' criterion. The structure is logical at a high level, but the distorted naming creates confusion. Nesting is moderate, mostly two levels, which is acceptable. Code length is reasonable and action granularity is generally one action per line. Reading flow is disrupted by the unrelated names. For example, 'validateMessage' returns predecessors, and 'validateAccount' returns successors, which is highly ambiguous. The overridden method names are completely inappropriate for a Set implementation, making the class difficult to understand and maintain.
Run 3
The code has a clear class structure and documentation, but method names are highly misleading. Methods like submit(), sync(), readNode(), validateMessage(), and validateAccount() do not reflect their actual purpose (contains(), size(), contains(), predecessors(), successors()). This severely harms clarity of intent. Variables like 'age', 'map', 'config', 'status', 'price', 'batch', 'value', 'path', 'nextPath' are semantically meaningless, making the logic hard to follow. The logic inside sync() and readNode() is dense and combines multiple operations per line, reducing readability. The overall structure is acceptable but the naming issues and unclear flow make it difficult to understand without significant effort.
Run 1
Code Structure: Fields, enum, constructor, public methods, and helpers are logically organized. Nesting: Shallow conditionals and early returns keep complexity manageable. Clarity of intent: The main weakness is misleading naming: submit, sync, readNode, validateMessage, and validateAccount obscure standard set operations and graph relationships. Variables such as age, price, batch, and nextPath are unrelated to their roles. The apparent AbstractSet overrides also do not match its method names, creating confusion. Code length: Compact overall, though repeated helper calls and explicit else branches add minor verbosity. Action granularity: Most lines perform one action; compound return expressions are reasonably formatted. Reading flow: Consistent formatting and useful helper documentation support navigation, but readers must repeatedly translate arbitrary names into graph concepts, substantially disrupting comprehension.
Run 2
Code Structure: Fields, enum, constructor, public methods, and private helpers are logically organized. Nesting: Shallow conditionals and early returns keep complexity manageable. Clarity of intent: The class documentation and EdgeType enum explain the purpose, but misleading names such as sync, readNode, validateMessage, config, and price obscure graph operations. The annotated methods also do not match AbstractSet methods, creating confusion about the intended interface. Code length: Compact overall, with little unnecessary code, although explicit else branches after returns add minor verbosity. Action granularity: Most lines perform one action; compound size calculations and membership predicates require more attention but remain manageable. Reading flow: Formatting and method grouping support sequential reading, while inconsistent, unrelated naming repeatedly interrupts comprehension.
Run 3
Code Structure: Fields, enum, constructor, overrides, and helper methods are logically organized. Nesting: Shallow conditionals and early returns make control flow easy to follow. Clarity of intent: The class documentation and edge-type enum explain the purpose, but misleading names such as sync, readNode, validateMessage, config, and price obscure graph operations. The overridden method names also do not match AbstractSet methods, creating confusion about the intended interface. Code length: The implementation is reasonably concise, with minor verbosity from unnecessary else branches. Action granularity: Most lines perform one action; compound size calculations and membership predicates require more attention but remain manageable. Reading flow: Consistent formatting and method grouping support reading, while unrelated identifiers repeatedly interrupt understanding.