/*
 * 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);
        }
    }
}