Source code
package com.google.common.graph;
import java.util.Optional;
import java.util.Set;
import org.jspecify.annotations.Nullable;
/**
* A class to allow {@link Network} implementations to be backed by a provided delegate. This is not
* currently planned to be released as a general-purpose forwarding class.
*
* @author James Sexton
* @author Joshua O'Madadhain
*/
abstract class ForwardingNetwork<N, E> extends AbstractNetwork<N, E> {
abstract Network<N, E> delegate();
@Override
public Set<N> nodes() {
return delegate().nodes();
}
@Override
public Set<E> edges() {
return delegate().edges();
}
@Override
public boolean isDirected() {
return delegate().isDirected();
}
@Override
public boolean allowsParallelEdges() {
return delegate().allowsParallelEdges();
}
@Override
public boolean allowsSelfLoops() {
return delegate().allowsSelfLoops();
}
@Override
public ElementOrder<N> nodeOrder() {
return delegate().nodeOrder();
}
@Override
public ElementOrder<E> edgeOrder() {
return delegate().edgeOrder();
}
@Override
public Set<N> adjacentNodes(N node) {
return delegate().adjacentNodes(node);
}
@Override
public Set<N> predecessors(N node) {
return delegate().predecessors(node);
}
@Override
public Set<N> successors(N node) {
return delegate().successors(node);
}
@Override
public Set<E> incidentEdges(N node) {
return delegate().incidentEdges(node);
}
@Override
public Set<E> inEdges(N node) {
return delegate().inEdges(node);
}
@Override
public Set<E> outEdges(N node) {
return delegate().outEdges(node);
}
@Override
public EndpointPair<N> incidentNodes(E edge) {
return delegate().incidentNodes(edge);
}
@Override
public Set<E> adjacentEdges(E edge) {
return delegate().adjacentEdges(edge);
}
@Override
public int degree(N node) {
return delegate().degree(node);
}
@Override
public int inDegree(N node) {
return delegate().inDegree(node);
}
@Override
public int outDegree(N node) {
return delegate().outDegree(node);
}
@Override
public Set<E> edgesConnecting(N nodeU, N nodeV) {
return delegate().edgesConnecting(nodeU, nodeV);
}
@Override
public Set<E> edgesConnecting(EndpointPair<N> endpoints) {
return delegate().edgesConnecting(endpoints);
}
@Override
public Optional<E> edgeConnecting(N nodeU, N nodeV) {
return delegate().edgeConnecting(nodeU, nodeV);
}
@Override
public Optional<E> edgeConnecting(EndpointPair<N> endpoints) {
return delegate().edgeConnecting(endpoints);
}
@Override
public @Nullable E edgeConnectingOrNull(N nodeU, N nodeV) {
return delegate().edgeConnectingOrNull(nodeU, nodeV);
}
@Override
public @Nullable E edgeConnectingOrNull(EndpointPair<N> endpoints) {
return delegate().edgeConnectingOrNull(endpoints);
}
@Override
public boolean hasEdgeConnecting(N nodeU, N nodeV) {
return delegate().hasEdgeConnecting(nodeU, nodeV);
}
@Override
public boolean hasEdgeConnecting(EndpointPair<N> endpoints) {
return delegate().hasEdgeConnecting(endpoints);
}
}
Run 1
The code is highly readable. It follows a consistent, repetitive delegation pattern with a clear structural organization: each method is short, has one clear action per line, and simply forwards to a delegate. Nesting is completely flat, with no conditional logic or loops. Clarity of intent is excellent, as the class name, Javadoc, and method names explicitly convey the purpose of each delegate method. The code length is appropriate for its purpose, avoiding unnecessary verbosity while maintaining completeness. Reading flow is natural and predictable, grouped logically by related functionalities. The only minor deduction is the absence of inline comments for individual methods, but the uniformity of the pattern makes this unnecessary.
Run 2
The code is highly readable. It follows a clear, consistent forwarding pattern with one method per action, minimal nesting, and obvious intent: each public method delegates to an underlying Network implementation. The structure is flat and logical, grouping related methods (nodes, edges, traversal, connectivity) in a natural order. Method names and Javadoc are clear. The only minor drawback is repetition inherent to forwarding classes, which slightly increases length, but it preserves clarity and maintainability.
Run 3
The code is highly readable. It follows a consistent, flat structure where each method overrides a delegate method, making the pattern easy to scan. Nesting is minimal—essentially none beyond the class declaration. The intent is clear: this is a forwarding wrapper. Each method is concise, often a single line, and each line performs one logical action (delegation). The reading flow is straightforward, with methods logically grouped by related functionality. Minor deductions: the lack of constructor or delegate validation (not shown) and the repetitive nature could be slightly verbose, but this repetition is inherent to the decorator pattern and not detrimental. Overall, excellent structure and clarity.
Run 1
Code Structure: Logically organized forwarding methods, with related operations and overloads grouped together. Nesting: Flat method bodies with no nested control flow. Clarity of intent: The class documentation, delegate() abstraction, descriptive method names, and consistent forwarding pattern make its purpose explicit. Code length: Long overall because of interface coverage, but each method is minimal; repetition is appropriate rather than unnecessary complexity. Action granularity: Each method contains one clear return statement on its own line. Reading flow: Consistent formatting, spacing, and @Override annotations make the code easy to scan. Minor drawbacks are repetitive boilerplate and the lack of visual section headings for the many methods.
Run 2
Code Structure: Well organized around a consistent delegation pattern, with related methods and overloads grouped together. Nesting: Flat method bodies with no conditional or loop nesting. Clarity of intent: The class documentation, descriptive method names, and uniform forwarding calls make its purpose immediately clear. Code length: The class is long due to repetitive overrides, but each method is minimal and the repetition is justified by the forwarding interface. Action granularity: Each method contains a single return statement performing one forwarding operation. Reading flow: Consistent formatting and predictable implementations make scanning easy; the lack of blank lines separating the package and imports is a minor formatting weakness.
Run 3
Code Structure: Logically organized forwarding methods, with related operations and overloads grouped together. Nesting: Completely flat method bodies with no branching or loops. Clarity of intent: The class documentation, descriptive method names, and consistent delegate() calls make its purpose obvious. Code length: The class is lengthy and repetitive, but each method is minimal; most repetition is inherent to explicit interface forwarding. Action granularity: Each method contains a single return statement performing one clear forwarding operation. Reading flow: Consistent formatting, annotations, and predictable method bodies make scanning easy. Minor drawbacks are the boilerplate volume and lack of spacing between the package declaration and imports.