}
        try {
            if (writer != null) {
                new SettingsStaxWriter().write(writer, content);
            } else {
                new SettingsStaxWriter().write(outputStream, content);
            }
        } catch (Exception e) {
            throw new XmlWriterException("Unable to write settings", e);
        }
    }

        }
        try {
            if (writer != null) {
                new SettingsStaxWriter().write(writer, content);
            } else {
                new SettingsStaxWriter().write(outputStream, content);
            }
        } catch (Exception e) {
            throw new XmlWriterException("Unable to write settings: " + getMessage(e), getLocation(e), e);
        }
    }

    static final int ACCESS_MASK = 1;
    static final int WRITE_MASK = 2;
    static final int WEAK_MASK = 4;

    /** Look-up table for factories. */
    static final EntryFactory[] factories = {
      STRONG,
      STRONG_ACCESS,
      STRONG_WRITE,
      STRONG_ACCESS_WRITE,
      WEAK,
      WEAK_ACCESS,
      WEAK_WRITE,
      WEAK_ACCESS_WRITE,
    };

    static EntryFactory getFactory(

          -20,
          Double.NaN,
          Double.NEGATIVE_INFINITY,
          -0.001);

  public void testFuzzyEqualsFinite() {
    for (double a : FINITE_DOUBLE_CANDIDATES) {
      for (double b : FINITE_DOUBLE_CANDIDATES) {
        for (double tolerance : FINITE_TOLERANCE_CANDIDATES) {
          assertEquals(Math.abs(a - b) <= tolerance, DoubleMath.fuzzyEquals(a, b, tolerance));
        }
      }
    }
  }

        return asStream(form.docId).contentType(getImageMimeType(thumbnailFile)).stream(out -> {
            try (BufferedInputStream in = new BufferedInputStream(new FileInputStream(thumbnailFile))) {
                out.write(in);
            }
        });
    }

    protected String getImageMimeType(final File imageFile) {
        final String path = imageFile.getAbsolutePath();
        if (path.endsWith(".png")) {

        }
    }

    public void exportCsv(final Writer writer) {
        final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
        final CsvConfig cfg = new CsvConfig(',', '"', '"');
        cfg.setEscapeDisabled(false);
        cfg.setQuoteDisabled(false);
        @SuppressWarnings("resource")
        final CsvWriter csvWriter = new CsvWriter(writer, cfg);
        try {

   * {@code Writer}. When the returned {@code OutputStream} is closed, so is the backing {@code
   * Writer}.
   */
  @J2ktIncompatible
  @GwtIncompatible // Writer,OutputStream
  public abstract OutputStream encodingStream(Writer writer);

  /**
   * Returns a {@code ByteSink} that writes base-encoded bytes to the specified {@code CharSink}.
   */
  @J2ktIncompatible

   * instead.
   *
   * <p>Unfortunately, the method reference {@code Optional::toJavaUtil} will not work, because it
   * could refer to either the static or instance version of this method. Write out the lambda
   * expression {@code o -> Optional.toJavaUtil(o)} instead.
   *
   * @since 21.0
   */
  @CheckForNull
  public static <T> java.util.Optional<T> toJavaUtil(@CheckForNull Optional<T> googleOptional) {

    final EnumSet<E> delegate;

    EnumSerializedForm(EnumSet<E> delegate) {
      this.delegate = delegate;
    }

    Object readResolve() {
      // EJ2 #76: Write readObject() methods defensively.
      return new ImmutableEnumSet<E>(delegate.clone());
    }

    private static final long serialVersionUID = 0;
  }

            final Path path = Paths.get(logFilePath, filename);
            return asStream(filename).contentTypeOctetStream().stream(out -> {
                try (InputStream in = Files.newInputStream(path)) {
                    out.write(in);
                }
            });
        }
        throwValidationError(messages -> messages.addErrorsCouldNotFindLogFile(GLOBAL, filename), this::asIndexHtml);
        return redirect(getClass()); // no-op
    }