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. Structure is logical: a clear abstract delegate method followed by straightforward overrides grouped functionally (basic properties, node queries, edge queries, connectivity). Nesting is flat—no conditional or loop nesting exists. Intent is obvious: every method directly delegates to the underlying Network. Length is appropriate for a forwarding class; repetition is inherent and not unnecessarily verbose. Action granularity is one delegate call per method, each on a single line. Reading flow is natural, with related methods grouped and named consistently. The only minor deductions are for inherent repetitiveness and the abstract class's purpose being slightly narrow, but neither meaningfully harms readability.
Run 3
This code is highly readable. It follows a consistent delegation pattern, with one method per line and minimal nesting, which keeps the structure flat and clear. Each method has a single responsibility—delegating to the underlying Network—making the intent unambiguous. The naming is intuitive and aligns with typical graph API conventions. The file is concise despite its length, as it is necessarily repetitive by design. Overall, the code exhibits excellent structure, clarity, and flow.
Run 1
Code Structure: Well-organized forwarding class with related operations and overloads grouped together. Nesting: Flat, with no conditional or loop nesting. Clarity of intent: Class documentation, descriptive method names, and consistent delegate calls make the purpose immediately clear. Code length: Long due to necessary interface-forwarding boilerplate, but each method is minimal and contains no unnecessary logic. Action granularity: Each method performs a single forwarding action on one line. Reading flow: Consistent formatting and predictable method bodies make scanning easy; the repetitive boilerplate slightly increases reading effort.
Run 2
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 name, documentation, and consistent delegate() calls clearly convey its purpose. Code length: The class is lengthy and repetitive, but each method is minimal and the repetition is appropriate for explicit interface forwarding. Action granularity: Each method contains a single return statement performing one forwarding operation. Reading flow: Consistent formatting, descriptive method names, and predictable implementation patterns make scanning easy. Minor drawbacks are boilerplate volume and the lack of spacing between the package declaration and imports.
Run 3
Code Structure: Methods are logically grouped by network properties, neighborhood queries, degrees, and edge connections, with overloads adjacent. Nesting: Completely flat method bodies with no branching or loops. Clarity of intent: The class documentation, descriptive method names, and consistent delegate calls make the forwarding purpose explicit. Code length: The class is lengthy but each method is minimal; repetition is appropriate for implementing a forwarding interface. Action granularity: Each method contains one return statement performing a single forwarding operation. Reading flow: Consistent formatting, annotations, and predictable method bodies make scanning easy. Minor drawbacks are boilerplate volume and the lack of blank lines separating the package and import declarations.