How to use

com.google.common.collect.Tables$UnmodifiableRowSortedMap

constructor

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attempts to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 *
 * <p>The returned table will be serializable if the specified table is serializable.
 *
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attempts to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 *
 * <p>The returned table will be serializable if the specified table is serializable.
 *
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attempts to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 *
 * <p>The returned table will be serializable if the specified table is serializable.
 *
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 * 
 * <p>The returned table will be serializable if the specified table is serializable.
 * 
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<R, C, V>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 *
 * <p>The returned table will be serializable if the specified table is serializable.
 *
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
    RowSortedTable<R, ? extends C, ? extends V> table) {
  /*
   * It's not ? extends R, because it's technically not covariant in R. Specifically,
   * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
   * Collections.unmodifiableSortedMap makes the same distinction.
   */
  return new UnmodifiableRowSortedMap<R, C, V>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 * 
 * <p>The returned table will be serializable if the specified table is serializable.
 * 
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<R, C, V>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 * 
 * <p>The returned table will be serializable if the specified table is serializable.
 * 
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<R, C, V>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attempts to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 *
 * <p>The returned table will be serializable if the specified table is serializable.
 *
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attempts to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 *
 * <p>The returned table will be serializable if the specified table is serializable.
 *
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 * 
 * <p>The returned table will be serializable if the specified table is serializable.
 * 
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<R, C, V>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 * 
 * <p>The returned table will be serializable if the specified table is serializable.
 * 
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<R, C, V>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 * 
 * <p>The returned table will be serializable if the specified table is serializable.
 * 
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<R, C, V>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 * 
 * <p>The returned table will be serializable if the specified table is serializable.
 * 
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<R, C, V>(table);
}

/**
 * Returns an unmodifiable view of the specified row-sorted table. This method allows modules to
 * provide users with "read-only" access to internal tables. Query operations on the returned
 * table "read through" to the specified table, and attemps to modify the returned table, whether
 * direct or via its collection views, result in an {@code UnsupportedOperationException}.
 * 
 * <p>The returned table will be serializable if the specified table is serializable.
 * 
 * @param table the row-sorted table for which an unmodifiable view is to be returned
 * @return an unmodifiable view of the specified table
 * @since 11.0
 */
@Beta
public static <R, C, V> RowSortedTable<R, C, V> unmodifiableRowSortedTable(
  RowSortedTable<R, ? extends C, ? extends V> table) {
 /*
  * It's not ? extends R, because it's technically not covariant in R. Specifically,
  * table.rowMap().comparator() could return a comparator that only works for the ? extends R.
  * Collections.unmodifiableSortedMap makes the same distinction.
  */
 return new UnmodifiableRowSortedMap<R, C, V>(table);
}