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 due to its clear structure and consistent pattern. Each method has a single responsibility, delegating to the underlying Network implementation with one action per line. The flat structure avoids deep nesting, and the natural reading flow follows the Network interface's logical grouping. Method names clearly express intent, and the Javadoc provides context for the class's purpose. The code is concise with minimal boilerplate, though the repetitive delegation pattern slightly reduces the score. Overall, this is an excellent example of clean, maintainable code.
Run 3
This is a textbook example of a forwarding/decorator pattern with excellent readability. The code structure is highly organized, with each public API method cleanly delegating to the underlying implementation. There is no nesting beyond the class itself, and each method body is a single clear statement. The intent is immediately obvious: every method forwards to the delegate. Action granularity is perfect—one method call and one return per method. Reading flow is natural, with methods logically grouped by related functionality (nodes, edges, adjacency, degree, connectivity). The only minor deductions are for the slight verbosity of the boilerplate nature of the forwarding pattern itself and the lack of inline comments explaining why certain methods exist, though the class-level Javadoc addresses the purpose well. Overall, this is highly maintainable and readable code.
Run 1
Code Structure: Logically organized forwarding methods, with related operations and overloads grouped together. Nesting: Minimal nesting; every implementation is a simple return statement. Clarity of intent: The class documentation, delegate() abstraction, descriptive method names, and @Override annotations make its forwarding purpose explicit. Code length: Long overall due to repetitive interface coverage, but each method is concise and the boilerplate is justified. Action granularity: Each statement performs one clear forwarding operation, with no unrelated actions combined. Reading flow: Consistent formatting and predictable method bodies make scanning easy. Minor drawbacks are the repetitive length and missing blank line between the package declaration and imports.
Run 2
Code Structure: Well-organized forwarding class with logically grouped methods and adjacent overloads. Nesting: Flat method bodies with no nested control flow. Clarity of intent: The class documentation, descriptive method names, and consistent delegate() calls clearly communicate its purpose. Code length: The class is long due to necessary forwarding boilerplate, but each method is minimal; repetition slightly increases scanning effort. Action granularity: Each method contains one straightforward return statement, without combining unrelated actions. Reading flow: Consistent formatting, annotations, and predictable implementation patterns make the code easy to follow.
Run 3
Code Structure: Cleanly organized around a single delegation pattern, with related operations and overloads grouped together. Nesting: Flat method bodies with no conditionals or loops. Clarity of intent: The class name, documentation, descriptive method names, and consistent forwarding calls make the purpose explicit. Code length: Long overall because of necessary forwarding boilerplate, but each method is minimal; repetition slightly reduces scanning efficiency. Action granularity: Each method contains one return statement performing a single forwarding operation. Reading flow: Consistent formatting, annotations, spacing between methods, and predictable ordering make the code easy to follow.