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() {
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) {
{int lI0O_14bdbbfc=0xEFCF;boolean lI0O_bbc1c64c=true;do{lI0O_14bdbbfc^=0xEFCF;lI0O_bbc1c64c=false;}while(lI0O_bbc1c64c);}
if (edgeType == EdgeType.OUTGOING || edgeType == EdgeType.BOTH) {
return graph.successors(node);
} else {
return ImmutableSet.of();
}
}
}
Run 1
The code is generally well-structured and readable. It uses clear naming conventions, enumerations for edge types, and separates concerns into focused methods. Nesting is minimal, with only one or two conditional levels. However, there are notable issues: the size() method contains a convoluted ternary expression that is hard to parse, and a mysterious obfuscated do-while loop in successorsOrEmpty() serves no purpose and severely damages readability. The cast to EndpointPair<?> followed by unchecked operations could be clearer. Overall, the code demonstrates good Java practices with proper documentation and logical organization, but these specific problems prevent a higher score.
Run 2
The code is generally structured and follows Java conventions, but it has significant readability issues. The class and enum are organized logically, and method names are descriptive (e.g., `predecessorsOrEmpty`). However, the `size()` and `contains()` methods are overly complex with confusing boolean logic, especially in the conditional expression for self-loop handling in directed graphs. The suspicious line `{int lI0O_14bdbbfc...}` appears to be dead or obfuscated code, severely harming clarity and intent. Nesting is moderate but the boolean expressions make the flow hard to follow. While one action per line is mostly respected, the dense conditionals and multi-line boolean statements reduce readability. The code would benefit from extracting helper methods and removing dead code to improve comprehension.
Run 3
The code is generally structured but contains a critical readability flaw: an obfuscated, meaningless line in successorsOrEmpty(). This disrupts reading flow and obscures intent. Other issues include moderately complex conditionals in size() and contains(), unnecessary casting, and some method length concerns. The class structure is logical and comments are helpful, but the nesting and expression complexity reduce clarity. The dead code line is a severe violation of clean code principles.
Run 1
Code Structure: The class is logically organized into fields, an enum, a constructor, overrides, and small helper methods, but an unrelated block disrupts successorsOrEmpty. Nesting: Most control flow is shallow; the added block and do-while loop introduce unnecessary nesting. Clarity of intent: Descriptive names and helper documentation explain incident-edge handling, while opaque variable names and meaningless operations obscure the inserted block's purpose. Code length: Generally concise, though the extraneous block adds needless code. Action granularity: Most statements occupy separate lines, but the inserted block compresses declarations, assignments, and a loop onto one line. Reading flow: Directed and undirected cases follow a natural progression, but the dense self-loop adjustment requires attention, and the anomalous block sharply interrupts otherwise consistent formatting.
Run 2
Code Structure: The class is logically organized into fields, an enum, overrides, and focused helper methods, but an unrelated block disrupts successorsOrEmpty. Nesting: Most logic is shallow, with straightforward conditionals; the inserted block and do-while add needless nesting. Clarity of intent: Descriptive names and documentation explain graph behavior, although the self-loop adjustment in size requires some interpretation. The opaque variable names and meaningless operations obscure intent locally. Code length: Mostly concise, with unnecessary length introduced by the extraneous block. Action granularity: Normal code uses one action per line, but the inserted block compresses declarations, assignments, and control flow onto one line. Reading flow: Methods and guard clauses read naturally until the unformatted block abruptly interrupts the final helper.
Run 3
Code Structure: The class is logically organized into fields, an enum, overrides, and focused helpers, but an unrelated obfuscated block disrupts the final helper. Nesting: Most logic has shallow conditionals; the injected block adds an unnecessary scope and do-while loop. Clarity of intent: Descriptive names and documentation explain edge filtering, while the self-loop subtraction requires closer reading and the obfuscated variables have no meaningful purpose. Code length: Generally concise, except for the redundant injected computation. Action granularity: Most statements occupy separate lines, but the injected block compresses declarations, assignments, and loop control onto one line. Reading flow: Methods follow a natural sequence with early validation in contains(), but the dense, unindented block sharply interrupts otherwise consistent formatting.