*
     * @return length in bytes
     */
    public int getLength() {
        return transform.getLength();
    }

    /**
     * Get the underlying RDMA transform structure
     *
     * @return RDMA transform
     */
    public Smb2RdmaTransform getTransform() {
        return transform;
    }

    /**
     * Encode to byte array for SMB2 READ/WRITE channel info
     *

     * @param offset the offset in the data buffer
     * @param length the number of bytes to write
     */
    public void setData(final byte[] data, final int offset, final int length) {
        this.data = data;
        this.dataOffset = offset;
        this.dataLength = length;
    }

    /**
     * Sets the number of bytes remaining to be written in a sequence of write operations.
     *

                final byte[] bytes = new byte[4096];
                int length = bis.read(bytes);
                while (length != -1) {
                    if (length != 0) {
                        final int len = length;
                        logger.fine(() -> {
                            try {
                                return "<<< " + new String(bytes, 0, len, encoding);

   *   <li>The space character " " is converted into a plus sign "+".
   *   <li>All other characters are converted into one or more bytes using UTF-8 encoding and each
   *       byte is then represented by the 3-character string "%XY", where "XY" is the two-digit,
   *       uppercase, hexadecimal representation of the byte value.
   * </ul>
   *
   * <p>This escaper is suitable for escaping parameter names and values even when <a

        }
    }

    /**
     * Writes the specified byte array to the file at the given pathname.
     *
     * @param pathname
     *            The path to the file.
     * @param bytes
     *            The byte array to write.
     */
    public static void writeBytes(final String pathname, final byte[] bytes) {
        try (FileOutputStream fos = OutputStreamUtil.create(new File(pathname))) {

      sink.writeByte(accumulator.toInt())
    }
  }

  fun encodedLength(bytes: ByteString): Int {
    var bitCount = 0L

    for (i in 0 until bytes.size) {
      val byteIn = bytes[i] and 0xff
      bitCount += CODE_BIT_COUNTS[byteIn].toLong()
    }

    return ((bitCount + 7) shr 3).toInt() // Round up to an even byte.
  }

  fun decode(
    source: BufferedSource,
    byteCount: Long,

        byte[] dst = new byte[15]; // Increased buffer size to accommodate offset + 8 bytes
        int offset = 3; // start in the middle to ensure no tail is overwritten
        int bytesWritten = cmd.writeParametersWireFormat(dst, offset);
        assertEquals(8, bytesWritten, "writeParametersWireFormat should write 8 bytes");

        byte[] expected = expectedParameters(fid, securityInformation);

		}
		w.writeType(buf, typ)
	}
	buf.WriteByte(')')
}

func (w *Walker) typeString(typ types.Type) string {
	var buf bytes.Buffer
	w.writeType(&buf, typ)
	return buf.String()
}

func (w *Walker) signatureString(sig *types.Signature) string {
	var buf bytes.Buffer
	w.writeSignature(&buf, sig)
	return buf.String()
}

func (w *Walker) emitObj(obj types.Object) {
	switch obj := obj.(type) {

	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z RMetricName) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendString(o, string(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *RMetricName) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 string
		zb0001, bts, err = msgp.ReadStringBytes(bts)

{* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}

### `HTMLResponse` { #htmlresponse }

Takes some text or bytes and returns an HTML response, as you read above.

### `PlainTextResponse` { #plaintextresponse }

Takes some text or bytes and returns a plain text response.

{* ../../docs_src/custom_response/tutorial005.py hl[2,7,9] *}

### `JSONResponse` { #jsonresponse }