}

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param persistedToolchains a persistedToolchains object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, PersistedToolchains persistedToolchains) throws IOException {
        try {
            delegate.write(writer, persistedToolchains.getDelegate());

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param model a model object.
     * @throws IOException java.io.IOException if any.
     */
    @Override
    public void write(Writer writer, Model model) throws IOException {
        super.write(writer, model);
    } // -- void write( Writer, Model )

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

        delegate.setFileComment(fileComment);
    }

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param settings a settings object.
     * @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) {

    object : ForwardingSink(sink) {
      @Throws(IOException::class)
      override fun write(
        source: Buffer,
        byteCount: Long,
      ) {
        val bytes = source.readByteString(byteCount)
        delegate.write(
          Buffer()
            .write(bytes.toAsciiUppercase()),
          byteCount,
        )
      }
    }

		writer.WriteByte('(')
		for idx, d := range v {
			if idx > 0 {
				writer.WriteByte(',')
			}
			stmt.QuoteTo(writer, d)
		}
		writer.WriteByte(')')
	case clause.Expr:
		v.Build(stmt)
	case string:
		stmt.DB.Dialector.QuoteTo(writer, v)
	case []string:
		writer.WriteByte('(')
		for idx, d := range v {
			if idx > 0 {
				writer.WriteByte(',')
			}

In OkHttp we expose a blocking API over a framed protocol. This document explains the code and policy that makes that work.

### Threads

#### Application's calling thread

		Name: "lorem.txt",
		Mode: 0600,
		Size: int64(len(inp)),
	})
	if err != nil {
		f.Fatalf("failed to create writer: %s", err)
	}
	_, err = w.Write(inp)
	if err != nil {
		f.Fatalf("failed to write file to archive: %s", err)
	}
	if err := w.Close(); err != nil {
		f.Fatalf("failed to write archive: %s", err)
	}
	f.Add(b.Bytes())

	f.Fuzz(func(t *testing.T, b []byte) {
		r := NewReader(bytes.NewReader(b))

var flateWriterPool sync.Pool

func newFlateWriter(w io.Writer) io.WriteCloser {
	fw, ok := flateWriterPool.Get().(*flate.Writer)
	if ok {
		fw.Reset(w)
	} else {
		fw, _ = flate.NewWriter(w, 5)
	}
	return &pooledFlateWriter{fw: fw}
}

type pooledFlateWriter struct {
	mu sync.Mutex // guards Close and Write
	fw *flate.Writer
}

func (w *pooledFlateWriter) Write(p []byte) (n int, err error) {
	w.mu.Lock()

        this.fileComment = fileComment;
    } // -- void setFileComment( String )

    /**
     * Method write.
     *
     * @param writer a writer object.
     * @param coreExtensions a coreExtensions object.
     * @throws IOException IOException if any.
     */
    public void write(Writer writer, CoreExtensions coreExtensions) throws IOException {
        XmlSerializer serializer = new MXSerializer();

    val newMaxFrameSize = 16777215
    val writer = Http2Writer(Buffer(), true)
    writer.applyAndAckSettings(Settings().set(Settings.MAX_FRAME_SIZE, newMaxFrameSize))
    assertThat(writer.maxDataLength()).isEqualTo(newMaxFrameSize)
    writer.frameHeader(0, newMaxFrameSize, Http2.TYPE_DATA, FLAG_NONE)
  }

  @Test fun streamIdHasReservedBit() {
    val writer = Http2Writer(Buffer(), true)