Java Code Examples for java.io.Closeable

@Test public void closeQuietly_should_close_resources() throws Exception {
  Closeable closeable1=mock(Closeable.class);
  Closeable closeable2=mock(Closeable.class);
  closeQuietly(closeable1,closeable2);
  verify(closeable1,times(1)).close();
  verify(closeable2,times(1)).close();
}
 

@Test public void testCloseQuietlyCloseableOk() throws IOException {
  final Closeable c=context.mock(Closeable.class);
  context.checking(new Expectations(){
{
      oneOf(c).close();
    }
  }
);
  IOUtils.closeQuietly(c);
}
 

protected void mountDir(DeploymentUnit unit,VirtualFile root,String name,String path) throws IOException {
  VirtualFile logical=root.getChild(name);
  File physical=new File(path);
  physical.mkdirs();
  Closeable mount=VFS.mountReal(physical,logical);
  unit.addToAttachmentList(CLOSEABLE_ATTACHMENTS_KEY,mount);
}
 

private static MountHandle doMount(final FileSystem fileSystem,final VirtualFile mountPoint,Closeable... additionalCloseables) throws IOException {
  boolean ok=false;
  try {
    final Closeable mountHandle=mount(mountPoint,fileSystem);
    ok=true;
    return new BasicMountHandle(fileSystem,mountHandle,additionalCloseables);
  }
  finally {
    if (!ok) {
      VFSUtils.safeClose(fileSystem);
    }
  }
}
 

/** 
 * Zips a directory into the given file.
 * @param directory the directory to zip.
 * @param zipfile the zip file to create.
 * @throws IOException in case of an error.
 */
public static void zip(final File directory,final File zipfile) throws IOException {
  final URI base=directory.toURI();
  final File toZip=new File(zipfile,"");
  toZip.setWritable(true);
  final Stack<File> stack=new Stack<File>();
  stack.push(directory);
  final OutputStream out=new FileOutputStream(toZip);
  Closeable res=out;
  try {
    final ZipOutputStream zout=new ZipOutputStream(out);
    res=zout;
    while (!stack.isEmpty()) {
      final File currentDirectory=stack.pop();
      for (      final File kid : currentDirectory.listFiles()) {
        String name=base.relativize(kid.toURI()).getPath();
        if (kid.isDirectory()) {
          stack.push(kid);
          name=name.endsWith("/") ? name : name + "/";
          zout.putNextEntry(new ZipEntry(name));
        }
 else {
          zout.putNextEntry(new ZipEntry(name));
          copy(kid,zout);
          zout.closeEntry();
        }
      }
    }
  }
  finally {
    res.close();
  }
}
 

public void testCloseableCloseQuietlyOnException(){
  IOUtils.closeQuietly(new Closeable(){
    public void close() throws IOException {
      throw new IOException();
    }
  }
);
}
 

public void testTermClose() throws Exception {
  final AtomicBoolean closed=new AtomicBoolean();
  processor.addListener(new Closeable(){
    public void close() throws IOException {
      closed.set(true);
    }
  }
);
  term.publish(TermEvent.close());
  assertJoin(thread);
  assertTrue(closed.get());
}
 

public void test_close1() throws Exception {
  IOUtils.close(new Closeable(){
    public void close() throws IOException {
    }
  }
);
}
 

/** 
 * Empty class from the start, one should fill it with addXX and setXX methods
 * @param experimentWithData the containing experiment
 */
public ExperimentalData(ExperimentWithData experimentWithData) throws AtlasDataException {
  log.info("loading data for experiment" + experimentWithData.getExperiment().getAccession());
  this.experimentWithData=experimentWithData;
  ResourceWatchdogFilter.register(new Closeable(){
    public void close(){
      closeQuietly(ExperimentalData.this.experimentWithData);
    }
  }
);
  collectSamples();
  collectAssays();
  createAssaySampleMappings();
}
 

@Singleton @Provides ClientConnectionManager newClientConnectionManager(HttpParams params,X509HostnameVerifier verifier,Closer closer) throws NoSuchAlgorithmException, KeyManagementException {
  SchemeRegistry schemeRegistry=new SchemeRegistry();
  Scheme http=new Scheme("http",PlainSocketFactory.getSocketFactory(),80);
  SSLContext context=SSLContext.getInstance("TLS");
  context.init(null,null,null);
  SSLSocketFactory sf=new SSLSocketFactory(context);
  sf.setHostnameVerifier(verifier);
  Scheme https=new Scheme("https",sf,443);
  SchemeRegistry sr=new SchemeRegistry();
  sr.register(http);
  sr.register(https);
  schemeRegistry.register(new Scheme("http",PlainSocketFactory.getSocketFactory(),80));
  schemeRegistry.register(new Scheme("https",SSLSocketFactory.getSocketFactory(),443));
  final ClientConnectionManager cm=new ThreadSafeClientConnManager(params,schemeRegistry);
  closer.addToClose(new Closeable(){
    @Override public void close() throws IOException {
      cm.shutdown();
    }
  }
);
  return cm;
}
 

private static void closeQuietly(Closeable c){
  try {
    c.close();
  }
 catch (  IOException e) {
  }
}
 

private static void close(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException e) {
    }
  }
}
 

/** 
 * Creates an instance.
 */
public StreamManager(){
  listener=new CloseListener(){
    public void notifyClosed(    Closeable closeable){
      if (closeable instanceof InputStream) {
synchronized (openInputStreams) {
          openInputStreams.remove(closeable);
          openInputStreams.notifyAll();
        }
      }
 else {
synchronized (openOutputStreams) {
          openOutputStreams.remove(closeable);
          openOutputStreams.notifyAll();
        }
      }
    }
  }
;
}
 

static void closeSilently(final Closeable closable){
  try {
    closable.close();
  }
 catch (  IOException ignore) {
  }
}
 

public static void closeSilently(Closeable c){
  if (c != null) {
    try {
      c.close();
    }
 catch (    Exception e) {
    }
  }
}
 

public static void closeSilently(Closeable c){
  if (c == null)   return;
  try {
    c.close();
  }
 catch (  Throwable t) {
  }
}
 

public static void close(Closeable strm){
  try {
    strm.close();
  }
 catch (  IOException e) {
  }
}
 

/** 
 * Closes the specified stream.
 * @param stream The stream to close.
 */
public static void closeStream(Closeable stream){
  if (stream != null) {
    try {
      stream.close();
    }
 catch (    IOException e) {
      android.util.Log.e(LOG_TAG,"Could not close stream",e);
    }
  }
}
 

/** 
 * Closes the specified stream.
 * @param stream The stream to close.
 */
public static void closeStream(Closeable stream){
  if (stream != null) {
    try {
      stream.close();
    }
 catch (    IOException e) {
      android.util.Log.e(LOG_TAG,"Could not close stream",e);
    }
  }
}
 

public static void close(Closeable c){
  try {
    if (c != null) {
      c.close();
    }
  }
 catch (  Exception e) {
  }
}
 

@Override public void close() throws IOException {
  this.closed=true;
  if (target instanceof Closeable) {
    ((Closeable)target).close();
  }
}
 

public static void closeSilently(Closeable c){
  if (c != null) {
    try {
      c.close();
    }
 catch (    Throwable e) {
    }
  }
}
 

static void closeSilently(Closeable c){
  if (c == null)   return;
  try {
    c.close();
  }
 catch (  Throwable t) {
  }
}
 

public static void closeSilently(Closeable c){
  if (c == null)   return;
  try {
    c.close();
  }
 catch (  Throwable t) {
  }
}
 

/** 
 * Closes the supplied Closeable if it's available.
 * @param closeable The closeable that has to be closed. Maybe <code>null</code>.
 */
public static final void close(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException ex) {
      A4ELogging.warn(ex.getMessage());
    }
  }
}
 

/** 
 * Closes the closable interface and reports error if any.
 * @param closable the closable object to be closed.
 */
public static void closeGracefully(Closeable closable){
  if (closable != null) {
    try {
      closable.close();
    }
 catch (    Exception e) {
      logger.error("Error while closing object " + closable,e);
    }
  }
}
 

/** 
 * Closes the specified stream.
 * @param stream The stream to close.
 */
private static void closeStream(Closeable stream){
  if (stream != null) {
    try {
      stream.close();
    }
 catch (    IOException e) {
    }
  }
}
 

public static void closeQuietly(Object input){
  if (input == null || !(input instanceof Closeable)) {
    return;
  }
  try {
    ((Closeable)input).close();
  }
 catch (  IOException ioe) {
  }
}
 

/** 
 * Closes the given  {@code Object}. Returns  {@code true} on successand  {@code false} on failure. All {@link IOException}s will be caught and no error will be thrown if the Object isn't any of the supported types.
 * @see Closeable
 * @see #close(Closeable)
 * @see AutoCloseable
 * @see #close(AutoCloseable)
 * @see Socket
 * @see #close(Socket)
 * @see ServerSocket
 * @see #close(ServerSocket)
 * @see DatagramSocket
 * @see #close(DatagramSocket)
 * @see AtomicReference
 * @see #close(AtomicReference)
 */
public static boolean close(Object o){
  if (o instanceof Closeable) {
    return close((Closeable)o);
  }
 else   if (o instanceof AutoCloseable) {
    return close((AutoCloseable)o);
  }
 else   if (o instanceof Socket) {
    return close((Socket)o);
  }
 else   if (o instanceof ServerSocket) {
    return close((ServerSocket)o);
  }
 else   if (o instanceof DatagramSocket) {
    return close((DatagramSocket)o);
  }
 else   if (o instanceof AtomicReference<?>) {
    return close(((AtomicReference<?>)o));
  }
  return false;
}
 

/** 
 * Closes an closeable instance ignoring exceptions
 * @param closeable the closeable to be closed
 */
public static void closeQuietly(Closeable closeable){
  try {
    if (closeable != null) {
      closeable.close();
    }
  }
 catch (  final IOException ignore) {
  }
}
 

static void closeQuietly(Closeable... closeables){
  for (  Closeable closeable : closeables) {
    if (closeable != null) {
      try {
        closeable.close();
      }
 catch (      IOException e) {
      }
    }
  }
}
 

public static void closeQuietly(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    Throwable e) {
      LOG.warn("failed to close '" + closeable + "'",e);
    }
  }
}
 

private ShutdownHook(){
  Runtime.getRuntime().addShutdownHook(new Thread(){
    public void run(){
      for (      Closeable c : closeables) {
        try {
          c.close();
        }
 catch (        IOException e) {
          LOG.error("Error while closing",e);
        }
      }
    }
  }
);
}
 

/** 
 * Closes the specified stream.
 * @param stream The stream to close.
 */
private static void closeStream(Closeable stream){
  if (stream != null) {
    try {
      stream.close();
    }
 catch (    IOException e) {
    }
  }
}
 

/** 
 * Closes the  {@link Closeable resource} without throwing an exception.
 * @param resource the  {@link Closeable resource} to close
 */
public static void closeSilently(final Closeable resource){
  if (resource != null) {
    try {
      resource.close();
    }
 catch (    IOException e) {
    }
  }
}
 

public static void closeSilently(Closeable c){
  if (c == null)   return;
  try {
    c.close();
  }
 catch (  Throwable t) {
  }
}
 

public static final void close(Closeable c){
  if (c != null) {
    try {
      c.close();
    }
 catch (    IOException e) {
      throw new RuntimeException("Could not close stream",e);
    }
  }
}
 

/** 
 * Closes the supplied stream if it's available.
 * @param closeable the closeable. Maybe <code>null</code>.
 */
public static final void close(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException ex) {
    }
  }
}
 

private void closeSilent(Closeable closeable){
  try {
    closeable.close();
  }
 catch (  IOException exception) {
  }
}
 

public static void safeClose(Closeable toClose){
  if (toClose != null) {
    try {
      toClose.close();
    }
 catch (    IOException e) {
    }
  }
}
 

/** 
 * Safe close.
 * @param closeable the closeable
 */
protected static void safeClose(final Closeable closeable){
  if (closeable != null)   try {
    closeable.close();
  }
 catch (  IOException e) {
  }
}
 

private void closeStream(Closeable in){
  if (in != null) {
    try {
      in.close();
    }
 catch (    IOException ex) {
      logger.warn("Can not close stream.",ex);
    }
  }
}
 

protected void closeQuietly(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException ignored) {
    }
  }
}
 

private static void close(final Closeable... closeables){
  for (  Closeable c : closeables) {
    try {
      c.close();
    }
 catch (    Exception e) {
    }
  }
}
 

public static void closeSilently(Closeable c){
  if (c == null)   return;
  try {
    c.close();
  }
 catch (  Throwable t) {
  }
}
 

@Test public void testViaProvider() throws Exception {
  List<Closeable> closeables=Lists.newArrayList();
  TestingServer server=new TestingServer();
  closeables.add(server);
  try {
    CuratorFramework client=CuratorFrameworkFactory.newClient(server.getConnectString(),new RetryOneTime(1));
    closeables.add(client);
    client.start();
    ServiceDiscovery<String> discovery=ServiceDiscoveryBuilder.builder(String.class).basePath("/discovery").client(client).build();
    closeables.add(discovery);
    discovery.start();
    ServiceProvider<String> serviceProvider=discovery.serviceProviderBuilder().serviceName("test").build();
    closeables.add(serviceProvider);
    serviceProvider.start();
    ServiceInstance<String> instance=ServiceInstance.<String>builder().payload("thing").name("test").port(10064).build();
    discovery.registerService(instance);
    int count=0;
    ServiceInstance<String> foundInstance=null;
    while (foundInstance == null) {
      Assert.assertTrue(count++ < 5);
      foundInstance=serviceProvider.getInstance();
      Thread.sleep(1000);
    }
    Assert.assertEquals(foundInstance,instance);
  }
  finally {
    Collections.reverse(closeables);
    for (    Closeable c : closeables) {
      Closeables.closeQuietly(c);
    }
  }
}
 

/** 
 * Closes a  {@link Closeable} silently
 * @param closable
 */
public static void closeSilently(final Closeable closable){
  if (closable == null) {
    return;
  }
  try {
    closable.close();
  }
 catch (  IOException e) {
  }
}
 

public static boolean close(Closeable c){
  if (c != null) {
    try {
      c.close();
      return true;
    }
 catch (    IOException ignore) {
    }
  }
  return false;
}
 

public static void closeSilently(Closeable c){
  if (c == null)   return;
  try {
    c.close();
  }
 catch (  Throwable t) {
  }
}
 

public static void close(Closeable io){
  if (io != null)   try {
    io.close();
  }
 catch (  IOException ignore) {
  }
}
 

public static void silentlyClose(Closeable... closeables){
  for (  Closeable cl : closeables) {
    try {
      cl.close();
    }
 catch (    Exception e) {
      L.d(e);
    }
  }
}
 

public static void safeClose(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException e) {
    }
  }
}
 

public static void close(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException e) {
    }
  }
}
 

private void close(final Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException e) {
      log.debug(e.getMessage());
    }
  }
}
 

public static void close(Closeable... closeables){
  for (  Closeable c : closeables) {
    try {
      if (c != null) {
        c.close();
      }
    }
 catch (    IOException e) {
      _log.log(Level.SEVERE,e.getLocalizedMessage(),e);
    }
  }
}
 

private static void safeClose(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException e) {
      e.printStackTrace();
    }
  }
}
 

protected static void closeQuietly(Closeable stream){
  if (stream != null) {
    try {
      stream.close();
    }
 catch (    Throwable t) {
    }
  }
}
 

/** 
 * Closes the  {@code Formatter}. If the output destination is  {@link Closeable}, then the method  {@code close()} will be called on that destination.If the  {@code Formatter} has been closed, then calling the this method will have noeffect. Any method but the  {@link #ioException()} that is called after the{@code Formatter} has been closed will raise a {@code FormatterClosedException}.
 */
public void close(){
  closed=true;
  try {
    if (out instanceof Closeable) {
      ((Closeable)out).close();
    }
  }
 catch (  IOException e) {
    lastIOException=e;
  }
}
 

private static void closeCloseable(Closeable c){
  if (c == null) {
    return;
  }
  try {
    c.close();
  }
 catch (  Throwable t) {
    logger.log(Level.WARNING,"Error ocurred while closing " + c,t);
  }
}
 

public void close(){
  try {
    ((Closeable)getScriptEngine()).close();
  }
 catch (  IOException e) {
    e.printStackTrace();
  }
}
 

/** 
 * Closes stream and ignores error while doing so. Don't use with output streams!
 * @param stream
 */
static void close(Closeable stream){
  if (stream == null) {
    return;
  }
  try {
    stream.close();
  }
 catch (  IOException e) {
  }
}
 

/** 
 * <p>Attempt to close an  {@link Closeable} object. Null argument value is authorized and no operation will beperformed in that use case.  {@link IOException} thrown are logged using the <code>error</code> level but notpropagated.</p>
 * @param out the stream to close
 */
public static void safeClose(Closeable out){
  if (out != null) {
    try {
      out.close();
    }
 catch (    IOException e) {
      log.error("Error while closing closeable " + out,e);
    }
  }
}
 

private static void closeStream(Closeable stream,String name){
  try {
    stream.close();
  }
 catch (  IOException ioe) {
    logger.warn(String.format("Unable to close process %s stream",name),ioe);
  }
}
 

public static void close(Closeable closeable) throws IOException {
  if (closeable == null)   return;
  try {
    if (closeable instanceof Flushable) {
      ((Flushable)closeable).flush();
    }
  }
 catch (  IOException e) {
  }
  try {
    closeable.close();
  }
 catch (  IOException e) {
  }
}
 

public static void close(Closeable... list){
  for (  Closeable c : list) {
    if (null != c) {
      try {
        c.close();
      }
 catch (      IOException e) {
      }
    }
  }
}
 

/** 
 * Unconditionally close a <code>Closeable</code>. <p> Equivalent to  {@link Closeable#close()}, except any exceptions will be ignored. This is typically used in finally blocks. <p> Example code: <pre> Closeable closeable = null; try { closeable = new FileReader("foo.txt"); // process closeable closeable.close(); } catch (Exception e) { // error handling } finally { IOUtils.closeQuietly(closeable); } </pre>
 * @param closeable the object to close, may be null or already closed
 * @since Commons IO 2.0
 */
public static void closeQuietly(Closeable closeable){
  try {
    if (closeable != null) {
      closeable.close();
    }
  }
 catch (  IOException ioe) {
  }
}
 

public static void close(Closeable resource){
  try {
    resource.close();
  }
 catch (  IOException e) {
    logger.log(Level.WARN,e);
  }
}
 

/** 
 * Closes the specified stream.
 * @param stream The stream to close.
 */
private static void closeStream(Closeable stream){
  if (stream != null) {
    try {
      stream.close();
    }
 catch (    IOException e) {
    }
  }
}
 

@PostConstruct public void init() throws IOException {
  Validate.notNull(cubeModel);
  Deque<Closeable> closeables=new ArrayDeque<Closeable>();
  try {
    InputStream cubeIs=cubeModel.getInputStream();
    closeables.addFirst(cubeIs);
    cubeModelYamlStr=IOUtil.fromStream(cubeIs,"utf-8");
    cube=YamlModelParser.parseYamlModel(cubeModelYamlStr);
  }
  finally {
    IOUtil.closeAll(closeables);
  }
}
 

public static void closeQuietly(Object input){
  if (input == null || !(input instanceof Closeable)) {
    return;
  }
  try {
    ((Closeable)input).close();
  }
 catch (  IOException ioe) {
  }
}
 

private static void closeQuietly(Closeable... closeables){
  if (null != closeables) {
    for (    Closeable closeable : closeables) {
      if (null != closeable) {
        try {
          closeable.close();
        }
 catch (        Exception e) {
        }
      }
    }
  }
}
 

private void safeCloseStream(Closeable stream){
  if (stream != null) {
    try {
      stream.close();
    }
 catch (    IOException e) {
    }
  }
}
 

/** 
 * <p>This is the default <code>response.success</code> handler.  It will be  executed if the response is not handled by a status-code-specific handler  (i.e. <code>response.'200'= {..}</code>) and no generic 'success' handler  is given (i.e. <code>response.success = {..}</code>.)  This handler simply  returns the parsed data from the response body.  In most cases you will  probably want to define a <code>response.success = {...}</code> handler  from the request closure, which will replace the response handler defined  by this method.  </p> <h4>Note for parsers that return streaming content:</h4> <p>For responses parsed as  {@link ParserRegistry#parseStream(HttpResponse) BINARY} or {@link ParserRegistry#parseText(HttpResponse) TEXT}, the  parser will return streaming content -- an <code>InputStream</code> or  <code>Reader</code>.  In these cases, this handler will buffer the the  response content before the network connection is closed.  </p> <p>In practice, a user-supplied response handler closure is  <i>designed</i> to handle streaming content so it can be read directly from  the response stream without buffering, which will be much more efficient. Therefore, it is recommended that request method variants be used which  explicitly accept a response handler closure in these cases.</p>
 * @param resp HTTP response
 * @param parsedData parsed data as resolved from this instance's {@link ParserRegistry}
 * @return the parsed data object (whatever the parser returns).
 * @throws ResponseParseException if there is an error buffering a streamingresponse.
 */
protected Object defaultSuccessHandler(HttpResponseDecorator resp,Object parsedData) throws ResponseParseException {
  try {
    if (parsedData instanceof InputStream) {
      ByteArrayOutputStream buffer=new ByteArrayOutputStream();
      DefaultGroovyMethods.leftShift(buffer,(InputStream)parsedData);
      parsedData=new ByteArrayInputStream(buffer.toByteArray());
    }
 else     if (parsedData instanceof Reader) {
      StringWriter buffer=new StringWriter();
      DefaultGroovyMethods.leftShift(buffer,(Reader)parsedData);
      parsedData=new StringReader(buffer.toString());
    }
 else     if (parsedData instanceof Closeable)     log.warn("Parsed data is streaming, but will be accessible after " + "the network connection is closed.  Use at your own risk!");
    return parsedData;
  }
 catch (  IOException ex) {
    throw new ResponseParseException(resp,ex);
  }
}
 

static void closeSilently(final Closeable closable){
  try {
    closable.close();
  }
 catch (  IOException ignore) {
  }
}
 

private static void quietClose(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException ioe) {
    }
  }
}
 

private void closeSilently(Closeable c){
  try {
    if (c != null) {
      c.close();
    }
  }
 catch (  Exception e) {
  }
}
 

private static void safeClose(Closeable stream){
  if (stream != null) {
    try {
      stream.close();
    }
 catch (    IOException e) {
    }
  }
}
 

/** 
 * @param out The closeable (Writer, Stream, etc.) to close
 */
public static void close(final Closeable out){
  if (out != null) {
    try {
      out.close();
    }
 catch (    IOException e) {
      e.printStackTrace();
    }
  }
}
 

/** 
 * Closes 'closeable', ignoring any checked exceptions. Does nothing if 'closeable' is null.
 */
public static void closeQuietly(Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    final RuntimeException rethrown) {
      throw rethrown;
    }
catch (    final Exception ignored) {
    }
  }
}
 

public void shutDown() throws Exception {
  if (!initialized) {
    return;
  }
  if (blobStoreNeedsClose && bs instanceof Closeable) {
    IOUtils.closeQuietly((Closeable)bs);
  }
  if (rs instanceof Closeable) {
    IOUtils.closeQuietly((Closeable)rs);
  }
  initialized=false;
}
 

private void safeClose(final Closeable closeable){
  if (closeable != null) {
    try {
      closeable.close();
    }
 catch (    IOException e) {
    }
  }
}
 

/** 
 * Safely close some resource without throwing an exception.  Any exception will be logged at TRACE level.
 */
public static void safeClose(Closeable c){
  try {
    if (c != null)     c.close();
  }
 catch (  Exception ex) {
    LOGGER.tracef(ex,"Failed to close resource");
  }
}
 

public static void safeClose(final Closeable closeable){
  if (closeable != null)   try {
    closeable.close();
  }
 catch (  Exception e) {
  }
}
 

public static void close(Closeable cl){
  if (cl == null)   return;
  try {
    cl.close();
  }
 catch (  Exception e) {
  }
}
 

private void safeClose(Closeable closable){
  try {
    logger.debug("Closing " + closable);
    closable.close();
  }
 catch (  Throwable e) {
    logger.debug("Exception closing " + closable,e);
  }
}
 

/** 
 * Safely close the resource, reporting an error if the close fails.
 * @param c the resource
 */
protected void safeClose(Closeable c){
  try {
    if (c != null)     c.close();
  }
 catch (  Exception e) {
    reportError("Error closing resource",e,ErrorManager.CLOSE_FAILURE);
  }
catch (  Throwable ignored) {
  }
}
 

private static void safeClose(final Closeable closeable){
  if (closeable != null)   try {
    closeable.close();
  }
 catch (  IOException e) {
  }
}
 

private static void safeClose(Closeable closable){
  try {
    closable.close();
  }
 catch (  Throwable t) {
    logger.debug("Failed to close endpoint ",t);
  }
}
 

/** 
 * A close handler which closes another resource.
 * @param c the resource to close
 * @return the close handler
 */
public static CloseHandler<Object> closingCloseHandler(final Closeable c){
  return new CloseHandler<Object>(){
    public void handleClose(    final Object closed,    final IOException exception){
      IoUtils.safeClose(c);
    }
  }
;
}
 

private static void safeClose(Closeable c){
  if (c != null)   try {
    c.close();
  }
 catch (  Throwable ignored) {
  }
}