network/bitvector: Multibit set/unset + string rep

network/bitvector/bitvector.go

@@ -22,15 +22,20 @@ import (
 
 var errInvalidLength = errors.New("invalid length")
 
+// BitVector is a convenience object for manipulating and representing bit vectors
 type BitVector struct {
 	len int
 	b   []byte
 }
 
+// New creates a new bit vector with the given length
 func New(l int) (bv *BitVector, err error) {
 	return NewFromBytes(make([]byte, l/8+1), l)
 }
 
+// NewFromBytes creates a bit vector from the passed byte slice.
+//
+// Leftmost bit in byte slice becomes leftmost bit in bit vector
 func NewFromBytes(b []byte, l int) (bv *BitVector, err error) {
 	if l <= 0 {
 		return nil, errInvalidLength
@@ -44,11 +49,13 @@ func NewFromBytes(b []byte, l int) (bv *BitVector, err error) {
 	}, nil
 }
 
+// Get gets the corresponding bit, counted from left to right
 func (bv *BitVector) Get(i int) bool {
 	bi := i / 8
 	return bv.b[bi]&(0x1<<uint(i%8)) != 0
 }
 
+// Set sets the corresponding bit, counted from left to right, to the corresponding state of v
 func (bv *BitVector) Set(i int, v bool) {
 	bi := i / 8
 	cv := bv.Get(i)
@@ -57,6 +64,38 @@ func (bv *BitVector) Set(i int, v bool) {
 	}
 }
 
+// SetBytes modifies all bits in the bitvector that are set in the argument
+//
+// If v is true, it sets all bits in the bitvector that are set in the argument
+// If v is false, it unsets all bites in the bitvector that are set in the argument
+//
+// The argument must be the same as the bitvector length
+func (bv *BitVector) SetBytes(bs []byte, v bool) error {
+	if len(bs) != bv.len {
+		return errors.New("invalid length")
+	}
+	for i := 0; i < bv.len*8; i++ {
+		bi := i / 8
+		if bs[bi]&(0x01<<uint(i%8)) > 0 {
+			bv.Set(i, v)
+		}
+	}
+	return nil
+}
+
+// String implements Stringer interface
+func (bv *BitVector) String() (s string) {
+	for i := 0; i < bv.len*8; i++ {
+		if bv.Get(i) {
+			s += "1"
+		} else {
+			s += "0"
+		}
+	}
+	return s
+}
+
+// Bytes retrieves the underlying bytes of the bitvector
 func (bv *BitVector) Bytes() []byte {
 	return bv.b
 }

network/bitvector/bitvector_test.go

@@ -18,6 +18,7 @@ package bitvector
 
 import "testing"
 
+// TestBitvectorNew checks that enforcements of argument length works in the constructors
 func TestBitvectorNew(t *testing.T) {
 	_, err := New(0)
 	if err != errInvalidLength {
@@ -40,6 +41,7 @@ func TestBitvectorNew(t *testing.T) {
 	}
 }
 
+// TestBitvectorGetSet tests correctness of individual Set and Get commands
 func TestBitvectorGetSet(t *testing.T) {
 	for _, length := range []int{
 		1,
@@ -93,6 +95,7 @@ func TestBitvectorGetSet(t *testing.T) {
 	}
 }
 
+// TestBitvectorNewFromBytesGet tests that bit vector is initialized correctly from underlying byte slice
 func TestBitvectorNewFromBytesGet(t *testing.T) {
 	bv, err := NewFromBytes([]byte{8}, 8)
 	if err != nil {
@@ -102,3 +105,36 @@ func TestBitvectorNewFromBytesGet(t *testing.T) {
 		t.Fatalf("element 3 is not set to true: state %08b", bv.b[0])
 	}
 }
+
+// TestBitVectorString tests that string representation of bit vector is correct
+func TestBitVectorString(t *testing.T) {
+	b := []byte{0xa5, 0x81}
+	expect := "1010010110000001"
+	bv, err := NewFromBytes(b, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if bv.String() != expect {
+		t.Fatalf("bitvector string fail: got %s, expect %s", bv.String(), expect)
+	}
+}
+
+// TestBitVectorSetUnsetBytes tests that setting and unsetting by byte slice modifies the bit vector correctly
+func TestBitVectorSetBytes(t *testing.T) {
+	b := []byte{0xff, 0xff}
+	cb := []byte{0xa5, 0x81}
+	expectUnset := "0101101001111110"
+	expectReset := "1111111111111111"
+	bv, err := NewFromBytes(b, 2)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bv.SetBytes(cb, false)
+	if bv.String() != expectUnset {
+		t.Fatalf("bitvector unset bytes fail: got %s, expect %s", bv.String(), expectUnset)
+	}
+	bv.SetBytes(cb, true)
+	if bv.String() != expectReset {
+		t.Fatalf("bitvector reset bytes fail: got %s, expect %s", bv.String(), expectReset)
+	}
+}