try {
                            long retryDelay = Math.min(MAX_RETRY_DELAY,
                                    BASE_RETRY_DELAY * (1L << Math.min(MAX_BACKOFF_SHIFT, getFailureCount(handle))));
                            Thread.sleep(retryDelay);
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();

      supplier =
          new Supplier<LongAddable>() {
            @Override
            public LongAddable get() {
              return new LongAdder();
            }
          };
    } catch (Throwable t) { // we really want to catch *everything*
      supplier =
          new Supplier<LongAddable>() {
            @Override
            public LongAddable get() {
              return new PureJavaLongAddable();
            }

     */
    public static FileOutputStream create(final File file) {
        assertArgumentNotNull("file", file);

        try {
            return new FileOutputStream(file);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Flushes the {@link OutputStream}.
     *
     * @param out the output stream
     */

                    ssn.treeConnectLogon();
                }
            }
            return new NtlmChallenge(trans.getServerEncryptionKey(), dc);
        } catch (final SmbException e) {
            throw e;
        } catch (final IOException e) {
            throw new SmbException("Connection failed", e);
        }
    }

    /**
     * @return
     */

                if (timeObj2 == null) {
                    return 1;
                }

                return o1.toString().compareTo(o2.toString());
            });
            return array;
        } catch (final IndexNotFoundException e) {
            return new Map[0];
        }
    }

    /**
     * Add a value to array index.
     * @param index Index
     * @param type Type
     * @param id ID

     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, Settings settings) throws IOException {
        try {
            delegate.write(writer, settings.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException("Error writing settings to " + writer, e);
        }
    }

    /**
     * Method write.
     *
     * @param stream a stream object.

                    isBind = true;
                }
            } catch (final LdapConfigurationException e) {
                logger.warn("LDAP configuration error: {}", e.getMessage(), e);
            } catch (final LdapOperationException e) {
                logger.warn("LDAP connection failed: {}", e.getMessage(), e);
            } catch (final Exception e) {

  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;
      }
    }
  }

  /**

        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            handleLeaseBreak(key, newState);
        });

        try {
            future.get(timeoutSeconds, TimeUnit.SECONDS);
        } catch (TimeoutException e) {
            // Force lease release if break handling times out
            LeaseEntry entry = leases.get(key);
            if (entry != null) {

                docBuilder.build(doc)
                return doc
            } catch (ClassDocGenerationException e) {
                throw e
            } catch (Exception e) {
                throw new ClassDocGenerationException("Could not load the class documentation for class '$className'.", e)
            }
        } finally {