Coverage Summary for Class: ForwardingNetwork (com.google.common.graph)

1 /*
2  * Copyright (C) 2016 The Guava Authors
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.common.graph;
18 
19 import java.util.Optional;
20 import java.util.Set;
21 import javax.annotation.CheckForNull;
22 
23 /**
24  * A class to allow {@link Network} implementations to be backed by a provided delegate. This is not
25  * currently planned to be released as a general-purpose forwarding class.
26  *
27  * @author James Sexton
28  * @author Joshua O'Madadhain
29  */
30 @ElementTypesAreNonnullByDefault
31 abstract class ForwardingNetwork<N, E> extends AbstractNetwork<N, E> {
32 
33   abstract Network<N, E> delegate();
34 
35   @Override
36   public Set<N> nodes() {
37     return delegate().nodes();
38   }
39 
40   @Override
41   public Set<E> edges() {
42     return delegate().edges();
43   }
44 
45   @Override
46   public boolean isDirected() {
47     return delegate().isDirected();
48   }
49 
50   @Override
51   public boolean allowsParallelEdges() {
52     return delegate().allowsParallelEdges();
53   }
54 
55   @Override
56   public boolean allowsSelfLoops() {
57     return delegate().allowsSelfLoops();
58   }
59 
60   @Override
61   public ElementOrder<N> nodeOrder() {
62     return delegate().nodeOrder();
63   }
64 
65   @Override
66   public ElementOrder<E> edgeOrder() {
67     return delegate().edgeOrder();
68   }
69 
70   @Override
71   public Set<N> adjacentNodes(N node) {
72     return delegate().adjacentNodes(node);
73   }
74 
75   @Override
76   public Set<N> predecessors(N node) {
77     return delegate().predecessors(node);
78   }
79 
80   @Override
81   public Set<N> successors(N node) {
82     return delegate().successors(node);
83   }
84 
85   @Override
86   public Set<E> incidentEdges(N node) {
87     return delegate().incidentEdges(node);
88   }
89 
90   @Override
91   public Set<E> inEdges(N node) {
92     return delegate().inEdges(node);
93   }
94 
95   @Override
96   public Set<E> outEdges(N node) {
97     return delegate().outEdges(node);
98   }
99 
100   @Override
101   public EndpointPair<N> incidentNodes(E edge) {
102     return delegate().incidentNodes(edge);
103   }
104 
105   @Override
106   public Set<E> adjacentEdges(E edge) {
107     return delegate().adjacentEdges(edge);
108   }
109 
110   @Override
111   public int degree(N node) {
112     return delegate().degree(node);
113   }
114 
115   @Override
116   public int inDegree(N node) {
117     return delegate().inDegree(node);
118   }
119 
120   @Override
121   public int outDegree(N node) {
122     return delegate().outDegree(node);
123   }
124 
125   @Override
126   public Set<E> edgesConnecting(N nodeU, N nodeV) {
127     return delegate().edgesConnecting(nodeU, nodeV);
128   }
129 
130   @Override
131   public Set<E> edgesConnecting(EndpointPair<N> endpoints) {
132     return delegate().edgesConnecting(endpoints);
133   }
134 
135   @Override
136   public Optional<E> edgeConnecting(N nodeU, N nodeV) {
137     return delegate().edgeConnecting(nodeU, nodeV);
138   }
139 
140   @Override
141   public Optional<E> edgeConnecting(EndpointPair<N> endpoints) {
142     return delegate().edgeConnecting(endpoints);
143   }
144 
145   @Override
146   @CheckForNull
147   public E edgeConnectingOrNull(N nodeU, N nodeV) {
148     return delegate().edgeConnectingOrNull(nodeU, nodeV);
149   }
150 
151   @Override
152   @CheckForNull
153   public E edgeConnectingOrNull(EndpointPair<N> endpoints) {
154     return delegate().edgeConnectingOrNull(endpoints);
155   }
156 
157   @Override
158   public boolean hasEdgeConnecting(N nodeU, N nodeV) {
159     return delegate().hasEdgeConnecting(nodeU, nodeV);
160   }
161 
162   @Override
163   public boolean hasEdgeConnecting(EndpointPair<N> endpoints) {
164     return delegate().hasEdgeConnecting(endpoints);
165   }
166 }