Source code
package com.google.common.graph;
import java.util.Optional;
import java.util.Set;
import org.jspecify.annotations.Nullable;
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
This code is a textbook example of the Delegation pattern, exhibiting excellent clarity and structure. The inheritance hierarchy is logical, the class is abstract, and the 'delegate()' method is clearly defined. There is no nesting, and every method follows a consistent, terse one-line action of forwarding the call. The reading flow is highly organized, logically grouping related methods (nodes, edges, degree, connectivity). The intent is unambiguous: this class forwards all operations to a delegate, reducing boilerplate in subclasses. While the code is repetitive, this verbosity is necessary for the proxy design and contributes to its predictability. Minor deductions relate to the slight redundancy and the lack of JavaDoc, which could explain the pattern, but the code itself is highly readable.
Run 2
This forwarding/decorator class is highly readable. Structure is logical and consistent: a single abstract delegate() method followed by uniformly implemented overrides. Nesting is essentially flat—each method body is a one-line delegation. Intent is unmistakable; it transparently forwards all Network operations. Code length is appropriate for the number of interface methods, though slightly repetitive by necessity. Action granularity is ideal: one action per line. Reading flow is natural, grouping related methods (nodes/edges, adjacency, degree, connection queries). Minor deductions: the unused Optional import and excessive blank lines after the package declaration slightly detract from polish. Overall, an exemplary use of the forwarding pattern with clear, predictable code.
Run 3
The code is highly readable due to its flat, consistent structure. Each method is a single-line delegation to an abstract 'delegate()', making intent immediately clear. There is no deep nesting or branching logic, and the method ordering follows a natural, logical progression (nodes, edges, properties, adjacency, degree, edge connectivity). While the class is somewhat long, the repetition is necessary for a forwarding wrapper and is not wasteful. One minor deduction is for the unused/extra blank lines after imports, but this does not materially affect readability. Overall, it is an excellent example of a simple, predictable forwarding pattern.
Run 1
Code Structure: Logically organized forwarding class with consistent method definitions and related overloads grouped together. Nesting: Flat, with no conditional or loop nesting. Clarity of intent: The class name, delegate() method, and direct forwarding calls make its purpose clear. Code length: Long overall due to necessary interface forwarding boilerplate, but each method is concise; excessive blank lines before the class add avoidable whitespace. Action granularity: Each method contains one return statement performing a single forwarding action. Reading flow: Consistent formatting and predictable delegation make the code easy to scan, though repetition slightly increases navigation effort.
Run 2
Code Structure: Methods are consistently organized by network properties, adjacency, degrees, and connectivity, with related overloads together. Nesting: Completely flat method bodies with no conditional or loop nesting. Clarity of intent: The class name, delegate() abstraction, and uniform forwarding calls clearly communicate its purpose. Code length: Each method is minimal; the overall length reflects necessary forwarding boilerplate rather than complex logic, although excessive blank lines before the class are unnecessary. Action granularity: Every method contains a single return statement, keeping actions easy to follow. Reading flow: Consistent formatting, descriptive names, and predictable method patterns make scanning straightforward. Minor whitespace clutter prevents a perfect score.
Run 3
Code Structure: Logically organized forwarding methods, with related operations and overloads grouped together. Nesting: Flat method bodies with no conditional or loop nesting. Clarity of intent: The class name, delegate() method, descriptive method names, and consistent forwarding pattern clearly communicate purpose. Code length: Each method is minimal; the overall repetition is appropriate for implementing the network interface rather than unnecessary complexity. Excessive blank lines before the class slightly detract from concision. Action granularity: Each method contains one return statement, keeping actions distinct and easy to inspect. Reading flow: Consistent annotations, indentation, spacing, and method ordering make the code predictable and easy to scan.