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 due to its consistent and logical structure. It follows a standard delegation pattern where each method is a single, clear delegation to the abstract delegate() method, making the intent immediately obvious. There is minimal nesting, no conditional complexity, and each line performs one action. The ordering of methods groups related functionality (nodes, edges, degree, edge connectivity), which aids the natural reading flow. The only minor drawback is code length—while repetitive, this is inherent to forwarding classes and not a sign of poor readability. Overall, it is very clear and maintainable.
Run 2
The code is highly readable. It follows a clear, consistent structure where each method simply delegates to an abstract delegate() method, making the intent unambiguous. The class is flat with no nesting, and each method performs exactly one action (delegation), adhering to good action granularity. Method ordering appears logical, grouping related functionality (nodes, edges, connectivity). Although the class is long, the length is justified by the interface implementation and does not introduce complexity. The reading flow is natural, with a clear pattern that is easy to scan. Minor deductions could be made for the repetitive boilerplate nature and the slightly unusual import of Optional/Nullable, but these do not significantly hinder readability.
Run 3
The code demonstrates excellent readability through its flat, consistent structure. Each method follows an identical one-line delegation pattern, making it highly predictable and easy to scan. The class has a clear single purpose: forwarding calls to a delegate object. Method grouping follows a logical progression (basic properties, node operations, edge operations, connectivity queries). No nesting exists beyond the class itself, and naming is explicit and self-documenting. The absence of additional logic keeps the code concise despite many methods. The abstract delegate() method clearly signals the extension point. Javadoc and annotations add useful context without clutter. Minor deductions only for slight repetition and lack of inner grouping comments.
Run 1
Code Structure: Well-organized forwarding class with related methods and overloads grouped together. Nesting: Flat method bodies with no conditional or loop nesting. Clarity of intent: Class documentation, descriptive method names, and consistent delegation make its purpose immediately clear. Code length: Long due to required forwarding boilerplate, but each method is minimal and contains no unnecessary logic. Action granularity: Each method performs one forwarding action in a single return statement. Reading flow: Consistent formatting and predictable method patterns make scanning easy, although the repetitive boilerplate slightly increases reading effort.
Run 2
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 documentation, descriptive method names, and consistent delegate() calls clearly establish its forwarding purpose. Code length: The class is lengthy and repetitive, but each method is minimal; most repetition is necessary to implement the forwarding interface explicitly. Action granularity: Each method contains a single return statement performing one clear forwarding operation. Reading flow: Consistent formatting, annotations, and method patterns make the code easy to scan and predict. Minor drawbacks are boilerplate volume and the lack of spacing between the package declaration and imports.
Run 3
Code Structure: Well-organized forwarding class 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 consistent delegate calls make its purpose immediately clear. Code length: Long but largely justified by the interface's forwarding requirements; repetition adds scanning overhead without unnecessary complexity. Action granularity: Each method contains a single return statement performing one clear forwarding operation. Reading flow: Consistent formatting, annotations, and predictable method patterns make the code easy to follow. Minor drawbacks are repetitive boilerplate and the lack of spacing between the package declaration and imports.