Merge branch 'master' of github.com:Workiva/go-datastructures into AddDependabot

Author: bender-wk

.github/CODEOWNERS

@@ -0,0 +1 @@
+@Workiva/skreams

.github/workflows/tests.yaml

@@ -0,0 +1,64 @@
+name: "Tests"
+
+on:
+  pull_request:
+  push:
+    branches:
+      - 'master'
+    tags:
+      - '*'
+
+permissions:
+  pull-requests: write
+  contents: write
+  id-token: write
+
+jobs:
+  Tests:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go: [ '1.15', 'stable' ]
+    name: Tests on Go ${{ matrix.go }}
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v4
+        with:
+          path: go/src/github.com/Workiva/go-datastructures
+
+      - name: Setup Go
+        uses: actions/[email protected]
+        with:
+          go-version: ${{ matrix.go }}
+
+      # go install does not work because it needs credentials
+      - name: install go2xunit
+        run: |
+          git clone https://github.com/tebeka/go2xunit.git
+          cd go2xunit
+          git checkout v1.4.10
+          go install 
+          cd ..
+
+      - name: Run Tests
+        timeout-minutes: 10
+        run: |
+          cd go/src/github.com/Workiva/go-datastructures
+          go test ./... | tee ${{github.workspace}}/go-test.txt 
+
+      - name: XML output
+        run: |
+          mkdir artifacts
+          go2xunit -input ./go-test.txt -output ./artifacts/tests_go_version-${{ matrix.go }}.xml
+
+      - name: Upload Test Results
+        uses: actions/upload-artifact@v4
+        with:
+          name: go-datastructures test go ${{ matrix.go }}
+          path: ./artifacts/tests_go_version-${{ matrix.go }}.xml
+          retention-days: 7
+
+      - uses: anchore/sbom-action@v0
+        with:
+          path: ./  
+          format: cyclonedx-json

.travis.yml

@@ -1,23 +1,16 @@
-FROM drydock-prod.workiva.net/workiva/smithy-runner-golang:121185 as build
+FROM golang:1.16-alpine3.13 AS build-go
 
 ARG GIT_SSH_KEY
 ARG KNOWN_HOSTS_CONTENT
 WORKDIR /go/src/github.com/Workiva/go-datastructures/
 ADD . /go/src/github.com/Workiva/go-datastructures/
 
-RUN mkdir /root/.ssh && \
-    echo "$KNOWN_HOSTS_CONTENT" > "/root/.ssh/known_hosts" && \
-    chmod 700 /root/.ssh/ && \
-    umask 0077 && echo "$GIT_SSH_KEY" >/root/.ssh/id_rsa && \
-    eval "$(ssh-agent -s)" && ssh-add /root/.ssh/id_rsa
-
 ARG GOPATH=/go/
 ENV PATH $GOPATH/bin:$PATH
-RUN git config --global [email protected]:.insteadOf https://github.com
 RUN echo "Starting the script section" && \
-		glide install && \
-		echo "script section completed"
+    go mod vendor && \
+    echo "script section completed"
 
-ARG BUILD_ARTIFACTS_DEPENDENCIES=/go/src/github.com/Workiva/go-datastructures/glide.lock
+ARG BUILD_ARTIFACTS_DEPENDENCIES=/go/src/github.com/Workiva/go-datastructures/go.mod
 
 FROM scratch

Dockerfile

@@ -1,4 +1,3 @@
-
 go-datastructures
 =================
 
@@ -150,7 +149,7 @@ interface and the most expensive operation in CPU profiling is the interface
 method which in turn calls into runtime.assertI2T.  We need generics.
 
 #### Immutable B Tree
-A btree based on two principals, immutablability and concurrency. 
+A btree based on two principles, immutability and concurrency. 
 Somewhat slow for single value lookups and puts, it is very fast for bulk operations.
 A persister can be injected to make this index persistent.
 
@@ -229,6 +228,6 @@ Requirements to commit here:
 
 
 ### Maintainers
-
- - Dustin Hiatt <[[email protected]](mailto:[email protected])>
  - Alexander Campbell <[[email protected]](mailto:[email protected])>
+ - Dustin Hiatt <[[email protected]](mailto:[email protected])>
+ - Ryan Jackson <[[email protected]](mailto:[email protected])>

README.md

@@ -20,6 +20,8 @@ efficient way.  This is *NOT* a threadsafe package.
 */
 package bitarray
 
+import "math/bits"
+
 // bitArray is a struct that maintains state of a bit array.
 type bitArray struct {
 	blocks  []block
@@ -116,7 +118,74 @@ func (ba *bitArray) GetBit(k uint64) (bool, error) {
 	return result, nil
 }
 
-//ClearBit will unset a bit at the given index if it is set.
+// GetSetBits gets the position of bits set in the array.
+func (ba *bitArray) GetSetBits(from uint64, buffer []uint64) []uint64 {
+	fromBlockIndex, fromOffset := getIndexAndRemainder(from)
+	return getSetBitsInBlocks(
+		fromBlockIndex,
+		fromOffset,
+		ba.blocks[fromBlockIndex:],
+		nil,
+		buffer,
+	)
+}
+
+// getSetBitsInBlocks fills a buffer with positions of set bits in the provided blocks. Optionally, indices may be
+// provided for sparse/non-consecutive blocks.
+func getSetBitsInBlocks(
+	fromBlockIndex, fromOffset uint64,
+	blocks []block,
+	indices []uint64,
+	buffer []uint64,
+) []uint64 {
+	bufferCapacity := cap(buffer)
+	if bufferCapacity == 0 {
+		return buffer[:0]
+	}
+
+	results := buffer[:bufferCapacity]
+	resultSize := 0
+
+	for i, block := range blocks {
+		blockIndex := fromBlockIndex + uint64(i)
+		if indices != nil {
+			blockIndex = indices[i]
+		}
+
+		isFirstBlock := blockIndex == fromBlockIndex
+		if isFirstBlock {
+			block >>= fromOffset
+		}
+
+		for block != 0 {
+			trailing := bits.TrailingZeros64(uint64(block))
+
+			if isFirstBlock {
+				results[resultSize] = uint64(trailing) + (blockIndex << 6) + fromOffset
+			} else {
+				results[resultSize] = uint64(trailing) + (blockIndex << 6)
+			}
+			resultSize++
+
+			if resultSize == cap(results) {
+				return results[:resultSize]
+			}
+
+			// Clear the bit we just added to the result, which is the last bit set in the block. Ex.:
+			//  block                   01001100
+			//  ^block                  10110011
+			//  (^block) + 1            10110100
+			//  block & (^block) + 1    00000100
+			//  block ^ mask            01001000
+			mask := block & ((^block) + 1)
+			block = block ^ mask
+		}
+	}
+
+	return results[:resultSize]
+}
+
+// ClearBit will unset a bit at the given index if it is set.
 func (ba *bitArray) ClearBit(k uint64) error {
 	if k >= ba.Capacity() {
 		return OutOfRangeError(k)
@@ -137,6 +206,15 @@ func (ba *bitArray) ClearBit(k uint64) error {
 	return nil
 }
 
+// Count returns the number of set bits in this array.
+func (ba *bitArray) Count() int {
+	count := 0
+	for _, block := range ba.blocks {
+		count += bits.OnesCount64(uint64(block))
+	}
+	return count
+}
+
 // Or will bitwise or two bit arrays and return a new bit array
 // representing the result.
 func (ba *bitArray) Or(other BitArray) BitArray {

bitarray/bitarray.go

@@ -20,6 +20,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestBitOperations(t *testing.T) {
@@ -142,6 +143,28 @@ func TestIsEmpty(t *testing.T) {
 	assert.False(t, ba.IsEmpty())
 }
 
+func TestCount(t *testing.T) {
+	ba := newBitArray(500)
+	assert.Equal(t, 0, ba.Count())
+
+	require.NoError(t, ba.SetBit(0))
+	assert.Equal(t, 1, ba.Count())
+
+	require.NoError(t, ba.SetBit(40))
+	require.NoError(t, ba.SetBit(64))
+	require.NoError(t, ba.SetBit(100))
+	require.NoError(t, ba.SetBit(200))
+	require.NoError(t, ba.SetBit(469))
+	require.NoError(t, ba.SetBit(500))
+	assert.Equal(t, 7, ba.Count())
+
+	require.NoError(t, ba.ClearBit(200))
+	assert.Equal(t, 6, ba.Count())
+
+	ba.Reset()
+	assert.Equal(t, 0, ba.Count())
+}
+
 func TestClear(t *testing.T) {
 	ba := newBitArray(10)
 
@@ -195,6 +218,53 @@ func BenchmarkGetBit(b *testing.B) {
 	}
 }
 
+func TestGetSetBits(t *testing.T) {
+	ba := newBitArray(1000)
+	buf := make([]uint64, 0, 5)
+
+	require.NoError(t, ba.SetBit(1))
+	require.NoError(t, ba.SetBit(4))
+	require.NoError(t, ba.SetBit(8))
+	require.NoError(t, ba.SetBit(63))
+	require.NoError(t, ba.SetBit(64))
+	require.NoError(t, ba.SetBit(200))
+	require.NoError(t, ba.SetBit(1000))
+
+	assert.Equal(t, []uint64(nil), ba.GetSetBits(0, nil))
+	assert.Equal(t, []uint64{}, ba.GetSetBits(0, []uint64{}))
+
+	assert.Equal(t, []uint64{1, 4, 8, 63, 64}, ba.GetSetBits(0, buf))
+	assert.Equal(t, []uint64{63, 64, 200, 1000}, ba.GetSetBits(10, buf))
+	assert.Equal(t, []uint64{63, 64, 200, 1000}, ba.GetSetBits(63, buf))
+	assert.Equal(t, []uint64{200, 1000}, ba.GetSetBits(128, buf))
+
+	require.NoError(t, ba.ClearBit(4))
+	require.NoError(t, ba.ClearBit(64))
+	assert.Equal(t, []uint64{1, 8, 63, 200, 1000}, ba.GetSetBits(0, buf))
+	assert.Empty(t, ba.GetSetBits(1001, buf))
+
+	ba.Reset()
+	assert.Empty(t, ba.GetSetBits(0, buf))
+}
+
+func BenchmarkGetSetBits(b *testing.B) {
+	numItems := uint64(168000)
+
+	ba := newBitArray(numItems)
+	for i := uint64(0); i < numItems; i++ {
+		if i%13 == 0 || i%5 == 0 {
+			require.NoError(b, ba.SetBit(i))
+		}
+	}
+
+	buf := make([]uint64, 0, ba.Capacity())
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ba.GetSetBits(0, buf)
+	}
+}
+
 func TestEquality(t *testing.T) {
 	ba := newBitArray(s + 1)
 	other := newBitArray(s + 1)

bitarray/bitarray_test.go

@@ -36,6 +36,10 @@ type BitArray interface {
 	// function returns an error if the position is out
 	// of range.  A sparse bit array never returns an error.
 	GetBit(k uint64) (bool, error)
+	// GetSetBits gets the position of bits set in the array. Will
+	// return as many set bits as can fit in the provided buffer
+	// starting from the specified position in the array.
+	GetSetBits(from uint64, buffer []uint64) []uint64
 	// ClearBit clears the bit at the given position.  This
 	// function returns an error if the position is out
 	// of range.  A sparse bit array never returns an error.
@@ -55,6 +59,8 @@ type BitArray interface {
 	// in the case of a dense bit array or the highest possible
 	// seen capacity of the sparse array.
 	Capacity() uint64
+	// Count returns the number of set bits in this array.
+	Count() int
 	// Or will bitwise or the two bitarrays and return a new bitarray
 	// representing the result.
 	Or(other BitArray) BitArray