} //-- void setStringFormatter(InputLocation.StringFormatter)

#end
    /**
     * Method write.
     *
     * @param writer a writer object
     * @param ${rootLcapName} a ${root.name} object
     * @throws IOException IOException if any
     */
    public void write(Writer writer, ${root.name} ${rootLcapName}) throws IOException, XMLStreamException {

type osError struct {
	err error
}

func (b *Writer) write0(buf []byte) {
	n, err := b.output.Write(buf)
	if n != len(buf) && err == nil {
		err = io.ErrShortWrite
	}
	if err != nil {
		panic(osError{err})
	}
}

func (b *Writer) writeN(src []byte, n int) {
	for n > len(src) {
		b.write0(src)
		n -= len(src)
	}
	b.write0(src[0:n])
}

var (
	newline = []byte{'\n'}

}

// NewWriter returns a new [Writer].
// Writes to the returned writer are compressed and written to w.
//
// It is the caller's responsibility to call Close on the [Writer] when done.
// Writes may be buffered and not flushed until Close.
//
// Callers that wish to set the fields in Writer.Header must do so before
// the first call to Write, Flush, or Close.
func NewWriter(w io.Writer) *Writer {

    def writer = new StringWriter()
    @Subject context = new JavadocOptionFileWriterContext(writer)

    def "writes"() {
        when: context.write("dummy")
        then: writer.toString() == "dummy"
    }

    def "writes new line"() {
        when: context.write("a").newLine().write("b")
        then: writer.toString() == "a${SystemProperties.instance.getLineSeparator()}b"
    }

     * @throws IOException If the model could not be serialized.
     */
    void write(File output, Map<String, Object> options, Model model) throws IOException;

    /**
     * Writes the supplied model to the specified character writer. The writer will be automatically closed before the
     * method returns.
     *
     * @param output The writer to serialize the model to, must not be {@code null}.

	return w.pw.Write(p)
}

// Close closes the writer.
// Any accepted writes will be flushed. Any new writes will be rejected.
// Once Close() exits, files are synchronized to disk.
func (w *Writer) Close() error {
	w.pw.CloseWithError(nil)

	if w.f != nil {
		if err := w.closeCurrentFile(); err != nil {
			return err
		}
	}

	return nil
}

     * @throws IOException If the settings could not be serialized.
     */
    void write(File output, Map<String, Object> options, Settings settings) throws IOException;

    /**
     * Writes the supplied settings to the specified character writer. The writer will be automatically closed before
     * the method returns.
     *
     * @param output The writer to serialize the settings to, must not be {@code null}.

}

// WriteCounters writes coverage counter-data content for the
// currently running program to the writer 'w'. An error will be
// returned if the operation can't be completed successfully (for
// example, if the currently running program was not built with
// "-cover", or if a write fails). The counter data written will be a
// snapshot taken at the point of the invocation.
func WriteCounters(w io.Writer) error {

// EncodeMsg implements msgp.Encodable
func (z *lockRequesterInfo) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 9
	// write "Name"
	err = en.Append(0x89, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	if err != nil {
		return
	}
	err = en.WriteString(z.Name)
	if err != nil {
		err = msgp.WrapError(err, "Name")
		return
	}
	// write "Writer"
	err = en.Append(0xa6, 0x57, 0x72, 0x69, 0x74, 0x65, 0x72)
	if err != nil {

import (
	"context"
	"fmt"
	"io"
)

// Writes to multiple writers
type multiWriter struct {
	writers     []io.Writer
	writeQuorum int
	errs        []error
}

// Write writes data to writers.
func (p *multiWriter) Write(ctx context.Context, blocks [][]byte) error {
	for i := range p.writers {
		if p.errs[i] != nil {
			continue
		}
		if p.writers[i] == nil {
			p.errs[i] = errDiskNotFound
			continue