* someone still manages to pass null, let's continue to have the method work.
   *
   * (PatternFilenameFilter is of course one of those classes that shouldn't be a publicly visible
   * class to begin with but rather something returned from a static factory method whose declared
   * return type is plain FilenameFilter. If we made such a change, then the annotation we choose

      return arbitrary;
    }
    if (type.getRawType() == Class.class) {
      // If parameter is Class<? extends Foo>, we return Foo.class
      @SuppressWarnings("unchecked")
      T defaultClass = (T) getFirstTypeParameter(type.getType()).getRawType();
      return defaultClass;
    }
    if (type.getRawType() == TypeToken.class) {
      // If parameter is TypeToken<? extends Foo>, we return TypeToken<Foo>.

  // public named classes with a public default constructor.

  public static final class IntsAsListGenerator extends TestIntegerListGenerator {
    @Override
    protected List<Integer> create(Integer[] elements) {
      return asList(elements);
    }
  }

  public static final class IntsAsListHeadSubListGenerator extends TestIntegerListGenerator {
    @Override

  // public named classes with a public default constructor.

  public static final class BytesAsListGenerator extends TestByteListGenerator {
    @Override
    protected List<Byte> create(Byte[] elements) {
      return asList(elements);
    }
  }

  public static final class BytesAsListHeadSubListGenerator extends TestByteListGenerator {
    @Override

  // public named classes with a public default constructor.

  public static final class LongsAsListGenerator extends TestLongListGenerator {
    @Override
    protected List<Long> create(Long[] elements) {
      return asList(elements);
    }
  }

  public static final class LongsAsListHeadSubListGenerator extends TestLongListGenerator {
    @Override

 *
 * <p>This class is usually preferable to {@link AtomicLong} when multiple threads update a common
 * sum that is used for purposes such as collecting statistics, not for fine-grained synchronization
 * control. Under low update contention, the two classes have similar characteristics. But under
 * high contention, expected throughput of this class is significantly higher, at the expense of

 * limitations under the License.
 */

package com.google.common;

import com.google.gwt.core.client.EntryPoint;

/**
 * A dummy entry point to convince Maven to compile our classes.
 *
 * @author Chris Povirk
 */
public class ForceGuavaCompilationEntryPoint implements EntryPoint {
  @Override
  public void onModuleLoad() {}

import org.jspecify.annotations.Nullable;

/**
 * A class that can supply objects of a single type; a pre-Java-8 version of {@link
 * java.util.function.Supplier java.util.function.Supplier}. Semantically, this could be a factory,
 * generator, builder, closure, or something else entirely. No guarantees are implied by this
 * interface.
 *
 * <p>The {@link Suppliers} class provides common suppliers and related utilities.
 *

   *
   * <p><b>Java 25+ users:</b> If the input is a {@link Reader}, you may prefer {@link
   * Reader#readAllLines()}. The two may have different performance characteristics for different
   * {@link Reader} classes and Java versions, but both methods read the entire input into memory
   * immediately, so we discourage use of both when memory usage is a concern.
   *
   * @param r the object to read from

 * by multiple threads.
 *
 * <p>Popular escapers are defined as constants in classes like {@link
 * com.google.common.html.HtmlEscapers} and {@link com.google.common.xml.XmlEscapers}. To create
 * your own escapers extend this class and implement the {@link #escape(int)} method.
 *
 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible