/*
 * Copyright (C) 2008 The Guava Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.glassfish.jersey.internal.guava;

import java.io.Serializable;
import java.util.Iterator;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;

import static org.glassfish.jersey.internal.guava.Preconditions.checkNotNull;

Provides static methods that involve a Table.

See the Guava User Guide article on Tables.

Author:Jared Levy, Louis Wasserman
Since:7.0
/** * Provides static methods that involve a {@code Table}. * <p> * <p>See the Guava User Guide article on <a href= * "http://code.google.com/p/guava-libraries/wiki/CollectionUtilitiesExplained#Tables"> * {@code Tables}</a>. * * @author Jared Levy * @author Louis Wasserman * @since 7.0 */
public final class Tables { private Tables() { }
Returns an immutable cell with the specified row key, column key, and value.

The returned cell is serializable.

Params:
  • rowKey – the row key to be associated with the returned cell
  • columnKey – the column key to be associated with the returned cell
  • value – the value to be associated with the returned cell
/** * Returns an immutable cell with the specified row key, column key, and * value. * <p> * <p>The returned cell is serializable. * * @param rowKey the row key to be associated with the returned cell * @param columnKey the column key to be associated with the returned cell * @param value the value to be associated with the returned cell */
public static <R, C, V> Table.Cell<R, C, V> immutableCell( R rowKey, C columnKey, V value) { return new ImmutableCell<R, C, V>(rowKey, columnKey, value); }
Creates a transposed view of a given table that flips its row and column keys. In other words, calling get(columnKey, rowKey) on the generated table always returns the same value as calling get(rowKey, columnKey) on the original table. Updating the original table changes the contents of the transposed table and vice versa.

The returned table supports update operations as long as the input table supports the analogous operation with swapped rows and columns. For example, in a HashBasedTable instance, rowKeySet().iterator() supports remove() but columnKeySet().iterator() doesn't. With a transposed HashBasedTable, it's the other way around.

/** * Creates a transposed view of a given table that flips its row and column * keys. In other words, calling {@code get(columnKey, rowKey)} on the * generated table always returns the same value as calling {@code * get(rowKey, columnKey)} on the original table. Updating the original table * changes the contents of the transposed table and vice versa. * <p> * <p>The returned table supports update operations as long as the input table * supports the analogous operation with swapped rows and columns. For * example, in a {@link HashBasedTable} instance, {@code * rowKeySet().iterator()} supports {@code remove()} but {@code * columnKeySet().iterator()} doesn't. With a transposed {@link * HashBasedTable}, it's the other way around. */
private static <R, C, V> Table<C, R, V> transpose(Table<R, C, V> table) { return (table instanceof TransposeTable) ? ((TransposeTable<R, C, V>) table).original : new TransposeTable<C, R, V>(table); } static boolean equalsImpl(Table<?, ?, ?> table, Object obj) { if (obj == table) { return true; } else if (obj instanceof Table) { Table<?, ?, ?> that = (Table<?, ?, ?>) obj; return table.cellSet().equals(that.cellSet()); } else { return false; } } static final class ImmutableCell<R, C, V> extends AbstractCell<R, C, V> implements Serializable { private static final long serialVersionUID = 0; private final R rowKey; private final C columnKey; private final V value; ImmutableCell( R rowKey, C columnKey, V value) { this.rowKey = rowKey; this.columnKey = columnKey; this.value = value; } @Override public R getRowKey() { return rowKey; } @Override public C getColumnKey() { return columnKey; } @Override public V getValue() { return value; } } abstract static class AbstractCell<R, C, V> implements Table.Cell<R, C, V> { // needed for serialization AbstractCell() { } @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (obj instanceof Table.Cell) { Table.Cell<?, ?, ?> other = (Table.Cell<?, ?, ?>) obj; return Objects.equals(getRowKey(), other.getRowKey()) && Objects.equals(getColumnKey(), other.getColumnKey()) && Objects.equals(getValue(), other.getValue()); } return false; } @Override public int hashCode() { return Objects.hash(getRowKey(), getColumnKey(), getValue()); } @Override public String toString() { return "(" + getRowKey() + "," + getColumnKey() + ")=" + getValue(); } } private static class TransposeTable<C, R, V> extends AbstractTable<C, R, V> { // Will cast TRANSPOSE_CELL to a type that always succeeds private static final Function<Cell<?, ?, ?>, Cell<?, ?, ?>> TRANSPOSE_CELL = new Function<Cell<?, ?, ?>, Cell<?, ?, ?>>() { @Override public Cell<?, ?, ?> apply(Cell<?, ?, ?> cell) { return immutableCell( cell.getColumnKey(), cell.getRowKey(), cell.getValue()); } }; final Table<R, C, V> original; TransposeTable(Table<R, C, V> original) { this.original = checkNotNull(original); } @Override public void clear() { original.clear(); } @Override public Map<C, V> column(R columnKey) { return original.row(columnKey); } @Override public Set<R> columnKeySet() { return original.rowKeySet(); } @Override public Map<R, Map<C, V>> columnMap() { return original.rowMap(); } @Override public boolean contains( Object rowKey, Object columnKey) { return original.contains(columnKey, rowKey); } @Override public boolean containsColumn(Object columnKey) { return original.containsRow(columnKey); } @Override public boolean containsRow(Object rowKey) { return original.containsColumn(rowKey); } @Override public boolean containsValue(Object value) { return original.containsValue(value); } @Override public V get(Object rowKey, Object columnKey) { return original.get(columnKey, rowKey); } @Override public V put(C rowKey, R columnKey, V value) { return original.put(columnKey, rowKey, value); } @Override public void putAll(Table<? extends C, ? extends R, ? extends V> table) { original.putAll(transpose(table)); } @Override public V remove(Object rowKey, Object columnKey) { return original.remove(columnKey, rowKey); } @Override public Map<R, V> row(C rowKey) { return original.column(rowKey); } @Override public Set<C> rowKeySet() { return original.columnKeySet(); } @Override public Map<C, Map<R, V>> rowMap() { return original.columnMap(); } @Override public int size() { return original.size(); } @SuppressWarnings("unchecked") @Override Iterator<Cell<C, R, V>> cellIterator() { return Iterators.transform(original.cellSet().iterator(), (Function) TRANSPOSE_CELL); } } }