How to use

com.google.common.collect.Tables$TransformedTable

constructor

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

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

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

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

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