001/*
002 * Copyright (C) 2007 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 */
014
015package com.google.common.io;
016
017import com.google.common.annotations.GwtIncompatible;
018import com.google.common.annotations.J2ktIncompatible;
019import com.google.common.annotations.VisibleForTesting;
020import java.io.Closeable;
021import java.io.IOException;
022import java.io.InputStream;
023import java.io.Reader;
024import java.util.logging.Level;
025import java.util.logging.Logger;
026import javax.annotation.CheckForNull;
027
028/**
029 * Utility methods for working with {@link Closeable} objects.
030 *
031 * @author Michael Lancaster
032 * @since 1.0
033 */
034@J2ktIncompatible
035@GwtIncompatible
036@ElementTypesAreNonnullByDefault
037public final class Closeables {
038  @VisibleForTesting static final Logger logger = Logger.getLogger(Closeables.class.getName());
039
040  private Closeables() {}
041
042  /**
043   * Closes a {@link Closeable}, with control over whether an {@code IOException} may be thrown.
044   * This is primarily useful in a finally block, where a thrown exception needs to be logged but
045   * not propagated (otherwise the original exception will be lost).
046   *
047   * <p>If {@code swallowIOException} is true then we never throw {@code IOException} but merely log
048   * it.
049   *
050   * <p>Example:
051   *
052   * <pre>{@code
053   * public void useStreamNicely() throws IOException {
054   *   SomeStream stream = new SomeStream("foo");
055   *   boolean threw = true;
056   *   try {
057   *     // ... code which does something with the stream ...
058   *     threw = false;
059   *   } finally {
060   *     // If an exception occurs, rethrow it only if threw==false:
061   *     Closeables.close(stream, threw);
062   *   }
063   * }
064   * }</pre>
065   *
066   * @param closeable the {@code Closeable} object to be closed, or null, in which case this method
067   *     does nothing
068   * @param swallowIOException if true, don't propagate IO exceptions thrown by the {@code close}
069   *     methods
070   * @throws IOException if {@code swallowIOException} is false and {@code close} throws an {@code
071   *     IOException}.
072   */
073  public static void close(@CheckForNull Closeable closeable, boolean swallowIOException)
074      throws IOException {
075    if (closeable == null) {
076      return;
077    }
078    try {
079      closeable.close();
080    } catch (IOException e) {
081      if (swallowIOException) {
082        logger.log(Level.WARNING, "IOException thrown while closing Closeable.", e);
083      } else {
084        throw e;
085      }
086    }
087  }
088
089  /**
090   * Closes the given {@link InputStream}, logging any {@code IOException} that's thrown rather than
091   * propagating it.
092   *
093   * <p>While it's not safe in the general case to ignore exceptions that are thrown when closing an
094   * I/O resource, it should generally be safe in the case of a resource that's being used only for
095   * reading, such as an {@code InputStream}. Unlike with writable resources, there's no chance that
096   * a failure that occurs when closing the stream indicates a meaningful problem such as a failure
097   * to flush all bytes to the underlying resource.
098   *
099   * @param inputStream the input stream to be closed, or {@code null} in which case this method
100   *     does nothing
101   * @since 17.0
102   */
103  public static void closeQuietly(@CheckForNull InputStream inputStream) {
104    try {
105      close(inputStream, true);
106    } catch (IOException impossible) {
107      throw new AssertionError(impossible);
108    }
109  }
110
111  /**
112   * Closes the given {@link Reader}, logging any {@code IOException} that's thrown rather than
113   * propagating it.
114   *
115   * <p>While it's not safe in the general case to ignore exceptions that are thrown when closing an
116   * I/O resource, it should generally be safe in the case of a resource that's being used only for
117   * reading, such as a {@code Reader}. Unlike with writable resources, there's no chance that a
118   * failure that occurs when closing the reader indicates a meaningful problem such as a failure to
119   * flush all bytes to the underlying resource.
120   *
121   * @param reader the reader to be closed, or {@code null} in which case this method does nothing
122   * @since 17.0
123   */
124  public static void closeQuietly(@CheckForNull Reader reader) {
125    try {
126      close(reader, true);
127    } catch (IOException impossible) {
128      throw new AssertionError(impossible);
129    }
130  }
131}