*/
    protected String decode(final String host) {
        if (host.indexOf('%') == -1) {
            return host;
        }
        try {
            return URLDecoder.decode(host, encoding);
        } catch (final UnsupportedEncodingException e) {
            return host;
        }
    }

    /**
     * Converts the given host string to ASCII using IDN.
     *
     * @param host the host string to convert

        add(buildCryptoSx(client)) // 521 - server down
      }
      add(buildChantra(client))
    }

  private fun getByIp(host: String): InetAddress =
    try {
      InetAddress.getByName(host)
    } catch (e: UnknownHostException) {
      // unlikely
      throw RuntimeException(e)
    }

  protected AbstractLoadingCache() {}

  @CanIgnoreReturnValue // TODO(b/27479612): consider removing this?
  @Override
  public V getUnchecked(K key) {
    try {
      return get(key);
    } catch (ExecutionException e) {
      throw new UncheckedExecutionException(e.getCause());
    }
  }

  @Override
  public ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {

                                currentID = "";
                            }
                        }
                    }
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
                _defaultParallel = socketToCore.values().stream().mapToInt(i -> i).sum();

            clientConnectionManager.closeExpired();
            // Close idle connections
            clientConnectionManager.closeIdle(TimeValue.ofMilliseconds(idleConnectionTimeout));
        } catch (final Exception e) {
            logger.warn("A connection monitoring exception occurs.", e);
        }
    }

                Duration.between(Instant.ofEpochMilli(resource.getTransferStartTime()), MonotonicClock.now());
        if ((duration.getSeconds() | duration.getNano()) > 0) { // duration.isPositive()
            long bytesPerSecond = Math.round(contentLength / (double) duration.toSeconds());
            message.append(" at ");
            format.format(message, bytesPerSecond);
            message.append("/s");
        }

        message.append(')');

                webConfigService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
                logger.info("Created web config: {}", entity.getName());
            } catch (final Exception e) {
                logger.warn("Failed to create web config: {}", form.name, e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

        try {
            Field field = getField(obj.getClass(), fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            throw new RuntimeException("Failed to get field value: " + fieldName, e);
        }
    }

    private void setFieldValue(Object obj, String fieldName, Object value) throws Exception {

   */
  public static void initialize(Class<?>... classes) {
    for (Class<?> clazz : classes) {
      try {
        Class.forName(clazz.getName(), true, clazz.getClassLoader());
      } catch (ClassNotFoundException e) {
        throw new AssertionError(e);
      }
    }
  }

  /**
   * Returns a proxy instance that implements {@code interfaceType} by dispatching method

                    || resp.getStatus() == TransPeekNamedPipeResponse.STATUS_SERVER_END_CLOSED) {
                fd.markClosed();
                return 0;
            }
            return resp.getAvailable();
        } catch (final SmbException se) {
            throw seToIoe(se);
        }
    }

    @Override
    public void close() {
        // ignore, the shared file descriptor is closed by the pipe handle
    }