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. It follows a consistent, flat structure with no nesting. Each method has a single, clear purpose: delegating to the underlying Network implementation. The naming is explicit and conventional, making intent immediately clear. Methods are concise, with one action per line (returning the delegated call). The reading flow is natural, grouping related methods logically (nodes/edges, ordering, adjacency, incidence, connectivity). The use of Javadoc and annotations adds clarity without clutter. Minor deductions: repetitive boilerplate slightly lengthens the file, and the abstract delegate method could benefit from a brief comment clarifying its role, but overall readability is excellent.
Run 3
The code is highly readable. It follows a clear, consistent structure where each method delegates directly to an underlying implementation. Nesting is minimal, with no conditional logic or deeply indented blocks. Intent is obvious from the class name, Javadoc, and method names. Each method is concise—typically one line—and each line performs a single action (delegation). The reading flow is natural: methods are grouped logically (basic graph properties, node-related operations, edge-related operations, and connectivity queries). The only minor drawback is the repetitive boilerplate nature of the forwarding pattern, which slightly reduces readability due to its verbosity, but this is inherent to the design and not a flaw in the code itself.
Run 1
Code Structure: Logically organized as a forwarding class, with related methods and overloads grouped together. Nesting: Minimal; each method contains a single return statement with no branching. Clarity of intent: The class documentation, delegate() method, descriptive names, and consistent forwarding pattern make its purpose explicit. Code length: Long overall because of necessary interface boilerplate, but individual methods are concise and contain no unnecessary logic. Action granularity: Each statement performs one clear forwarding operation, with no compressed multi-statement lines. Reading flow: Consistent formatting, annotations, spacing, and method patterns make the code easy to scan. Minor drawbacks are repetitive boilerplate and the lack of visual section headings for the many methods.
Run 2
Code Structure: Methods are logically grouped by network properties, node/edge relationships, degrees, and connection queries. Nesting: All methods are flat, with no branching or nested control flow. Clarity of intent: The class documentation, descriptive method names, and consistent delegate calls make its forwarding purpose explicit. Code length: The class is lengthy and repetitive, but each method is minimal; the repetition is appropriate for implementing the forwarding interface. Action granularity: Each method contains a single return statement performing one clear forwarding operation. Reading flow: Consistent formatting, annotations, and adjacent overloads make the code predictable and easy to scan. Minor spacing between the package declaration and imports would improve presentation.
Run 3
Code Structure: Methods are consistently organized, with related operations and overloads grouped together. Nesting: Completely flat method bodies contain no branching or loops. Clarity of intent: The class name, documentation, and uniform delegate calls clearly communicate the forwarding purpose. Code length: The class is lengthy because it covers many interface methods, but each implementation is minimal; repetition is appropriate forwarding boilerplate. Action granularity: Each method contains a single return statement performing one forwarding operation. Reading flow: Consistent annotations, spacing, naming, and method patterns make the code easy to scan. Minor formatting improvements, such as separating the package declaration from imports, would improve presentation.