/**
  * Helper method used when value to serialize is {@link Closeable} and its <code>close()</code>
  * method is to be called right after serialization has been called
  */
 private final void _writeCloseable(JsonGenerator jgen, Object value, SerializationConfig cfg)
     throws IOException, JsonGenerationException, JsonMappingException {
   Closeable toClose = (Closeable) value;
   try {
     if (_rootType == null) {
       _serializerProvider(cfg).serializeValue(jgen, value);
     } else {
       _serializerProvider(cfg).serializeValue(jgen, value, _rootType, _rootSerializer);
     }
     JsonGenerator tmpJgen = jgen;
     jgen = null;
     tmpJgen.close();
     Closeable tmpToClose = toClose;
     toClose = null;
     tmpToClose.close();
   } finally {
     /* Need to close both generator and value, as long as they haven't yet
      * been closed
      */
     if (jgen != null) {
       try {
         jgen.close();
       } catch (IOException ioe) {
       }
     }
     if (toClose != null) {
       try {
         toClose.close();
       } catch (IOException ioe) {
       }
     }
   }
 }
 private static final void safeClose(Closeable closeable) {
   if (closeable != null) {
     try {
       closeable.close();
     } catch (IOException e) {
     }
   }
 }
 public static void closeResource(Closeable closeable) {
   if (closeable != null) {
     try {
       closeable.close();
     } catch (IOException ignored) {
     }
   }
 }
 private void safeClose(@Nullable Closeable enumerator, MavenIndexException[] exceptions) {
   try {
     if (enumerator != null) enumerator.close();
   } catch (IOException e) {
     MavenLog.LOG.warn(e);
     if (exceptions[0] == null) exceptions[0] = new MavenIndexException(e);
   }
 }
Exemple #5
0
  public static void closeQuietly(Closeable closeable) {
    try {
      if (closeable != null) {
        closeable.close();
      }
    } catch (IOException e) {

    }
  }
Exemple #6
0
 /**
  * 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
  */
 private static void closeQuietly(Closeable closeable) {
   try {
     if (closeable != null) {
       closeable.close();
     }
   } catch (IOException ioe) {
     // ignore
   }
 }
 /**
  * @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();
         }
     }
 }
Exemple #8
0
  public void stop() {
    for (Closeable c : closeables)
      try {
        c.close();
      } catch (IOException ignore) {
      }

    ChatHandler.removeAll();
  }
 public static void closeSilently(Closeable stream) {
   if (stream != null) {
     try {
       stream.close();
     } catch (IOException e) {
       // close silently
     }
   }
 }
Exemple #10
0
 public void closeQuietly(Closeable s) {
   if (s != null) {
     try {
       s.close();
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
 }
Exemple #11
0
 /**
  * Close stream or resource.
  *
  * @param closeable
  */
 private void close(Closeable closeable) {
   if (closeable != null) {
     try {
       closeable.close();
     } catch (Exception e) {
       log.trace("Error closing stream or resource", e);
     }
   }
 }
 /**
  * Closes a resource if it is not null All possible IOExceptions are ignored
  *
  * @param e resource to close
  */
 public static void close(@Nullable Closeable e) {
   if (e != null) {
     try {
       e.close();
     } catch (IOException e1) {
       // ignore
     }
   }
 }
Exemple #13
0
 /**
  * Closes the given {@link Closeable} ignoring the I/O exception that might occur. Does nothing if
  * <code>null</code> is given as argument.
  */
 public static void closeSilently(@CheckForNull Closeable closeable) {
   if (closeable == null) {
     return;
   }
   try {
     closeable.close();
   } catch (IOException e) {
     // ignore
   }
 }
 /**
  * Close all {@link Closeable}s except for <i>n</i> of them.
  *
  * @param n The number of {@link Closeable}s to keep open at most.
  */
 void closeAllBut(int n) throws IOException {
   synchronized (m_closeableList) {
     while (m_closeableList.size() > n) {
       final Closeable closeable = m_closeableList.removeFirst();
       synchronized (closeable) {
         closeable.close();
       }
     }
   }
 }
Exemple #15
0
 /**
  * Close the given resource.
  *
  * @param resource The resource to be closed.
  */
 private static void close(Closeable resource) {
   if (resource != null) {
     try {
       resource.close();
     } catch (IOException ignore) {
       // Ignore IOException. If you want to handle this anyway, it might be useful to know
       // that this will generally only be thrown when the client aborted the request.
     }
   }
 }
Exemple #16
0
 public static void close(Closeable c) {
   // convenience
   if (c != null) {
     try {
       c.close();
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
 }
Exemple #17
0
 public void close() {
   for (ClassDataCollector cd : delegates)
     try {
       if (cd instanceof Closeable) ((Closeable) cd).close();
     } catch (Exception e) {
       reporter.error("Fail to call close on %s", cd);
     }
   delegates.clear();
   shortlist.clear();
 }
 public static void close(Closeable c) {
   if (c == null) {
     return;
   }
   try {
     c.close();
   } catch (IOException e) {
     log.warn("Can't close file streams.", e);
   }
 }
Exemple #19
0
 public static void closeQuietly(Closeable closeable) {
   if (closeable != null) {
     try {
       closeable.close();
     } catch (RuntimeException e) {
       throw e;
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }
Exemple #20
0
 public static void closeQuietly(Closeable closeable, String streamDescription) {
   if (closeable != null) {
     try {
       closeable.close();
     } catch (IOException ex) {
       if (!isEmpty(streamDescription)) {
         log.severe("error closing stream " + streamDescription + ": " + ex);
       }
     }
   }
 }
 @Override
 public void close() throws IOException {
   out.close();
   br.close();
   ous.close();
   ois.close();
   socket.close();
   for (Closeable extraCloseable : extraCloseables) {
     extraCloseable.close();
   }
 }
 /**
  * Closes all not-null resources All possible IOExceptions are ignored
  *
  * @param toClose resources to close
  * @since 7.0
  */
 public static void closeAll(@NotNull Closeable... toClose) {
   for (Closeable e : toClose) {
     if (e != null) {
       try {
         e.close();
       } catch (IOException e1) {
         // ignore
       }
     }
   }
 }
 @Override
 public void close() {
   for (Object it : cache.values()) {
     if (it instanceof Closeable) {
       try {
         ((Closeable) it).close();
       } catch (IOException e) {
         error(e);
       }
     }
   }
 }
    void closeQuietly(final Closeable closeable) {

      if (closeable != null) {

        try {
          closeable.close();
        } catch (final IOException e) {

          e.printStackTrace();
        }
      }
    }
Exemple #25
0
  protected boolean close(Closeable closeable) {
    if (closeable != null) {
      try {
        closeable.close();

        return true;
      } catch (IOException e) {
        // mute
      }
    }

    return false;
  }
 /**
  * Helper method used when value to serialize is {@link Closeable} and its <code>close()</code>
  * method is to be called right after serialization has been called
  */
 private final void _writeCloseableValue(JsonGenerator jgen, Object value, SerializationConfig cfg)
     throws IOException, JsonGenerationException, JsonMappingException {
   Closeable toClose = (Closeable) value;
   try {
     if (_rootType == null) {
       _serializerProvider(cfg).serializeValue(jgen, value);
     } else {
       _serializerProvider(cfg).serializeValue(jgen, value, _rootType, _rootSerializer);
     }
     if (_config.isEnabled(SerializationFeature.FLUSH_AFTER_WRITE_VALUE)) {
       jgen.flush();
     }
     Closeable tmpToClose = toClose;
     toClose = null;
     tmpToClose.close();
   } finally {
     if (toClose != null) {
       try {
         toClose.close();
       } catch (IOException ioe) {
       }
     }
   }
 }
Exemple #27
0
 public static void close(final Closeable closeable) {
   if (closeable == null) return;
   try {
     if (Flushable.class.isInstance(closeable)) {
       ((Flushable) closeable).flush();
     }
   } catch (Throwable e) {
     // Ignore
   }
   try {
     closeable.close();
   } catch (Throwable e) {
     // Ignore
   }
 }
 public void closePrinters() throws PrinterManagerException {
   PrinterManagerException printerManagerException = new PrinterManagerException();
   for (Printer printer : printers) {
     if (printer instanceof Closeable) {
       try {
         ((Closeable) printer).close();
       } catch (PrinterException e) {
         printerManagerException.addPrinterException(e);
       }
     }
   }
   if (!printerManagerException.getPrinterExceptions().isEmpty()) {
     throw printerManagerException;
   }
 }
Exemple #29
0
 /**
  * Method that will close an {@link java.io.Closeable} ignoring it if it is null and ignoring
  * exceptions.
  *
  * @param closeable the closeable to close.
  * @since jEdit 4.3pre8
  */
 public static void closeQuietly(Closeable closeable) {
   if (closeable != null) {
     try {
       if (closeable instanceof Flushable) {
         ((Flushable) closeable).flush();
       }
     } catch (IOException e) {
       // ignore
     }
     try {
       closeable.close();
     } catch (IOException e) {
       // ignore
     }
   }
 } // }}}
Exemple #30
0
  /**
   * Writes the RTF document and send the output to an {@link Appendable}. This method closes the
   * {@link Appendable} after writing if its of type {@link Closeable}.
   *
   * @param out Destination of this RTF output.
   */
  public void out(Appendable out) {
    if (out == null) throw new IllegalArgumentException("Appendable is not allowed to be null");

    try {
      writeRtfDocument(out);
    } catch (IOException e) {
      throw new RtfException(e);
    } finally {
      if (out instanceof Closeable)
        try {
          ((Closeable) out).close();
        } catch (IOException e) {
          throw new RtfException(e);
        }
    }
  }