How to use

Tables$TransformedTable

in

com.google.common.collect

/**
 * Returns a view of a table where each value is transformed by a function. All other properties
 * of the table, such as iteration order, are left intact.
 *
 * <p>Changes in the underlying table are reflected in this view. Conversely, this view supports
 * removal operations, and these are reflected in the underlying table.
 *
 * <p>It's acceptable for the underlying table to contain null keys, and even null values provided
 * that the function is capable of accepting null input. The transformed table might contain null
 * values, if the function sometimes gives a null result.
 *
 * <p>The returned table is not thread-safe or serializable, even if the underlying table is.
 *
 * <p>The function is applied lazily, invoked when needed. This is necessary for the returned
 * table to be a view, but it means that the function will be applied many times for bulk
 * operations like {@link Table#containsValue} and {@code Table.toString()}. For this to perform
 * well, {@code function} should be fast. To avoid lazy evaluation when the returned table doesn't
 * need to be a view, copy the returned table into a new table of your choosing.
 *
 * @since 10.0
 */
@Beta
public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<>(fromTable, function);
}

@Override
public V2 get(Object rowKey, Object columnKey) {
 // The function is passed a null input only when the table contains a null
 // value.
 return contains(rowKey, columnKey) ? function.apply(fromTable.get(rowKey, columnKey)) : null;
}

@Override
Iterator<Cell<R, C, V2>> cellIterator() {
 return Iterators.transform(fromTable.cellSet().iterator(), cellFunction());
}

@Override
public V2 remove(Object rowKey, Object columnKey) {
 return contains(rowKey, columnKey)
   ? function.apply(fromTable.remove(rowKey, columnKey))
   : null;
}

/**
 * Returns a view of a table where each value is transformed by a function. All other properties
 * of the table, such as iteration order, are left intact.
 *
 * <p>Changes in the underlying table are reflected in this view. Conversely, this view supports
 * removal operations, and these are reflected in the underlying table.
 *
 * <p>It's acceptable for the underlying table to contain null keys, and even null values provided
 * that the function is capable of accepting null input. The transformed table might contain null
 * values, if the function sometimes gives a null result.
 *
 * <p>The returned table is not thread-safe or serializable, even if the underlying table is.
 *
 * <p>The function is applied lazily, invoked when needed. This is necessary for the returned
 * table to be a view, but it means that the function will be applied many times for bulk
 * operations like {@link Table#containsValue} and {@code Table.toString()}. For this to perform
 * well, {@code function} should be fast. To avoid lazy evaluation when the returned table doesn't
 * need to be a view, copy the returned table into a new table of your choosing.
 *
 * @since 10.0
 */
@Beta
public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<>(fromTable, function);
}

/**
 * Returns a view of a table where each value is transformed by a function. All other properties
 * of the table, such as iteration order, are left intact.
 *
 * <p>Changes in the underlying table are reflected in this view. Conversely, this view supports
 * removal operations, and these are reflected in the underlying table.
 *
 * <p>It's acceptable for the underlying table to contain null keys, and even null values provided
 * that the function is capable of accepting null input. The transformed table might contain null
 * values, if the function sometimes gives a null result.
 *
 * <p>The returned table is not thread-safe or serializable, even if the underlying table is.
 *
 * <p>The function is applied lazily, invoked when needed. This is necessary for the returned
 * table to be a view, but it means that the function will be applied many times for bulk
 * operations like {@link Table#containsValue} and {@code Table.toString()}. For this to perform
 * well, {@code function} should be fast. To avoid lazy evaluation when the returned table doesn't
 * need to be a view, copy the returned table into a new table of your choosing.
 *
 * @since 10.0
 */
@Beta
public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<>(fromTable, function);
}

@Override public Map<C, Map<R, V2>> columnMap() {
 return (columnMap == null) ? columnMap = createColumnMap() : columnMap;
}

@Override public Map<C, Map<R, V2>> columnMap() {
 return (columnMap == null) ? columnMap = createColumnMap() : columnMap;
}

@Override public int hashCode() {
 return cellSet().hashCode();
}

@Override public int hashCode() {
 return cellSet().hashCode();
}

/**
 * Returns a view of a table where each value is transformed by a function. All other properties
 * of the table, such as iteration order, are left intact.
 *
 * <p>Changes in the underlying table are reflected in this view. Conversely, this view supports
 * removal operations, and these are reflected in the underlying table.
 *
 * <p>It's acceptable for the underlying table to contain null keys, and even null values provided
 * that the function is capable of accepting null input. The transformed table might contain null
 * values, if the function sometimes gives a null result.
 *
 * <p>The returned table is not thread-safe or serializable, even if the underlying table is.
 *
 * <p>The function is applied lazily, invoked when needed. This is necessary for the returned
 * table to be a view, but it means that the function will be applied many times for bulk
 * operations like {@link Table#containsValue} and {@code Table.toString()}. For this to perform
 * well, {@code function} should be fast. To avoid lazy evaluation when the returned table doesn't
 * need to be a view, copy the returned table into a new table of your choosing.
 *
 * @since 10.0
 */
@Beta
public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<>(fromTable, function);
}

/**
 * Returns a view of a table where each value is transformed by a function. All other properties
 * of the table, such as iteration order, are left intact.
 *
 * <p>Changes in the underlying table are reflected in this view. Conversely, this view supports
 * removal operations, and these are reflected in the underlying table.
 *
 * <p>It's acceptable for the underlying table to contain null keys, and even null values provided
 * that the function is capable of accepting null input. The transformed table might contain null
 * values, if the function sometimes gives a null result.
 *
 * <p>The returned table is not thread-safe or serializable, even if the underlying table is.
 *
 * <p>The function is applied lazily, invoked when needed. This is necessary for the returned
 * table to be a view, but it means that the function will be applied many times for bulk
 * operations like {@link Table#containsValue} and {@code Table.toString()}. For this to perform
 * well, {@code function} should be fast. To avoid lazy evaluation when the returned table doesn't
 * need to be a view, copy the returned table into a new table of your choosing.
 *
 * @since 10.0
 */
@Beta
public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<>(fromTable, function);
}

public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<R, C, V1, V2>(fromTable, function);

public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<R, C, V1, V2>(fromTable, function);

public static <R, C, V1, V2> Table<R, C, V2> transformValues(
    Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
  return new TransformedTable<R, C, V1, V2>(fromTable, function);

public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<R, C, V1, V2>(fromTable, function);

public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<R, C, V1, V2>(fromTable, function);

public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<R, C, V1, V2>(fromTable, function);

/**
 * Returns a view of a table where each value is transformed by a function.
 * All other properties of the table, such as iteration order, are left
 * intact.
 *
 * <p>Changes in the underlying table are reflected in this view. Conversely,
 * this view supports removal operations, and these are reflected in the
 * underlying table.
 *
 * <p>It's acceptable for the underlying table to contain null keys, and even
 * null values provided that the function is capable of accepting null input.
 * The transformed table might contain null values, if the function sometimes
 * gives a null result.
 *
 * <p>The returned table is not thread-safe or serializable, even if the
 * underlying table is.
 *
 * <p>The function is applied lazily, invoked when needed. This is necessary
 * for the returned table to be a view, but it means that the function will be
 * applied many times for bulk operations like {@link Table#containsValue} and
 * {@code Table.toString()}. For this to perform well, {@code function} should
 * be fast. To avoid lazy evaluation when the returned table doesn't need to
 * be a view, copy the returned table into a new table of your choosing.
 *
 * @since 10.0
 */
public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<R, C, V1, V2>(fromTable, function);
}

public static <R, C, V1, V2> Table<R, C, V2> transformValues(
  Table<R, C, V1> fromTable, Function<? super V1, V2> function) {
 return new TransformedTable<R, C, V1, V2>(fromTable, function);