001 /*
002 * Copyright (C) 2009 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package com.google.common.collect;
018
019 import static com.google.common.base.Preconditions.checkArgument;
020 import static com.google.common.base.Preconditions.checkNotNull;
021
022 import com.google.common.annotations.Beta;
023 import com.google.common.base.Objects;
024
025 import java.io.Serializable;
026 import java.lang.reflect.Array;
027 import java.util.AbstractCollection;
028 import java.util.AbstractMap;
029 import java.util.AbstractSet;
030 import java.util.Arrays;
031 import java.util.Collection;
032 import java.util.Iterator;
033 import java.util.Map;
034 import java.util.Map.Entry;
035 import java.util.Set;
036
037 import javax.annotation.Nullable;
038
039 /**
040 * Fixed-size {@link Table} implementation backed by a two-dimensional array.
041 *
042 * <p>The allowed row and column keys must be supplied when the table is
043 * created. The table always contains a mapping for every row key / column pair.
044 * The value corresponding to a given row and column is null unless another
045 * value is provided.
046 *
047 * <p>The table's size is constant: the product of the number of supplied row
048 * keys and the number of supplied column keys. The {@code remove} and {@code
049 * clear} methods are not supported by the table or its views. The {@link
050 * #erase} and {@link #eraseAll} methods may be used instead.
051 *
052 * <p>The ordering of the row and column keys provided when the table is
053 * constructed determines the iteration ordering across rows and columns in the
054 * table's views. None of the view iterators support {@link Iterator#remove}.
055 * If the table is modified after an iterator is created, the iterator remains
056 * valid.
057 *
058 * <p>This class requires less memory than the {@link HashBasedTable} and {@link
059 * TreeBasedTable} implementations, except when the table is sparse.
060 *
061 * <p>Null row keys or column keys are not permitted.
062 *
063 * <p>This class provides methods involving the underlying array structure,
064 * where the array indices correspond to the position of a row or column in the
065 * lists of allowed keys and values. See the {@link #at}, {@link #set}, {@link
066 * #toArray}, {@link #rowKeyList}, and {@link #columnKeyList} methods for more
067 * details.
068 *
069 * <p>Note that this implementation is not synchronized. If multiple threads
070 * access the same cell of an {@code ArrayTable} concurrently and one of the
071 * threads modifies its value, there is no guarantee that the new value will be
072 * fully visible to the other threads. To guarantee that modifications are
073 * visible, synchronize access to the table. Unlike other {@code Table}
074 * implementations, synchronization is unnecessary between a thread that writes
075 * to one cell and a thread that reads from another.
076 *
077 * @author Jared Levy
078 * @since 10.0
079 */
080 @Beta
081 public final class ArrayTable<R, C, V> implements Table<R, C, V>, Serializable {
082
083 /**
084 * Creates an empty {@code ArrayTable}.
085 *
086 * @param rowKeys row keys that may be stored in the generated table
087 * @param columnKeys column keys that may be stored in the generated table
088 * @throws NullPointerException if any of the provided keys is null
089 * @throws IllegalArgumentException if {@code rowKeys} or {@code columnKeys}
090 * contains duplicates or is empty
091 */
092 public static <R, C, V> ArrayTable<R, C, V> create(
093 Iterable<? extends R> rowKeys, Iterable<? extends C> columnKeys) {
094 return new ArrayTable<R, C, V>(rowKeys, columnKeys);
095 }
096
097 /*
098 * TODO(jlevy): Add factory methods taking an Enum class, instead of an
099 * iterable, to specify the allowed row keys and/or column keys. Note that
100 * custom serialization logic is needed to support different enum sizes during
101 * serialization and deserialization.
102 */
103
104 /**
105 * Creates an {@code ArrayTable} with the mappings in the provided table.
106 *
107 * <p>If {@code table} includes a mapping with row key {@code r} and a
108 * separate mapping with column key {@code c}, the returned table contains a
109 * mapping with row key {@code r} and column key {@code c}. If that row key /
110 * column key pair in not in {@code table}, the pair maps to {@code null} in
111 * the generated table.
112 *
113 * <p>The returned table allows subsequent {@code put} calls with the row keys
114 * in {@code table.rowKeySet()} and the column keys in {@code
115 * table.columnKeySet()}. Calling {@link #put} with other keys leads to an
116 * {@code IllegalArgumentException}.
117 *
118 * <p>The ordering of {@code table.rowKeySet()} and {@code
119 * table.columnKeySet()} determines the row and column iteration ordering of
120 * the returned table.
121 *
122 * @throws NullPointerException if {@code table} has a null key
123 * @throws IllegalArgumentException if the provided table is empty
124 */
125 public static <R, C, V> ArrayTable<R, C, V> create(Table<R, C, V> table) {
126 return new ArrayTable<R, C, V>(table);
127 }
128
129 /**
130 * Creates an {@code ArrayTable} with the same mappings, allowed keys, and
131 * iteration ordering as the provided {@code ArrayTable}.
132 */
133 public static <R, C, V> ArrayTable<R, C, V> create(
134 ArrayTable<R, C, V> table) {
135 return new ArrayTable<R, C, V>(table);
136 }
137
138 private final ImmutableList<R> rowList;
139 private final ImmutableList<C> columnList;
140
141 // TODO(jlevy): Add getters returning rowKeyToIndex and columnKeyToIndex?
142 private final ImmutableMap<R, Integer> rowKeyToIndex;
143 private final ImmutableMap<C, Integer> columnKeyToIndex;
144 private final V[][] array;
145
146 private ArrayTable(Iterable<? extends R> rowKeys,
147 Iterable<? extends C> columnKeys) {
148 this.rowList = ImmutableList.copyOf(rowKeys);
149 this.columnList = ImmutableList.copyOf(columnKeys);
150 checkArgument(!rowList.isEmpty());
151 checkArgument(!columnList.isEmpty());
152
153 /*
154 * TODO(jlevy): Support empty rowKeys or columnKeys? If we do, when
155 * columnKeys is empty but rowKeys isn't, the table is empty but
156 * containsRow() can return true and rowKeySet() isn't empty.
157 */
158 ImmutableMap.Builder<R, Integer> rowBuilder = ImmutableMap.builder();
159 for (int i = 0; i < rowList.size(); i++) {
160 rowBuilder.put(rowList.get(i), i);
161 }
162 rowKeyToIndex = rowBuilder.build();
163
164 ImmutableMap.Builder<C, Integer> columnBuilder = ImmutableMap.builder();
165 for (int i = 0; i < columnList.size(); i++) {
166 columnBuilder.put(columnList.get(i), i);
167 }
168 columnKeyToIndex = columnBuilder.build();
169
170 @SuppressWarnings("unchecked")
171 V[][] tmpArray
172 = (V[][]) new Object[rowList.size()][columnList.size()];
173 array = tmpArray;
174 }
175
176 private ArrayTable(Table<R, C, V> table) {
177 this(table.rowKeySet(), table.columnKeySet());
178 putAll(table);
179 }
180
181 private ArrayTable(ArrayTable<R, C, V> table) {
182 rowList = table.rowList;
183 columnList = table.columnList;
184 rowKeyToIndex = table.rowKeyToIndex;
185 columnKeyToIndex = table.columnKeyToIndex;
186 @SuppressWarnings("unchecked")
187 V[][] copy = (V[][]) new Object[rowList.size()][columnList.size()];
188 array = copy;
189 for (int i = 0; i < rowList.size(); i++) {
190 System.arraycopy(table.array[i], 0, copy[i], 0, table.array[i].length);
191 }
192 }
193
194 /**
195 * Returns, as an immutable list, the row keys provided when the table was
196 * constructed, including those that are mapped to null values only.
197 */
198 public ImmutableList<R> rowKeyList() {
199 return rowList;
200 }
201
202 /**
203 * Returns, as an immutable list, the column keys provided when the table was
204 * constructed, including those that are mapped to null values only.
205 */
206 public ImmutableList<C> columnKeyList() {
207 return columnList;
208 }
209
210 /**
211 * Returns the value corresponding to the specified row and column indices.
212 * The same value is returned by {@code
213 * get(rowKeyList().get(rowIndex), columnKeyList().get(columnIndex))}, but
214 * this method runs more quickly.
215 *
216 * @param rowIndex position of the row key in {@link #rowKeyList()}
217 * @param columnIndex position of the row key in {@link #columnKeyList()}
218 * @return the value with the specified row and column
219 * @throws IndexOutOfBoundsException if either index is negative, {@code
220 * rowIndex} is greater then or equal to the number of allowed row keys,
221 * or {@code columnIndex} is greater then or equal to the number of
222 * allowed column keys
223 */
224 public V at(int rowIndex, int columnIndex) {
225 return array[rowIndex][columnIndex];
226 }
227
228 /**
229 * Associates {@code value} with the specified row and column indices. The
230 * logic {@code
231 * put(rowKeyList().get(rowIndex), columnKeyList().get(columnIndex), value)}
232 * has the same behavior, but this method runs more quickly.
233 *
234 * @param rowIndex position of the row key in {@link #rowKeyList()}
235 * @param columnIndex position of the row key in {@link #columnKeyList()}
236 * @param value value to store in the table
237 * @return the previous value with the specified row and column
238 * @throws IndexOutOfBoundsException if either index is negative, {@code
239 * rowIndex} is greater then or equal to the number of allowed row keys,
240 * or {@code columnIndex} is greater then or equal to the number of
241 * allowed column keys
242 */
243 public V set(int rowIndex, int columnIndex, @Nullable V value) {
244 V oldValue = array[rowIndex][columnIndex];
245 array[rowIndex][columnIndex] = value;
246 return oldValue;
247 }
248
249 /**
250 * Returns a two-dimensional array with the table contents. The row and column
251 * indices correspond to the positions of the row and column in the iterables
252 * provided during table construction. If the table lacks a mapping for a
253 * given row and column, the corresponding array element is null.
254 *
255 * <p>Subsequent table changes will not modify the array, and vice versa.
256 *
257 * @param valueClass class of values stored in the returned array
258 */
259 public V[][] toArray(Class<V> valueClass) {
260 // Can change to use varargs in JDK 1.6 if we want
261 @SuppressWarnings("unchecked") // TODO: safe?
262 V[][] copy = (V[][]) Array.newInstance(
263 valueClass, new int[] { rowList.size(), columnList.size() });
264 for (int i = 0; i < rowList.size(); i++) {
265 System.arraycopy(array[i], 0, copy[i], 0, array[i].length);
266 }
267 return copy;
268 }
269
270 /**
271 * Not supported. Use {@link #eraseAll} instead.
272 *
273 * @throws UnsupportedOperationException always
274 * @deprecated Use {@link #eraseAll}
275 */
276 @Override
277 @Deprecated public void clear() {
278 throw new UnsupportedOperationException();
279 }
280
281 /**
282 * Associates the value {@code null} with every pair of allowed row and column
283 * keys.
284 */
285 public void eraseAll() {
286 for (V[] row : array) {
287 Arrays.fill(row, null);
288 }
289 }
290
291 /**
292 * Returns {@code true} if the provided keys are among the keys provided when
293 * the table was constructed.
294 */
295 @Override
296 public boolean contains(@Nullable Object rowKey, @Nullable Object columnKey) {
297 return containsRow(rowKey) && containsColumn(columnKey);
298 }
299
300 /**
301 * Returns {@code true} if the provided column key is among the column keys
302 * provided when the table was constructed.
303 */
304 @Override
305 public boolean containsColumn(@Nullable Object columnKey) {
306 return columnKeyToIndex.containsKey(columnKey);
307 }
308
309 /**
310 * Returns {@code true} if the provided row key is among the row keys
311 * provided when the table was constructed.
312 */
313 @Override
314 public boolean containsRow(@Nullable Object rowKey) {
315 return rowKeyToIndex.containsKey(rowKey);
316 }
317
318 @Override
319 public boolean containsValue(@Nullable Object value) {
320 for (V[] row : array) {
321 for (V element : row) {
322 if (Objects.equal(value, element)) {
323 return true;
324 }
325 }
326 }
327 return false;
328 }
329
330 @Override
331 public V get(@Nullable Object rowKey, @Nullable Object columnKey) {
332 Integer rowIndex = rowKeyToIndex.get(rowKey);
333 Integer columnIndex = columnKeyToIndex.get(columnKey);
334 return getIndexed(rowIndex, columnIndex);
335 }
336
337 private V getIndexed(Integer rowIndex, Integer columnIndex) {
338 return (rowIndex == null || columnIndex == null)
339 ? null : array[rowIndex][columnIndex];
340 }
341
342 /**
343 * Always returns {@code false}.
344 */
345 @Override
346 public boolean isEmpty() {
347 return false;
348 }
349
350 /**
351 * {@inheritDoc}
352 *
353 * @throws IllegalArgumentException if {@code rowKey} is not in {@link
354 * #rowKeySet()} or {@code columnKey} is not in {@link #columnKeySet()}.
355 */
356 @Override
357 public V put(R rowKey, C columnKey, @Nullable V value) {
358 checkNotNull(rowKey);
359 checkNotNull(columnKey);
360 Integer rowIndex = rowKeyToIndex.get(rowKey);
361 checkArgument(rowIndex != null, "Row %s not in %s", rowKey, rowList);
362 Integer columnIndex = columnKeyToIndex.get(columnKey);
363 checkArgument(columnIndex != null,
364 "Column %s not in %s", columnKey, columnList);
365 return set(rowIndex, columnIndex, value);
366 }
367
368 /*
369 * TODO(jlevy): Consider creating a merge() method, similar to putAll() but
370 * copying non-null values only.
371 */
372
373 /**
374 * {@inheritDoc}
375 *
376 * <p>If {@code table} is an {@code ArrayTable}, its null values will be
377 * stored in this table, possibly replacing values that were previously
378 * non-null.
379 *
380 * @throws NullPointerException if {@code table} has a null key
381 * @throws IllegalArgumentException if any of the provided table's row keys or
382 * column keys is not in {@link #rowKeySet()} or {@link #columnKeySet()}
383 */
384 @Override
385 public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
386 for (Cell<? extends R, ? extends C, ? extends V> cell : table.cellSet()) {
387 put(cell.getRowKey(), cell.getColumnKey(), cell.getValue());
388 }
389 }
390
391 /**
392 * Not supported. Use {@link #erase} instead.
393 *
394 * @throws UnsupportedOperationException always
395 * @deprecated Use {@link #erase}
396 */
397 @Override
398 @Deprecated public V remove(Object rowKey, Object columnKey) {
399 throw new UnsupportedOperationException();
400 }
401
402 /**
403 * Associates the value {@code null} with the specified keys, assuming both
404 * keys are valid. If either key is null or isn't among the keys provided
405 * during construction, this method has no effect.
406 *
407 * <p>This method is equivalent to {@code put(rowKey, columnKey, null)} when
408 * both provided keys are valid.
409 *
410 * @param rowKey row key of mapping to be erased
411 * @param columnKey column key of mapping to be erased
412 * @return the value previously associated with the keys, or {@code null} if
413 * no mapping existed for the keys
414 */
415 public V erase(@Nullable Object rowKey, @Nullable Object columnKey) {
416 Integer rowIndex = rowKeyToIndex.get(rowKey);
417 Integer columnIndex = columnKeyToIndex.get(columnKey);
418 if (rowIndex == null || columnIndex == null) {
419 return null;
420 }
421 return set(rowIndex, columnIndex, null);
422 }
423
424 // TODO(jlevy): Add eraseRow and eraseColumn methods?
425
426 @Override
427 public int size() {
428 return rowList.size() * columnList.size();
429 }
430
431 @Override public boolean equals(@Nullable Object obj) {
432 if (obj instanceof Table) {
433 Table<?, ?, ?> other = (Table<?, ?, ?>) obj;
434 return cellSet().equals(other.cellSet());
435 }
436 return false;
437 }
438
439 @Override public int hashCode() {
440 return cellSet().hashCode();
441 }
442
443 /**
444 * Returns the string representation {@code rowMap().toString()}.
445 */
446 @Override public String toString() {
447 return rowMap().toString();
448 }
449
450 private transient CellSet cellSet;
451
452 /**
453 * Returns an unmodifiable set of all row key / column key / value
454 * triplets. Changes to the table will update the returned set.
455 *
456 * <p>The returned set's iterator traverses the mappings with the first row
457 * key, the mappings with the second row key, and so on.
458 *
459 * <p>The value in the returned cells may change if the table subsequently
460 * changes.
461 *
462 * @return set of table cells consisting of row key / column key / value
463 * triplets
464 */
465 @Override
466 public Set<Cell<R, C, V>> cellSet() {
467 CellSet set = cellSet;
468 return (set == null) ? cellSet = new CellSet() : set;
469 }
470
471 private class CellSet extends AbstractSet<Cell<R, C, V>> {
472
473 @Override public Iterator<Cell<R, C, V>> iterator() {
474 return new AbstractIndexedListIterator<Cell<R, C, V>>(size()) {
475 @Override protected Cell<R, C, V> get(final int index) {
476 return new Tables.AbstractCell<R, C, V>() {
477 final int rowIndex = index / columnList.size();
478 final int columnIndex = index % columnList.size();
479 @Override
480 public R getRowKey() {
481 return rowList.get(rowIndex);
482 }
483 @Override
484 public C getColumnKey() {
485 return columnList.get(columnIndex);
486 }
487 @Override
488 public V getValue() {
489 return array[rowIndex][columnIndex];
490 }
491 };
492 }
493 };
494 }
495
496 @Override public int size() {
497 return ArrayTable.this.size();
498 }
499
500 @Override public boolean contains(Object obj) {
501 if (obj instanceof Cell) {
502 Cell<?, ?, ?> cell = (Cell<?, ?, ?>) obj;
503 Integer rowIndex = rowKeyToIndex.get(cell.getRowKey());
504 Integer columnIndex = columnKeyToIndex.get(cell.getColumnKey());
505 return rowIndex != null
506 && columnIndex != null
507 && Objects.equal(array[rowIndex][columnIndex], cell.getValue());
508 }
509 return false;
510 }
511 }
512
513 /**
514 * Returns a view of all mappings that have the given column key. If the
515 * column key isn't in {@link #columnKeySet()}, an empty immutable map is
516 * returned.
517 *
518 * <p>Otherwise, for each row key in {@link #rowKeySet()}, the returned map
519 * associates the row key with the corresponding value in the table. Changes
520 * to the returned map will update the underlying table, and vice versa.
521 *
522 * @param columnKey key of column to search for in the table
523 * @return the corresponding map from row keys to values
524 */
525 @Override
526 public Map<R, V> column(C columnKey) {
527 checkNotNull(columnKey);
528 Integer columnIndex = columnKeyToIndex.get(columnKey);
529 return (columnIndex == null)
530 ? ImmutableMap.<R, V>of() : new Column(columnIndex);
531 }
532
533 private class Column extends AbstractMap<R, V> {
534 final int columnIndex;
535
536 Column(int columnIndex) {
537 this.columnIndex = columnIndex;
538 }
539
540 ColumnEntrySet entrySet;
541
542 @Override public Set<Entry<R, V>> entrySet() {
543 ColumnEntrySet set = entrySet;
544 return (set == null) ? entrySet = new ColumnEntrySet(columnIndex) : set;
545 }
546
547 @Override public V get(Object rowKey) {
548 Integer rowIndex = rowKeyToIndex.get(rowKey);
549 return getIndexed(rowIndex, columnIndex);
550 }
551
552 @Override public boolean containsKey(Object rowKey) {
553 return rowKeyToIndex.containsKey(rowKey);
554 }
555
556 @Override public V put(R rowKey, V value) {
557 checkNotNull(rowKey);
558 Integer rowIndex = rowKeyToIndex.get(rowKey);
559 checkArgument(rowIndex != null, "Row %s not in %s", rowKey, rowList);
560 return set(rowIndex, columnIndex, value);
561 }
562
563 @Override public Set<R> keySet() {
564 return rowKeySet();
565 }
566 }
567
568 private class ColumnEntrySet extends AbstractSet<Entry<R, V>> {
569 final int columnIndex;
570
571 ColumnEntrySet(int columnIndex) {
572 this.columnIndex = columnIndex;
573 }
574
575 @Override public Iterator<Entry<R, V>> iterator() {
576 return new AbstractIndexedListIterator<Entry<R, V>>(size()) {
577 @Override protected Entry<R, V> get(final int rowIndex) {
578 return new AbstractMapEntry<R, V>() {
579 @Override public R getKey() {
580 return rowList.get(rowIndex);
581 }
582 @Override public V getValue() {
583 return array[rowIndex][columnIndex];
584 }
585 @Override public V setValue(V value) {
586 return ArrayTable.this.set(rowIndex, columnIndex, value);
587 }
588 };
589 }
590 };
591 }
592
593 @Override public int size() {
594 return rowList.size();
595 }
596 }
597
598 /**
599 * Returns an immutable set of the valid column keys, including those that
600 * are associated with null values only.
601 *
602 * @return immutable set of column keys
603 */
604 @Override
605 public ImmutableSet<C> columnKeySet() {
606 return columnKeyToIndex.keySet();
607 }
608
609 private transient ColumnMap columnMap;
610
611 @Override
612 public Map<C, Map<R, V>> columnMap() {
613 ColumnMap map = columnMap;
614 return (map == null) ? columnMap = new ColumnMap() : map;
615 }
616
617 private class ColumnMap extends AbstractMap<C, Map<R, V>> {
618 transient ColumnMapEntrySet entrySet;
619
620 @Override public Set<Entry<C, Map<R, V>>> entrySet() {
621 ColumnMapEntrySet set = entrySet;
622 return (set == null) ? entrySet = new ColumnMapEntrySet() : set;
623 }
624
625 @Override public Map<R, V> get(Object columnKey) {
626 Integer columnIndex = columnKeyToIndex.get(columnKey);
627 return (columnIndex == null) ? null : new Column(columnIndex);
628 }
629
630 @Override public boolean containsKey(Object columnKey) {
631 return containsColumn(columnKey);
632 }
633
634 @Override public Set<C> keySet() {
635 return columnKeySet();
636 }
637
638 @Override public Map<R, V> remove(Object columnKey) {
639 throw new UnsupportedOperationException();
640 }
641 }
642
643 private class ColumnMapEntrySet extends AbstractSet<Entry<C, Map<R, V>>> {
644 @Override public Iterator<Entry<C, Map<R, V>>> iterator() {
645 return new AbstractIndexedListIterator<Entry<C, Map<R, V>>>(size()) {
646 @Override protected Entry<C, Map<R, V>> get(int index) {
647 return Maps.<C, Map<R, V>>immutableEntry(columnList.get(index),
648 new Column(index));
649 }
650 };
651 }
652
653 @Override public int size() {
654 return columnList.size();
655 }
656 }
657
658 /**
659 * Returns a view of all mappings that have the given row key. If the
660 * row key isn't in {@link #rowKeySet()}, an empty immutable map is
661 * returned.
662 *
663 * <p>Otherwise, for each column key in {@link #columnKeySet()}, the returned
664 * map associates the column key with the corresponding value in the
665 * table. Changes to the returned map will update the underlying table, and
666 * vice versa.
667 *
668 * @param rowKey key of row to search for in the table
669 * @return the corresponding map from column keys to values
670 */
671 @Override
672 public Map<C, V> row(R rowKey) {
673 checkNotNull(rowKey);
674 Integer rowIndex = rowKeyToIndex.get(rowKey);
675 return (rowIndex == null) ? ImmutableMap.<C, V>of() : new Row(rowIndex);
676 }
677
678 private class Row extends AbstractMap<C, V> {
679 final int rowIndex;
680
681 Row(int rowIndex) {
682 this.rowIndex = rowIndex;
683 }
684
685 RowEntrySet entrySet;
686
687 @Override public Set<Entry<C, V>> entrySet() {
688 RowEntrySet set = entrySet;
689 return (set == null) ? entrySet = new RowEntrySet(rowIndex) : set;
690 }
691
692 @Override public V get(Object columnKey) {
693 Integer columnIndex = columnKeyToIndex.get(columnKey);
694 return getIndexed(rowIndex, columnIndex);
695 }
696
697 @Override public boolean containsKey(Object columnKey) {
698 return containsColumn(columnKey);
699 }
700
701 @Override public V put(C columnKey, V value) {
702 checkNotNull(columnKey);
703 Integer columnIndex = columnKeyToIndex.get(columnKey);
704 checkArgument(columnIndex != null,
705 "Column %s not in %s", columnKey, columnList);
706 return set(rowIndex, columnIndex, value);
707 }
708
709 @Override public Set<C> keySet() {
710 return columnKeySet();
711 }
712 }
713
714 private class RowEntrySet extends AbstractSet<Entry<C, V>> {
715 final int rowIndex;
716
717 RowEntrySet(int rowIndex) {
718 this.rowIndex = rowIndex;
719 }
720
721 @Override public Iterator<Entry<C, V>> iterator() {
722 return new AbstractIndexedListIterator<Entry<C, V>>(size()) {
723 @Override protected Entry<C, V> get(final int columnIndex) {
724 return new AbstractMapEntry<C, V>() {
725 @Override public C getKey() {
726 return columnList.get(columnIndex);
727 }
728 @Override public V getValue() {
729 return array[rowIndex][columnIndex];
730 }
731 @Override public V setValue(V value) {
732 return ArrayTable.this.set(rowIndex, columnIndex, value);
733 }
734 };
735 }
736 };
737 }
738
739 @Override public int size() {
740 return columnList.size();
741 }
742 }
743
744 /**
745 * Returns an immutable set of the valid row keys, including those that are
746 * associated with null values only.
747 *
748 * @return immutable set of row keys
749 */
750 @Override
751 public ImmutableSet<R> rowKeySet() {
752 return rowKeyToIndex.keySet();
753 }
754
755 private transient RowMap rowMap;
756
757 @Override
758 public Map<R, Map<C, V>> rowMap() {
759 RowMap map = rowMap;
760 return (map == null) ? rowMap = new RowMap() : map;
761 }
762
763 private class RowMap extends AbstractMap<R, Map<C, V>> {
764 transient RowMapEntrySet entrySet;
765
766 @Override public Set<Entry<R, Map<C, V>>> entrySet() {
767 RowMapEntrySet set = entrySet;
768 return (set == null) ? entrySet = new RowMapEntrySet() : set;
769 }
770
771 @Override public Map<C, V> get(Object rowKey) {
772 Integer rowIndex = rowKeyToIndex.get(rowKey);
773 return (rowIndex == null) ? null : new Row(rowIndex);
774 }
775
776 @Override public boolean containsKey(Object rowKey) {
777 return containsRow(rowKey);
778 }
779
780 @Override public Set<R> keySet() {
781 return rowKeySet();
782 }
783
784 @Override public Map<C, V> remove(Object rowKey) {
785 throw new UnsupportedOperationException();
786 }
787 }
788
789 private class RowMapEntrySet extends AbstractSet<Entry<R, Map<C, V>>> {
790 @Override public Iterator<Entry<R, Map<C, V>>> iterator() {
791 return new AbstractIndexedListIterator<Entry<R, Map<C, V>>>(size()) {
792 @Override protected Entry<R, Map<C, V>> get(int index) {
793 return Maps.<R, Map<C, V>>immutableEntry(rowList.get(index),
794 new Row(index));
795 }
796 };
797 }
798
799 @Override public int size() {
800 return rowList.size();
801 }
802 }
803
804 private transient Collection<V> values;
805
806 /**
807 * Returns an unmodifiable collection of all values, which may contain
808 * duplicates. Changes to the table will update the returned collection.
809 *
810 * <p>The returned collection's iterator traverses the values of the first row
811 * key, the values of the second row key, and so on.
812 *
813 * @return collection of values
814 */
815 @Override
816 public Collection<V> values() {
817 Collection<V> v = values;
818 return (v == null) ? values = new Values() : v;
819 }
820
821 private class Values extends AbstractCollection<V> {
822 @Override public Iterator<V> iterator() {
823 return new AbstractIndexedListIterator<V>(size()) {
824 @Override protected V get(int index) {
825 int rowIndex = index / columnList.size();
826 int columnIndex = index % columnList.size();
827 return array[rowIndex][columnIndex];
828 }
829 };
830 }
831
832 @Override public int size() {
833 return ArrayTable.this.size();
834 }
835
836 @Override public boolean contains(Object value) {
837 return containsValue(value);
838 }
839 }
840
841 private static final long serialVersionUID = 0;
842 }