QpackUtil Class — netty Architecture

Source Code

codec-http3/src/main/java/io/netty/handler/codec/http3/QpackUtil.java lines 26–468

final class QpackUtil {
    private static final QpackException PREFIXED_INTEGER_TOO_LONG =
            QpackException.newStatic(QpackDecoder.class, "toIntOrThrow(...)",
                    "QPACK - invalid prefixed integer");

    /**
     * Encode integer according to
     * <a href="https://tools.ietf.org/html/rfc7541#section-5.1">Section 5.1</a>.
     */
    static void encodePrefixedInteger(ByteBuf out, byte mask, int prefixLength, long toEncode) {
        checkInRange(toEncode, 0, MAX_UNSIGNED_INT, "toEncode");
        int nbits = (1 << prefixLength) - 1;
        if (toEncode < nbits) {
            out.writeByte((byte) (mask | toEncode));
        } else {
            out.writeByte((byte) (mask | nbits));
            long remainder = toEncode - nbits;
            while (remainder > 128) {
                byte next = (byte) ((remainder % 128) | 0x80);
                out.writeByte(next);
                remainder = remainder / 128;
            }
            out.writeByte((byte) remainder);
        }
    }

    /**
     * Decode the integer or return {@code -1} if not enough bytes are readable.
     * This method increases the readerIndex when the integer could be decoded.
     *
     * @param in the input {@link ByteBuf}
     * @param prefixLength the prefix length
     * @return the integer or {@code -1} if not enough readable bytes are in the {@link ByteBuf).
     */
    static int decodePrefixedIntegerAsInt(ByteBuf in, int prefixLength) throws QpackException {
        return toIntOrThrow(decodePrefixedInteger(in, prefixLength));
    }

    /**
     * Converts the passed {@code aLong} to an {@code int} if the value can fit an {@code int}, otherwise throws a
     * {@link QpackException}.
     *
     * @param aLong to convert.
     * @throws QpackException If the value does not fit an {@code int}.
     */
    static int toIntOrThrow(long aLong) throws QpackException {
        if ((int) aLong != aLong) {
            throw PREFIXED_INTEGER_TOO_LONG;
        }
        return (int) aLong;
    }

    /**
     * Decode the integer or return {@code -1} if not enough bytes are readable.
     * This method increases the readerIndex when the integer could be decoded.
     *
     * @param in the input {@link ByteBuf}
     * @param prefixLength the prefix length
     * @return the integer or {@code -1} if not enough readable bytes are in the {@link ByteBuf).
     */
    static long decodePrefixedInteger(ByteBuf in, int prefixLength) {
        int readerIndex = in.readerIndex();
        int writerIndex = in.writerIndex();
        if (readerIndex == writerIndex) {
            return -1;
        }

        int nbits = (1 << prefixLength) - 1;
        int first = in.readByte() & nbits;
        if (first < nbits) {
            return first;
        }

        int idx = readerIndex + 1;
        long i = first;
        int factor = 0;
        byte next;
        do {
            if (idx == writerIndex) {
                in.readerIndex(readerIndex);
                return -1;