* single value. A table may be sparse, with only a small fraction of row key / column key pairs
 * possessing a corresponding value.
 *
 * <p>The mappings corresponding to a given row key may be viewed as a {@link Map} whose keys are
 * the columns. The reverse is also available, associating a column with a row key / value map. Note

 * @since 10.0
 */
@GwtCompatible
public abstract class CacheLoader<K, V> {
  /** Constructor for use by subclasses. */
  protected CacheLoader() {}

  /**
   * Computes or retrieves the value corresponding to {@code key}.
   *
   * @param key the non-null key whose value should be loaded
   * @return the value associated with {@code key}; <b>must not be null</b>
   * @throws Exception if unable to load the result

   * that traverses the elements in {@code a}, followed by the elements in {@code b}. The source
   * iterators are not polled until necessary.
   *
   * <p>The returned iterable's iterator supports {@code remove()} when the corresponding input
   * iterator supports it.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#concat}.
   *
   * @since 20.0
   */
  public static <T extends @Nullable Object> FluentIterable<T> concat(

   * that traverses the elements in {@code a}, followed by the elements in {@code b}. The source
   * iterators are not polled until necessary.
   *
   * <p>The returned iterable's iterator supports {@code remove()} when the corresponding input
   * iterator supports it.
   *
   * <p><b>{@code Stream} equivalent:</b> {@link Stream#concat}.
   *
   * @since 20.0
   */
  public static <T extends @Nullable Object> FluentIterable<T> concat(

   *
   * <p>Otherwise, for each row key in {@link #rowKeySet()}, the returned map associates the row key
   * with the corresponding value in the table. Changes to the returned map will update the
   * underlying table, and vice versa.
   *
   * @param columnKey key of column to search for in the table
   * @return the corresponding map from row keys to values
   */
  @Override
  public Map<R, @Nullable V> column(C columnKey) {

     *             If the number of actual and formal parameters differ, if unwrapping of primitive arguments fails,
     *             or if after unwrapping, the parameter values cannot be converted to the corresponding formal parameter types,
     *             or if the constructor is related to an enum type
     * @see Constructor#newInstance(Object[])
     */

     */
    protected MessageFormatter() {
    }

    /** Length of the numeric part of the message code */
    protected static final int CODE_NUMBER_LENGTH = 4;

    /** Suffix of the resource bundle name corresponding to the message code */
    protected static final String MESSAGES = "Messages";

    /** Flag indicating initialization */
    protected static volatile boolean initialized;

    /**
     * Returns the message.

        }
        return o;
    }

    /**
     * Converts to the wrapper type corresponding to the specified primitive type.
     *
     * @param type
     *            Primitive type
     * @param o
     *            Source object
     * @return Object converted to the wrapper type corresponding to the specified primitive type
     */

            }
        }
    }

    /**
     * Returns a {@link File} representing the directory corresponding to the root package.
     *
     * @param rootDir the root directory
     * @param rootPackage the root package
     * @return a {@link File} representing the directory corresponding to the package
     */
    protected static File getPackageDir(final File rootDir, final String rootPackage) {

import org.jspecify.annotations.Nullable;

/**
 * An assortment of mainly legacy static utility methods that operate on or return objects of type
 * {@code Iterable}. Except as noted, each method has a corresponding {@link Iterator}-based method
 * in the {@link Iterators} class.
 *
 * <p><b>Java 8+ users:</b> several common uses for this class are now more comprehensively