Merge pull request #4 from tunabay/edge

v1.2.0 rc

Author: tunabay

bitarray_slice.go

@@ -38,6 +38,10 @@ func (ba *BitArray) Slice(start, end int) *BitArray {
 	return &BitArray{b: buf, nBits: nBits}
 }
 
+// SliceToEnd is shorthand for Slice(start, ba.Len()) and returns the subpart
+// from the position specified start to the last bit.
+func (ba *BitArray) SliceToEnd(start int) *BitArray { return ba.Slice(start, ba.Len()) }
+
 // ToWidth returns a new BitArray resized to wid bits with its contents
 // preserved. If wid is less than ba.Len(), some bits will be lost. If wid is
 // greater than be.Len(), the expanded space will be filled with 0s. In both

bitarray_slice_example_test.go

@@ -20,6 +20,16 @@ func ExampleBitArray_Slice() {
 	// 1101
 }
 
+func ExampleBitArray_SliceToEnd() {
+	ba := bitarray.MustParse("0011-1010 01101")
+	fmt.Printf("% b\n", ba.SliceToEnd(4))
+	fmt.Printf("% b\n", ba.SliceToEnd(9))
+
+	// Output:
+	// 10100110 1
+	// 1101
+}
+
 func ExampleBitArray_ToWidth() {
 	ba := bitarray.MustParse("1010-1111 0000-11")
 	fmt.Printf("% s\n", ba.ToWidth(7, bitarray.AlignLeft))

buffer.go

@@ -12,11 +12,11 @@ import (
 // and writing with an offset. It is not safe for concurrent use by multiple
 // goroutines. The zero value for Buffer represents a zero length buffer that
 // can be resized and used.
-type Buffer BitArray
-
-// Buffer fields:
-// .b     []byte // nil only for zero length
-// .nBits int
+type Buffer struct {
+	b     []byte // nil only for zero length
+	nBits int
+	off   int
+}
 
 // NewBuffer creates a Buffer with the specified bit length.
 func NewBuffer(nBits int) *Buffer {
@@ -47,6 +47,33 @@ func NewBufferFromBitArray(ba BitArrayer) *Buffer {
 	return buf
 }
 
+// NewBufferFromByteSlice creates a new Buffer that references an existing byte
+// slice b. The created Buffer references b without copying it, therefore,
+// changes to the buffer affect b and vice versa.  The length of the buffer
+// created will be len(b) * 8. NewBufferFromByteSlice is useful when reading or
+// writing a subpart of a byte slice as a bit array without copying or
+// bit-shifting.
+func NewBufferFromByteSlice(b []byte) *Buffer {
+	return NewBufferFromByteSlicePartial(b, 0, len(b)<<3)
+}
+
+// NewBufferFromByteSlicePartial is identical to NewBufferFromByteSlice except
+// that it creates a buffer with the first bit specified by off, and the length
+// specified by nBits.
+func NewBufferFromByteSlicePartial(b []byte, off, nBits int) *Buffer {
+	switch {
+	case off < 0:
+		panicf("NewBufferFromByteSlice: negative off %d.", nBits)
+	case nBits < 0:
+		panicf("NewBufferFromByteSlice: negative nBits %d.", nBits)
+	case len(b)<<3 < off+nBits:
+		panicf("NewBufferFromByteSlice: out of range: off=%d, nBits=%d > len=%d.", off, nBits, len(b))
+	case nBits == 0:
+		return &Buffer{}
+	}
+	return &Buffer{b: b[off>>3:], nBits: nBits, off: off & 7}
+}
+
 // IsZero returns whether the Buffer is zero length.
 func (buf *Buffer) IsZero() bool {
 	return buf.Len() == 0
@@ -65,22 +92,22 @@ func (buf *Buffer) Clone() *Buffer {
 	if buf.Len() == 0 {
 		return &Buffer{}
 	}
-	b := allocByteSlice(len(buf.b))
-	copy(b, buf.b)
+	b := allocByteSlice((buf.nBits + 7) >> 3)
+	copyBits(b, buf.b, 0, buf.off, buf.nBits)
 
 	return &Buffer{b: b, nBits: buf.nBits}
 }
 
 // BitArray creates an imuurable BitArray from the current content.
 func (buf *Buffer) BitArray() *BitArray {
-	return NewFromBytes(buf.b, 0, buf.nBits)
+	return NewFromBytes(buf.b, buf.off, buf.nBits)
 }
 
 // String returns the string representation of the current content.
 func (buf Buffer) String() string {
 	sb := make([]byte, buf.nBits)
 	for i := 0; i < buf.nBits; i++ {
-		sb[i] = '0' + buf.b[i>>3]>>(7-i&7)&1
+		sb[i] = '0' + buf.b[(buf.off+i)>>3]>>(7-(buf.off+i)&7)&1
 	}
 	return string(sb)
 }
@@ -89,71 +116,51 @@ func (buf Buffer) String() string {
 // bits in the new range to be extended are initialized with 0. When shrinking,
 // the extra bits are truncated. In either case, the align specifies whether to
 // fix the MSBs or the LSBs.
+//
+// Resize always reallocates internal memory. That is, the buffers created by
+// Slice method or NewBufferFromByteSlice break their relationship with the
+// parent buffer or slice by calling this Resize, even if nBits is equivalent to
+// or less than its current size.
 func (buf *Buffer) Resize(nBits int, align Alignment) {
 	switch {
 	case nBits < 0:
 		panicf("Resize: negative nBits %d.", nBits)
-	case nBits == buf.nBits:
-		return
 	case nBits == 0:
 		buf.b = nil
 		buf.nBits = 0
+		buf.off = 0
 		return
 	}
-	nBytes := (nBits + 7) >> 3
 
-	// AlignLeft
-	if align == AlignLeft {
-		// shrink
-		if nBits < buf.nBits {
-			buf.b = buf.b[:nBytes]
-			if nBits&7 != 0 {
-				buf.b[nBits>>3] &= 0xff << (8 - nBits&7)
-			}
-			buf.nBits = nBits
-			return
-		}
-
-		// extend
-		if nBytes <= cap(buf.b) { // enough cap
-			n := len(buf.b)
-			buf.b = buf.b[:nBytes]
-			for ; n < nBytes; n++ {
-				buf.b[n] = 0
-			}
-			buf.nBits = nBits
-			return
-		}
-
-		newb := allocByteSlice(nBytes)
-		copy(newb, buf.b)
-		buf.b = newb
+	b := allocByteSlice((nBits + 7) >> 3)
+	if buf.nBits == 0 {
+		buf.b = b
 		buf.nBits = nBits
+		buf.off = 0
 		return
 	}
-
-	// AlignRight
-	// shrink
-	if nBits < buf.nBits {
-		if nBits&7 == buf.nBits&7 { // no shift
-			buf.b = buf.b[len(buf.b)-nBytes:]
-			buf.nBits = nBits
-			return
+	if align == AlignLeft {
+		if nBits < buf.nBits { // shrink
+			copyBits(b, buf.b, 0, buf.off, nBits)
+		} else { // extend
+			copyBits(b, buf.b, 0, buf.off, buf.nBits)
+		}
+	} else {
+		if nBits < buf.nBits { // shrink
+			copyBits(b, buf.b, 0, buf.off+buf.nBits-nBits, nBits)
+		} else { // extend
+			copyBits(b, buf.b, nBits-buf.nBits, buf.off, buf.nBits)
 		}
-		newb := allocByteSlice(nBytes)
-		_ = copyBits(newb, buf.b, 0, buf.nBits-nBits, nBits)
-		buf.b = newb
-		buf.nBits = nBits
-		return
 	}
 
-	// extend
-	newb := allocByteSlice(nBytes)
-	if buf.b != nil {
-		_ = copyBits(newb, buf.b, nBits-buf.nBits, 0, buf.nBits)
-	}
-	buf.b = newb
+	buf.b = b
 	buf.nBits = nBits
+	buf.off = 0
+}
+
+// FillBits sets all the bits in the buffer to the value bit, 0 or 1.
+func (buf *Buffer) FillBits(bit byte) {
+	buf.FillBitsAt(0, buf.nBits, bit)
 }
 
 // FillBitsAt sets the nBits bits starting at off to the value bit.
@@ -166,12 +173,12 @@ func (buf *Buffer) FillBitsAt(off, nBits int, bit byte) {
 	case buf.nBits < off+nBits:
 		panicf("FillBitsAt: out of range: off=%d + nBits=%d > len=%d.", off, nBits, buf.nBits)
 	case bit&1 == 0:
-		clearBits(buf.b, off, nBits)
+		clearBits(buf.b, buf.off+off, nBits)
 	default:
-		setBits(buf.b, off, nBits)
+		setBits(buf.b, buf.off+off, nBits)
 	}
 }
 
 // Format implements the fmt.Formatter interface to format Buffer value using
 // the standard fmt.Printf family functions.
-func (buf Buffer) Format(s fmt.State, verb rune) { BitArray(buf).Format(s, verb) }
+func (buf Buffer) Format(s fmt.State, verb rune) { buf.BitArray().Format(s, verb) }

buffer_bitwise.go

@@ -4,10 +4,6 @@
 
 package bitarray
 
-import (
-	"math/bits"
-)
-
 // ToggleBitAt flips a single bit at the position specified by off in the
 // buffer.
 func (buf *Buffer) ToggleBitAt(off int) {
@@ -16,9 +12,9 @@ func (buf *Buffer) ToggleBitAt(off int) {
 		panicf("ToggleBitAt: negative off %d.", off)
 	case buf.nBits <= off:
 		panicf("ToggleBitAt: out of range: off=%d >= len=%d.", off, buf.nBits)
-	default:
-		buf.b[off>>3] ^= byte(0x80) >> (off & 7)
 	}
+	off += buf.off
+	buf.b[off>>3] ^= byte(0x80) >> (off & 7)
 }
 
 // ToggleBitsAt inverts the nBits bits starting at off.
@@ -33,7 +29,7 @@ func (buf *Buffer) ToggleBitsAt(off, nBits int) {
 	case nBits == 0:
 		// no-op
 	default:
-		toggleBits(buf.b, off, nBits)
+		toggleBits(buf.b, buf.off+off, nBits)
 	}
 }
 
@@ -53,9 +49,9 @@ func (buf *Buffer) AndAt(off int, x BitArrayer) {
 	case bax.IsZero():
 		// no-op
 	case bax.b == nil:
-		clearBits(buf.b, off, bax.nBits)
+		clearBits(buf.b, buf.off+off, bax.nBits)
 	default:
-		andBits(buf.b, bax.b, off, 0, bax.nBits)
+		andBits(buf.b, bax.b, buf.off+off, 0, bax.nBits)
 	}
 }
 
@@ -74,7 +70,7 @@ func (buf *Buffer) OrAt(off int, x BitArrayer) {
 	case bax.IsZero(), bax.b == nil:
 		// no-op
 	default:
-		orBits(buf.b, bax.b, off, 0, bax.nBits)
+		orBits(buf.b, bax.b, buf.off+off, 0, bax.nBits)
 	}
 }
 
@@ -94,25 +90,15 @@ func (buf *Buffer) XorAt(off int, x BitArrayer) {
 	case bax.IsZero(), bax.b == nil:
 		// no-op
 	default:
-		xorBits(buf.b, bax.b, off, 0, bax.nBits)
+		xorBits(buf.b, bax.b, buf.off+off, 0, bax.nBits)
 	}
 }
 
 // LeadingZeros returns the number of leading zero bits in the Buffer.
-func (buf *Buffer) LeadingZeros() int { return (*BitArray)(buf).LeadingZeros() }
+func (buf *Buffer) LeadingZeros() int { return buf.BitArray().LeadingZeros() }
 
 // TrailingZeros returns the number of trailing zero bits in the Buffer.
-func (buf *Buffer) TrailingZeros() int { return (*BitArray)(buf).TrailingZeros() }
+func (buf *Buffer) TrailingZeros() int { return buf.BitArray().TrailingZeros() }
 
 // OnesCount returns the number of one bits, population count, in the Buffer.
-func (buf *Buffer) OnesCount() int {
-	if buf.IsZero() {
-		return 0
-	}
-	n := 0
-	for _, b := range buf.b {
-		n += bits.OnesCount8(b)
-	}
-
-	return n
-}
+func (buf *Buffer) OnesCount() int { return buf.BitArray().OnesCount() }

buffer_copy.go

@@ -0,0 +1,78 @@
+// Copyright (c) 2021 Hirotsuna Mizuno. All rights reserved.
+// Use of this source code is governed by the MIT license that can be found in
+// the LICENSE file.
+
+package bitarray
+
+// CopyBitsFromBytes reads nBits bits from b at the offset bOff, and write them
+// into the buffer at the offset off.
+func (buf *Buffer) CopyBitsFromBytes(off int, b []byte, bOff, nBits int) {
+	switch {
+	case off < 0:
+		panicf("CopyBitsFromBytes: negative off %d.", off)
+	case buf.nBits < off+nBits:
+		panicf("CopyBitsFromBytes: out of range: off=%d + nBits=%d > len=%d.", off, nBits, buf.nBits)
+	case nBits == 0:
+		return
+	}
+	copyBits(buf.b, b, buf.off+off, bOff, nBits)
+}
+
+// CopyBitsToBytes reads nBits bits of the buffer starting at the offset off,
+// and write them into the byte slice b at the offset bOff.
+func (buf *Buffer) CopyBitsToBytes(off int, b []byte, bOff, nBits int) {
+	switch {
+	case off < 0:
+		panicf("CopyBitsToBytes: negative off %d.", off)
+	case buf.nBits < off+nBits:
+		panicf("CopyBitsToBytes: out of range: off=%d + nBits=%d > len=%d.", off, nBits, buf.nBits)
+	case nBits == 0:
+		return
+	}
+	copyBits(b, buf.b, bOff, buf.off+off, nBits)
+}
+
+// CopyBits copies bits from src into dst. CopyBits returns the number of bits
+// copied, which will be the minimum of src.Len() and dst.Len().
+func CopyBits(dst, src *Buffer) int {
+	nBits := dst.Len()
+	if sLen := src.Len(); sLen < nBits {
+		nBits = sLen
+	}
+	if nBits != 0 {
+		copyBits(dst.b, src.b, dst.off, src.off, nBits)
+	}
+
+	return nBits
+}
+
+// CopyBitsN is identical to CopyBits except that it copies up to nBits bits.
+func CopyBitsN(dst, src *Buffer, nBits int) int {
+	if dLen := dst.Len(); dLen < nBits {
+		nBits = dLen
+	}
+	if sLen := src.Len(); sLen < nBits {
+		nBits = sLen
+	}
+	if nBits != 0 {
+		copyBits(dst.b, src.b, dst.off, src.off, nBits)
+	}
+
+	return nBits
+}
+
+// CopyBitsPartial is identical to CopyBitsN except that it reads and writes
+// bits starting at specified offsets rather than the first bits.
+func CopyBitsPartial(dst, src *Buffer, dstOff, srcOff, nBits int) int {
+	if dLen := dst.Len() - dstOff; dLen < nBits {
+		nBits = dLen
+	}
+	if sLen := src.Len() - srcOff; sLen < nBits {
+		nBits = sLen
+	}
+	if nBits != 0 {
+		copyBits(dst.b, src.b, dst.off+dstOff, src.off+srcOff, nBits)
+	}
+
+	return nBits
+}