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