* intern(a)} is permitted to return one instance now and a different instance later if the
   * original interned instance was garbage-collected.
   *
   * <p><b>Warning:</b> do not use with mutable objects.
   *
   * @throws NullPointerException if {@code sample} is null
   */
  E intern(E sample);

 * @author Harry Heymann
 * @since 2.0
 */
@GwtCompatible
public interface Supplier<T extends @Nullable Object> {
  /**
   * Retrieves an instance of the appropriate type. The returned object may or may not be a new
   * instance, depending on the implementation.
   *
   * @return an instance of the appropriate type
   */
  @ParametricNullness
  T get();

  /**

    public void test_multipleInstances() {
        // Test creating multiple instances
        ResultOffsetExceededException exception1 = new ResultOffsetExceededException("First instance");
        ResultOffsetExceededException exception2 = new ResultOffsetExceededException("Second instance");
        ResultOffsetExceededException exception3 = new ResultOffsetExceededException("Third instance");

        assertNotSame(exception1, exception2);

        return factory;
    }

    /**
     * Creates a new instance of {@link SAXParser} using the default configuration of {@link SAXParserFactory}.
     *
     * @return A new instance of {@link SAXParser}.
     */
    public static SAXParser newSAXParser() {
        return newSAXParser(newInstance());
    }

    /**
     * Creates a new instance of {@link SAXParser} using the specified {@link SAXParserFactory}.
     *

      @ParametricNullness T instance) {
    return new SupplierOfInstance<>(instance);
  }

  private static final class SupplierOfInstance<T extends @Nullable Object>
      implements Supplier<T>, Serializable {
    @ParametricNullness final T instance;

    SupplierOfInstance(@ParametricNullness T instance) {
      this.instance = instance;
    }

    @Override
    @ParametricNullness
    public T get() {

@GwtCompatible
@FunctionalInterface
public interface Supplier<T extends @Nullable Object> extends java.util.function.Supplier<T> {
  /**
   * Retrieves an instance of the appropriate type. The returned object may or may not be a new
   * instance, depending on the implementation.
   *
   * @return an instance of the appropriate type
   */
  @Override
  @ParametricNullness
  T get();

  /**

          .put(ImmutableClassToInstanceMap.class, ImmutableClassToInstanceMap.builder().build())
          .put(Comparable.class, ByToString.INSTANCE)
          .put(Comparator.class, AlwaysEqual.INSTANCE)
          .put(Ordering.class, AlwaysEqual.INSTANCE)
          .put(Range.class, Range.all())
          .put(MapDifference.class, Maps.difference(ImmutableMap.of(), ImmutableMap.of()))
          .put(

    public static synchronized final SingletonContext getInstance() {
        if (INSTANCE == null) {
            try {
                log.debug("Initializing singleton context");
                init(null);
            } catch (final CIFSException e) {
                log.error("Failed to create singleton JCIFS context", e);
            }
        }
        return INSTANCE;
    }

    /**

  <version>0.0.0.0</version>
</parent>
    ]]></configuration>
    <description> This is the MavenProject instance for the parent of the current POM.
    </description>
  </expression>
  <expression>
    <syntax>project.file</syntax>
    <description> This is the File instance that refers to the location of the current POM on
      disk.
    </description>
  </expression>
  <expression>

    private TimeoutManager() {
    }

    /**
     * Returns the instance for the singleton.
     *
     * @return the instance for the singleton
     */
    public static TimeoutManager getInstance() {
        return instance;
    }

    /**
     * Starts the process.
     */
    public synchronized void start() {
        if (thread == null) {