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 consistent, flat structure. Each method follows the same simple delegation pattern, making the intent immediately clear. Nesting is minimal, and each method contains only one action per line, contributing to excellent action granularity. The class-level Javadoc provides useful context about the purpose and limitations. Method ordering is logical, grouping related methods (nodes/edges, direction properties, adjacency, incidence, connectivity). The only minor drawbacks are slight repetition inherent to forwarding classes and the lack of method-level comments explaining edge cases, but these do not significantly impact readability. Overall, the code is concise, well-organized, and easy to understand.
Run 3
The code is a highly readable forwarding/decorator class. It follows a clear, consistent structure: every public method simply delegates to an abstract delegate() method, making the intent and behavior immediately obvious. There is no unnecessary nesting, and each method contains a single action. The class-level Javadoc explains its purpose and temporary nature. The methods are organized logically, with related methods grouped together. The code is concise, with no redundant logic or boilerplate beyond what is necessary for delegation. Each override is a single line, enhancing readability and maintainability. The only minor drawback is that the class is somewhat repetitive, but this is inherent to the forwarding pattern and does not detract from clarity. Overall, the code is well-structured, flat, and easy to read.
Run 1
Code Structure: Well-organized forwarding class with consistent overrides and related overloads grouped together. Nesting: Flat, with no conditional or loop nesting. Clarity of intent: The class documentation, delegate() abstraction, and descriptive method names make the forwarding purpose explicit. Code length: Long due to repetitive interface forwarding, but each method is minimal and the repetition is justified. Action granularity: Each method contains a single return statement forwarding one operation; no unrelated actions are combined. Reading flow: Consistent formatting and predictable method bodies make scanning easy. Minor drawbacks are the extensive boilerplate and lack of spacing between the package declaration and imports.
Run 2
Code Structure: Well-organized forwarding class with related operations and overloads grouped together. Nesting: Flat, single-statement methods with no nested control flow. Clarity of intent: The class documentation, descriptive method names, and consistent delegate calls make its purpose explicit. Code length: Long overall because of necessary forwarding boilerplate, but each method is concise without unnecessary logic. Action granularity: Each method contains one clear forwarding statement, with no unrelated actions combined. Reading flow: Consistent formatting and predictable method structure make scanning easy; minor spacing between the package and imports would improve presentation.
Run 3
Code Structure: Logically organized forwarding methods, with related operations and overloads grouped together. Nesting: Completely flat method bodies with no conditional or loop nesting. Clarity of intent: The class documentation, delegate() method, descriptive names, and consistent forwarding pattern make its purpose explicit. Code length: The class is lengthy and repetitive, but each method is minimal; most repetition is inherent to implementing this forwarding interface. Action granularity: Each method contains a single return statement performing one forwarding operation. Reading flow: Consistent formatting and predictable method implementations make scanning easy. Minor drawbacks are the repetitive boilerplate and lack of blank lines separating the package declaration from imports and related method groups.