Allows the binary reader to avoid allocating PresenceBitmaps when a macro signature has less than 5 required parameters.

[tgregg]

Description of changes:
This reduces allocations for these common signature shapes. We can expect to see additional improvements using pooling/caching and/or precomputation for known signatures.

Before: 271 ms/op
After: 264 ms/op (-2.6%)

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

[popematt]

I think in the long run, the existing abstraction may work for the writer, but for the reader we need something that is implemented a bit more like an iterator (and can be pooled). Something like this, I think:

class PresenceBitsReader {

    var buffer: ByteArray = emptyArray()
    var startInclusive: Int = 0
    var endExclusive: Int = 0
    // Tracks pairs of bits rather than bytes.
    var i: Int = 0

    fun init(buffer: ByteArray, startInclusive: Int, endExclusive: Int) {
        i = 0
        // ...copy the rest of the fields in, too
    }

    fun hasNext() = i / 4 < endExclusive

    // Returns the next raw AEB value: 0, 1, or 2
    fun next(): Int {
        val byte = buffer[i / 4]
        val bit_position = i mod 4
        i++
        return when (bit_position) {
            0 -> (byte and 0b00000011)
            1 -> (byte and 0b00001100) ushr 2
            2 -> (byte and 0b00110000) ushr 4
            3 -> (byte and 0b11000000) ushr 6
            else -> throw IllegalStateException("Unreachable")
        }
    }
}