1 /*
2 * Copyright (C) 2013 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
5 * in compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License
10 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
11 * or implied. See the License for the specific language governing permissions and limitations under
12 * the License.
13 */
14
15 package com.google.common.collect;
16
17 import com.google.common.annotations.GwtCompatible;
18 import com.google.errorprone.annotations.CanIgnoreReturnValue;
19 import com.google.errorprone.annotations.concurrent.LazyInit;
20 import com.google.j2objc.annotations.WeakOuter;
21 import java.util.AbstractCollection;
22 import java.util.AbstractSet;
23 import java.util.Collection;
24 import java.util.Iterator;
25 import java.util.Map;
26 import java.util.Set;
27 import java.util.Spliterator;
28 import org.checkerframework.checker.nullness.qual.Nullable;
29
30 /**
31 * Skeletal, implementation-agnostic implementation of the {@link Table} interface.
32 *
33 * @author Louis Wasserman
34 */
35 @GwtCompatible
36 abstract class AbstractTable<R, C, V> implements Table<R, C, V> {
37
38 @Override
39 public boolean containsRow(@Nullable Object rowKey) {
40 return Maps.safeContainsKey(rowMap(), rowKey);
41 }
42
43 @Override
44 public boolean containsColumn(@Nullable Object columnKey) {
45 return Maps.safeContainsKey(columnMap(), columnKey);
46 }
47
48 @Override
49 public Set<R> rowKeySet() {
50 return rowMap().keySet();
51 }
52
53 @Override
54 public Set<C> columnKeySet() {
55 return columnMap().keySet();
56 }
57
58 @Override
59 public boolean containsValue(@Nullable Object value) {
60 for (Map<C, V> row : rowMap().values()) {
61 if (row.containsValue(value)) {
62 return true;
63 }
64 }
65 return false;
66 }
67
68 @Override
69 public boolean contains(@Nullable Object rowKey, @Nullable Object columnKey) {
70 Map<C, V> row = Maps.safeGet(rowMap(), rowKey);
71 return row != null && Maps.safeContainsKey(row, columnKey);
72 }
73
74 @Override
75 public V get(@Nullable Object rowKey, @Nullable Object columnKey) {
76 Map<C, V> row = Maps.safeGet(rowMap(), rowKey);
77 return (row == null) ? null : Maps.safeGet(row, columnKey);
78 }
79
80 @Override
81 public boolean isEmpty() {
82 return size() == 0;
83 }
84
85 @Override
86 public void clear() {
87 Iterators.clear(cellSet().iterator());
88 }
89
90 @CanIgnoreReturnValue
91 @Override
92 public V remove(@Nullable Object rowKey, @Nullable Object columnKey) {
93 Map<C, V> row = Maps.safeGet(rowMap(), rowKey);
94 return (row == null) ? null : Maps.safeRemove(row, columnKey);
95 }
96
97 @CanIgnoreReturnValue
98 @Override
99 public V put(R rowKey, C columnKey, V value) {
100 return row(rowKey).put(columnKey, value);
101 }
102
103 @Override
104 public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
105 for (Table.Cell<? extends R, ? extends C, ? extends V> cell : table.cellSet()) {
106 put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
107 }
108 }
109
110 @LazyInit private transient @Nullable Set<Cell<R, C, V>> cellSet;
111
112 @Override
113 public Set<Cell<R, C, V>> cellSet() {
114 Set<Cell<R, C, V>> result = cellSet;
115 return (result == null) ? cellSet = createCellSet() : result;
116 }
117
118 Set<Cell<R, C, V>> createCellSet() {
119 return new CellSet();
120 }
121
122 abstract Iterator<Table.Cell<R, C, V>> cellIterator();
123
124 abstract Spliterator<Table.Cell<R, C, V>> cellSpliterator();
125
126 @WeakOuter
127 class CellSet extends AbstractSet<Cell<R, C, V>> {
128 @Override
129 public boolean contains(Object o) {
130 if (o instanceof Cell) {
131 Cell<?, ?, ?> cell = (Cell<?, ?, ?>) o;
132 Map<C, V> row = Maps.safeGet(rowMap(), cell.getRowKey());
133 return row != null
134 && Collections2.safeContains(
135 row.entrySet(), Maps.immutableEntry(cell.getColumnKey(), cell.getValue()));
136 }
137 return false;
138 }
139
140 @Override
141 public boolean remove(@Nullable Object o) {
142 if (o instanceof Cell) {
143 Cell<?, ?, ?> cell = (Cell<?, ?, ?>) o;
144 Map<C, V> row = Maps.safeGet(rowMap(), cell.getRowKey());
145 return row != null
146 && Collections2.safeRemove(
147 row.entrySet(), Maps.immutableEntry(cell.getColumnKey(), cell.getValue()));
148 }
149 return false;
150 }
151
152 @Override
153 public void clear() {
154 AbstractTable.this.clear();
155 }
156
157 @Override
158 public Iterator<Table.Cell<R, C, V>> iterator() {
159 return cellIterator();
160 }
161
162 @Override
163 public Spliterator<Cell<R, C, V>> spliterator() {
164 return cellSpliterator();
165 }
166
167 @Override
168 public int size() {
169 return AbstractTable.this.size();
170 }
171 }
172
173 @LazyInit private transient @Nullable Collection<V> values;
174
175 @Override
176 public Collection<V> values() {
177 Collection<V> result = values;
178 return (result == null) ? values = createValues() : result;
179 }
180
181 Collection<V> createValues() {
182 return new Values();
183 }
184
185 Iterator<V> valuesIterator() {
186 return new TransformedIterator<Cell<R, C, V>, V>(cellSet().iterator()) {
187 @Override
188 V transform(Cell<R, C, V> cell) {
189 return cell.getValue();
190 }
191 };
192 }
193
194 Spliterator<V> valuesSpliterator() {
195 return CollectSpliterators.map(cellSpliterator(), Table.Cell::getValue);
196 }
197
198 @WeakOuter
199 class Values extends AbstractCollection<V> {
200 @Override
201 public Iterator<V> iterator() {
202 return valuesIterator();
203 }
204
205 @Override
206 public Spliterator<V> spliterator() {
207 return valuesSpliterator();
208 }
209
210 @Override
211 public boolean contains(Object o) {
212 return containsValue(o);
213 }
214
215 @Override
216 public void clear() {
217 AbstractTable.this.clear();
218 }
219
220 @Override
221 public int size() {
222 return AbstractTable.this.size();
223 }
224 }
225
226 @Override
227 public boolean equals(@Nullable Object obj) {
228 return Tables.equalsImpl(this, obj);
229 }
230
231 @Override
232 public int hashCode() {
233 return cellSet().hashCode();
234 }
235
236 /** Returns the string representation {@code rowMap().toString()}. */
237 @Override
238 public String toString() {
239 return rowMap().toString();
240 }
241 }