Path path;
        OutputStream outputStream;
        Writer writer;
        T content;
        Function<Object, String> inputLocationFormatter;

        public XmlWriterRequestBuilder<T> path(Path path) {
            this.path = path;
            return this;
        }

        public XmlWriterRequestBuilder<T> outputStream(OutputStream outputStream) {
            this.outputStream = outputStream;

    public SystemLogger(@Nullable OutputStream out) {
        this(out, null);
    }

    public SystemLogger(@Nullable OutputStream out, @Nullable Level threshold) {
        this.out = new PrintWriter(toPsOrDef(out, System.err), true);
        this.threshold = Objects.requireNonNullElse(threshold, Level.INFO);
    }

    private PrintStream toPsOrDef(OutputStream outputStream, PrintStream def) {

import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.charset.Charset;

/**
 * A destination to which bytes can be written, such as a file. Unlike an {@link OutputStream}, a
 * {@code ByteSink} is not an open, stateful stream that can be written to and closed. Instead, it
 * is an immutable <i>supplier</i> of {@code OutputStream} instances.
 *

    }

    /**
     * Creates an OutputStream from an XContentBuilder using the provided callback function.
     *
     * @param func the callback function to build XContent
     * @param mediaType the media type for the content builder
     * @return an OutputStream containing the built content, or an empty ByteArrayOutputStream if an error occurs
     */

        write(XmlWriterRequest.<T>builder().content(content).path(path).build());
    }

    default void write(@Nonnull T content, @Nonnull OutputStream outputStream) throws XmlWriterException {
        write(XmlWriterRequest.<T>builder()
                .content(content)
                .outputStream(outputStream)
                .build());
    }

    default void write(@Nonnull T content, @Nonnull Writer writer) throws XmlWriterException {

    }
  }

  /**
   * Wraps a {@code PrimitiveSink} as an {@link OutputStream}, so it is easy to {@link Funnel#funnel
   * funnel} an object to a {@code PrimitiveSink} if there is already a way to write the contents of
   * the object to an {@code OutputStream}.
   *
   * <p>The {@code close} and {@code flush} methods of the returned {@code OutputStream} do nothing,
   * and no method throws {@code IOException}.
   *

   * data written to it to the underlying {@link OutputStream}.
   *
   * <p>The {@link OutputStream} should not be written to before or after the hand-off.
   */
  // TODO(user): Evaluate whether it makes sense to always piggyback the computation of a
  // HashCode on an existing OutputStream, compared to creating a separate OutputStream that could
  // be (optionally) be combined with another if needed (with something like

        CloseableUtil.close((OutputStream) null);
    }

    /**
     * @throws Exception
     */
    @Test
    public void testClose_noThrowIOException() throws Exception {
        final OutputStream out = new IOExceptionOccurOutputStream();
        CloseableUtil.close(out);
    }

    private static class NotifyOutputStream extends OutputStream {
        private String notify_;

        @Override

    /**
     * Downloads an object from storage.
     *
     * @param objectName the name/path of the object to download
     * @param outputStream the output stream to write data to
     */
    void downloadObject(String objectName, OutputStream outputStream);

    /**
     * Deletes an object from storage.
     *
     * @param objectName the name/path of the object to delete
     */

                "buildSrc/" + MINIMUM_COMPILER_VERSION_PATH;
    }

    private static class IndentingOutputStream extends OutputStream {

        public final byte[] indent;
        private final OutputStream delegate;

        IndentingOutputStream(OutputStream delegate, Object version) {
            this.delegate = delegate;
            indent = (" [" + version + "] ").getBytes(StandardCharsets.UTF_8);