}

    /**
     * Wraps the writer with a {@link BufferedWriter} if necessary.
     *
     * @param writer the writer
     * @return the wrapped writer
     */
    protected static Writer wrap(final Writer writer) {
        if (writer instanceof BufferedWriter) {
            return writer;
        }
        if (writer instanceof StringWriter) {
            return writer;
        }

  /**
   * Puts a chunk of an array of bytes into this sink. {@code bytes[off]} is the first byte written,
   * {@code bytes[off + len - 1]} is the last.
   *
   * @param bytes a byte array
   * @param off the start offset in the array
   * @param len the number of bytes to write
   * @return this instance
   * @throws IndexOutOfBoundsException if {@code off < 0} or {@code off + len > bytes.length} or

    /**
     * Converts a long value to hexadecimal characters and writes them to the specified character array.
     *
     * @param val the long value to convert to hexadecimal characters
     * @param dst the destination character array to write the hex digits into
     * @param dstIndex the starting index in the destination array
     * @param size the number of hex digits to write (will be left-padded with zeros)
     */

        }

        @Override
        public void write(final byte[] b) throws IOException {
            stream.write(b);
            collector.write(b);
        }

        @Override
        public void write(final byte[] b, final int off, final int len) throws IOException {
            stream.write(b, off, len);
            collector.write(b, off, len);
        }

        @Override

}

// EncodeMsg implements msgp.Encodable
func (z *metacache) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 13
	// write "end"
	err = en.Append(0x8d, 0xa3, 0x65, 0x6e, 0x64)
	if err != nil {
		return
	}
	err = en.WriteTime(z.ended)
	if err != nil {
		err = msgp.WrapError(err, "ended")
		return
	}
	// write "st"
	err = en.Append(0xa2, 0x73, 0x74)
	if err != nil {
		return
	}

        return 0;
    }

    /**
     * Encode this request (no-op since there's no data)
     *
     * @param dst destination buffer
     * @param dstIndex starting offset
     * @return number of bytes written (always 0)
     */
    public int encode(byte[] dst, int dstIndex) {
        // No data to encode
        return 0;
    }

In this example, the messages will be written to the `log.txt` file *after* the response is sent.

If there was a query in the request, it will be written to the log in a background task.

And then another background task generated at the *path operation function* will write a message using the `email` path parameter.

## Technical Details { #technical-details }

      throws IOException {
    StringWriter writer = new StringWriter();
    try (OutputStream encodingStream = encoding.encodingStream(writer)) {
      encodingStream.write(decoded.getBytes(UTF_8));
    }
    assertThat(writer.toString()).isEqualTo(encoded);
  }

  @GwtIncompatible // Reader
  private static void testStreamingDecodes(BaseEncoding encoding, String encoded, String decoded)
      throws IOException {

        assertEquals(0x00, SMBUtil.readInt2(buffer, 10));

        // Verify filename
        String actualFilename = readString(buffer, 12, written - 12);
        assertEquals(TEST_FILENAME, actualFilename);

        // Verify total bytes written
        assertTrue(written >= 12 + TEST_FILENAME.length());
    }

    @Test
    void testWriteDataWireFormat() {
        // Test data wire format writing (should return 0)

   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.
   * However, we can't usually write {@code throw t;} when {@code t} has a static type of {@link
   * Throwable}. But we <i>can</i> write {@code sneakyThrow(t);}.
   *