Add Buffer.Bytes() and Buffer.RawBytes().

Author: tunabay

buffer_rw.go

@@ -100,6 +100,28 @@ func (buf *Buffer) PutByteAt(off int, b byte) {
 	copyBits(buf.b, []byte{b}, buf.off+off, 0, 8)
 }
 
+// RawBytes returns all the bits of the buffer as a byte slice. The caller must
+// not change the contents of the returned byte slice. The slice returned may or
+// may not reference to the internal buffer itself of buf, depending on whether
+// bit-shifting is needed of not. Also, if buf.Len() is not a multiple of 8, the
+// bits after the last bit in the slice returned are undefined. The main purpose
+// of RawBytes is to efficiently pass bit data to other byte-oriented APIs. In
+// general, it is recommended to use the safer Bytes() instead.
+func (buf *Buffer) RawBytes() []byte {
+	if buf.off&7 == 0 {
+		return buf.b[buf.off>>3 : (buf.off+buf.nBits+7)>>3]
+	}
+	return buf.Bytes()
+}
+
+// Bytes returns all the bits of the buffer as a byte slice. If buf.Len() is not
+// a multiple of 8, it will be padded with 0.
+func (buf *Buffer) Bytes() []byte {
+	b := make([]byte, (buf.nBits+7)>>3)
+	copyBits(b, buf.b, 0, buf.off, buf.nBits)
+	return b
+}
+
 // BytesAt reads 8 * nBytes bits starting at the offset off and returns them as
 // a byte slice. Note that off is in bits, not bytes. If the off is not a
 // multiple of 8, it returns a properly shifted byte slice.

buffer_rw_example_test.go

@@ -94,6 +94,32 @@ func ExampleBuffer_PutByteAt() {
 	// 00111100000000
 }
 
+func ExampleBuffer_RawBytes() {
+	ba := bitarray.MustParse("1111-0000 1010-1010 1111-1111 11")
+	buf := bitarray.NewBufferFromBitArray(ba)
+
+	// not byte-aligned, copied, 0-padded
+	fmt.Printf("%08b\n", buf.Slice(3, 24).RawBytes())
+	// byte-aligned, not copied, not 0-padded
+	fmt.Printf("%08b\n", buf.Slice(3, 24).Slice(5, 16).RawBytes())
+
+	// Output:
+	// [10000101 01010111 11111000]
+	// [10101010 11111111]
+}
+
+func ExampleBuffer_Bytes() {
+	ba := bitarray.MustParse("1100-1010 1010-1111 0101-11")
+	buf := bitarray.NewBufferFromBitArray(ba)
+
+	fmt.Printf("%08b\n", buf.Bytes())
+	fmt.Printf("%08b\n", buf.Slice(4, 20).Bytes())
+
+	// Output:
+	// [11001010 10101111 01011100]
+	// [10101010 11110101]
+}
+
 func ExampleBuffer_BytesAt() {
 	ba := bitarray.MustParse("1100-1010 0011-1111 1010-0000 0111-1000")
 	buf := bitarray.NewBufferFromBitArray(ba)

buffer_rw_test.go

@@ -282,6 +282,94 @@ func TestBuffer_PutByteAt(t *testing.T) {
 	chkpanic(0, 0)
 }
 
+func TestBuffer_RawBytes(t *testing.T) {
+	chk := func(buf *bitarray.Buffer, want ...byte) {
+		t.Helper()
+		got := buf.RawBytes()
+		if !bytes.Equal(got, want) {
+			t.Error("unexpected RawBytes():")
+			t.Logf(" got: %08b", got)
+			t.Logf("want: %08b", want)
+			t.Logf(" buf: %s", buf.D())
+		}
+	}
+
+	ba := bitarray.MustParse("1100-1111 0000-1010 1100-1110 0011-01")
+	buf := bitarray.NewBufferFromBitArray(ba)
+	chk(
+		buf,
+		0b_1100_1111, 0b_0000_1010, 0b_1100_1110, 0b_0011_0100,
+	)
+	chk(
+		buf.Slice(0, 17),
+		0b_1100_1111, 0b_0000_1010, 0b_1100_1110,
+	)
+	chk(
+		buf.Slice(4, 28),
+		0b_1111_0000, 0b_1010_1100, 0b_1110_0011,
+	)
+	chk(
+		buf.Slice(4, 24),
+		0b_1111_0000, 0b_1010_1100, 0b_1110_0000,
+	)
+	chk(
+		buf.Slice(4, 24).SliceToEnd(4),
+		0b_0000_1010, 0b_1100_1110,
+	)
+	chk(
+		buf.Slice(4, 24).Slice(4, 16),
+		0b_0000_1010, 0b_1100_1110,
+	)
+	chk(
+		buf.Slice(4, 24).SliceToEnd(6),
+		0b_0010_1011, 0b_0011_1000,
+	)
+}
+
+func TestBuffer_Bytes(t *testing.T) {
+	chk := func(buf *bitarray.Buffer, want ...byte) {
+		t.Helper()
+		got := buf.Bytes()
+		if !bytes.Equal(got, want) {
+			t.Error("unexpected Bytes():")
+			t.Logf(" got: %08b", got)
+			t.Logf("want: %08b", want)
+			t.Logf(" buf: %s", buf.D())
+		}
+	}
+
+	ba := bitarray.MustParse("1100-1111 0000-1010 1100-1110 0011-01")
+	buf := bitarray.NewBufferFromBitArray(ba)
+	chk(
+		buf,
+		0b_1100_1111, 0b_0000_1010, 0b_1100_1110, 0b_0011_0100,
+	)
+	chk(
+		buf.Slice(0, 17),
+		0b_1100_1111, 0b_0000_1010, 0b_1000_0000,
+	)
+	chk(
+		buf.Slice(4, 28),
+		0b_1111_0000, 0b_1010_1100, 0b_1110_0011,
+	)
+	chk(
+		buf.Slice(4, 24),
+		0b_1111_0000, 0b_1010_1100, 0b_1110_0000,
+	)
+	chk(
+		buf.Slice(4, 24).SliceToEnd(4),
+		0b_0000_1010, 0b_1100_1110,
+	)
+	chk(
+		buf.Slice(4, 24).Slice(4, 16),
+		0b_0000_1010, 0b_1100_0000,
+	)
+	chk(
+		buf.Slice(4, 24).SliceToEnd(6),
+		0b_0010_1011, 0b_0011_1000,
+	)
+}
+
 func TestBuffer_BytesAt(t *testing.T) {
 	buf := bitarray.NewBuffer(30)
 	chk := func(off, nBytes int, want ...byte) {