Coverage Summary for Class: ForwardingValueGraph (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 ValueGraph} implementations to be backed by a provided delegate. This is
25  * not 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 ForwardingValueGraph<N, V> extends AbstractValueGraph<N, V> {
32 
33   abstract ValueGraph<N, V> delegate();
34 
35   @Override
36   public Set<N> nodes() {
37     return delegate().nodes();
38   }
39 
40   /**
41    * Defer to {@link AbstractValueGraph#edges()} (based on {@link #successors(Object)}) for full
42    * edges() implementation.
43    */
44   @Override
45   protected long edgeCount() {
46     return delegate().edges().size();
47   }
48 
49   @Override
50   public boolean isDirected() {
51     return delegate().isDirected();
52   }
53 
54   @Override
55   public boolean allowsSelfLoops() {
56     return delegate().allowsSelfLoops();
57   }
58 
59   @Override
60   public ElementOrder<N> nodeOrder() {
61     return delegate().nodeOrder();
62   }
63 
64   @Override
65   public ElementOrder<N> incidentEdgeOrder() {
66     return delegate().incidentEdgeOrder();
67   }
68 
69   @Override
70   public Set<N> adjacentNodes(N node) {
71     return delegate().adjacentNodes(node);
72   }
73 
74   @Override
75   public Set<N> predecessors(N node) {
76     return delegate().predecessors(node);
77   }
78 
79   @Override
80   public Set<N> successors(N node) {
81     return delegate().successors(node);
82   }
83 
84   @Override
85   public int degree(N node) {
86     return delegate().degree(node);
87   }
88 
89   @Override
90   public int inDegree(N node) {
91     return delegate().inDegree(node);
92   }
93 
94   @Override
95   public int outDegree(N node) {
96     return delegate().outDegree(node);
97   }
98 
99   @Override
100   public boolean hasEdgeConnecting(N nodeU, N nodeV) {
101     return delegate().hasEdgeConnecting(nodeU, nodeV);
102   }
103 
104   @Override
105   public boolean hasEdgeConnecting(EndpointPair<N> endpoints) {
106     return delegate().hasEdgeConnecting(endpoints);
107   }
108 
109   @Override
110   public Optional<V> edgeValue(N nodeU, N nodeV) {
111     return delegate().edgeValue(nodeU, nodeV);
112   }
113 
114   @Override
115   public Optional<V> edgeValue(EndpointPair<N> endpoints) {
116     return delegate().edgeValue(endpoints);
117   }
118 
119   @Override
120   @CheckForNull
121   public V edgeValueOrDefault(N nodeU, N nodeV, @CheckForNull V defaultValue) {
122     return delegate().edgeValueOrDefault(nodeU, nodeV, defaultValue);
123   }
124 
125   @Override
126   @CheckForNull
127   public V edgeValueOrDefault(EndpointPair<N> endpoints, @CheckForNull V defaultValue) {
128     return delegate().edgeValueOrDefault(endpoints, defaultValue);
129   }
130 }