Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F61939866
Closeables.java
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Thu, May 9, 22:49
Size
3 KB
Mime Type
text/x-java
Expires
Sat, May 11, 22:49 (2 d)
Engine
blob
Format
Raw Data
Handle
17581133
Attached To
R7507 YCSB
Closeables.java
View Options
/*
* Copyright (C) 2007 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package
com.google.common.io
;
import
com.google.common.annotations.Beta
;
import
com.google.common.annotations.VisibleForTesting
;
import
java.io.Closeable
;
import
java.io.IOException
;
import
java.util.logging.Level
;
import
java.util.logging.Logger
;
import
javax.annotation.Nullable
;
/**
* Utility methods for working with {@link Closeable} objects.
*
* @author Michael Lancaster
* @since 1.0
*/
@Beta
public
final
class
Closeables
{
@VisibleForTesting
static
final
Logger
logger
=
Logger
.
getLogger
(
Closeables
.
class
.
getName
());
private
Closeables
()
{}
/**
* Closes a {@link Closeable}, with control over whether an
* {@code IOException} may be thrown. This is primarily useful in a
* finally block, where a thrown exception needs to be logged but not
* propagated (otherwise the original exception will be lost).
*
* <p>If {@code swallowIOException} is true then we never throw
* {@code IOException} but merely log it.
*
* <p>Example:
*
* <p><pre>public void useStreamNicely() throws IOException {
* SomeStream stream = new SomeStream("foo");
* boolean threw = true;
* try {
* // Some code which does something with the Stream. May throw a
* // Throwable.
* threw = false; // No throwable thrown.
* } finally {
* // Close the stream.
* // If an exception occurs, only rethrow it if (threw==false).
* Closeables.close(stream, threw);
* }
* </pre>
*
* @param closeable the {@code Closeable} object to be closed, or null,
* in which case this method does nothing
* @param swallowIOException if true, don't propagate IO exceptions
* thrown by the {@code close} methods
* @throws IOException if {@code swallowIOException} is false and
* {@code close} throws an {@code IOException}.
*/
public
static
void
close
(
@Nullable
Closeable
closeable
,
boolean
swallowIOException
)
throws
IOException
{
if
(
closeable
==
null
)
{
return
;
}
try
{
closeable
.
close
();
}
catch
(
IOException
e
)
{
if
(
swallowIOException
)
{
logger
.
log
(
Level
.
WARNING
,
"IOException thrown while closing Closeable."
,
e
);
}
else
{
throw
e
;
}
}
}
/**
* Equivalent to calling {@code close(closeable, true)}, but with no
* IOException in the signature.
* @param closeable the {@code Closeable} object to be closed, or null, in
* which case this method does nothing
*/
public
static
void
closeQuietly
(
@Nullable
Closeable
closeable
)
{
try
{
close
(
closeable
,
true
);
}
catch
(
IOException
e
)
{
logger
.
log
(
Level
.
SEVERE
,
"IOException should not have been thrown."
,
e
);
}
}
}
Event Timeline
Log In to Comment