Support 1.23 iterator in a backward-compatible way

Author: trend-amikai-chuang

iter.go

@@ -0,0 +1,23 @@
+package roaring
+
+func Values(b *Bitmap) func(func(uint32) bool) {
+	it := b.Iterator()
+	return func(yield func(uint32) bool) {
+		for it.HasNext() {
+			if !yield(it.Next()) {
+				return
+			}
+		}
+	}
+}
+
+func Backward(b *Bitmap) func(func(uint32) bool) {
+	it := b.ReverseIterator()
+	return func(yield func(uint32) bool) {
+		for it.HasNext() {
+			if !yield(it.Next()) {
+				return
+			}
+		}
+	}
+}

iter123_test.go

@@ -0,0 +1,111 @@
+//go:build go1.23
+// +build go1.23
+
+package roaring
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBackwardCount123(t *testing.T) {
+	array := []int{2, 63, 64, 65, 4095, 4096, 4097, 4159, 4160, 4161, 5000, 20000, 66666}
+	for _, testSize := range array {
+		b := New()
+		for i := uint32(0); i < uint32(testSize); i++ {
+			b.Add(i)
+		}
+
+		count := 0
+		for range Values(b) {
+			count++
+		}
+
+		assert.Equal(t, testSize, count)
+	}
+}
+
+func TestBackward123(t *testing.T) {
+	t.Run("#1", func(t *testing.T) {
+		values := []uint32{0, 2, 15, 16, 31, 32, 33, 9999, MaxUint16, MaxUint32}
+		b := New()
+		for n := 0; n < len(values); n++ {
+			b.Add(values[n])
+		}
+		n := len(values) - 1
+		for val := range Backward(b) {
+			assert.EqualValues(t, val, values[n])
+			n--
+		}
+	})
+
+	t.Run("#2", func(t *testing.T) {
+		b := New()
+
+		count := 0
+		for range Backward(b) {
+			count++
+		}
+
+		assert.Equal(t, 0, count)
+	})
+
+	t.Run("#3", func(t *testing.T) {
+		b := New()
+		b.AddInt(0)
+
+		// only one value zero
+		for val := range Backward(b) {
+			assert.EqualValues(t, 0, val)
+		}
+	})
+
+	t.Run("#4", func(t *testing.T) {
+		b := New()
+		b.AddInt(9999)
+
+		// only one value 9999
+		for val := range Backward(b) {
+			assert.EqualValues(t, 9999, val)
+		}
+	})
+
+	t.Run("#5", func(t *testing.T) {
+		b := New()
+		b.AddInt(MaxUint16)
+
+		// only one value MaxUint16
+		for val := range Backward(b) {
+			assert.EqualValues(t, MaxUint16, val)
+		}
+	})
+
+	t.Run("#6", func(t *testing.T) {
+		b := New()
+		b.AddInt(MaxUint32)
+
+		// only one value MaxUint32
+		for val := range Backward(b) {
+			assert.EqualValues(t, MaxUint32, val)
+		}
+	})
+}
+
+func TestValues123(t *testing.T) {
+	b := New()
+
+	testSize := 5000
+	for i := 0; i < testSize; i++ {
+		b.AddInt(i)
+	}
+
+	n := 0
+	for val := range Values(b) {
+		assert.Equal(t, uint32(n), val)
+		n++
+
+	}
+
+	assert.Equal(t, testSize, n)
+}

iter_test.go

@@ -0,0 +1,133 @@
+package roaring
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBackwardCount(t *testing.T) {
+	array := []int{2, 63, 64, 65, 4095, 4096, 4097, 4159, 4160, 4161, 5000, 20000, 66666}
+	for _, testSize := range array {
+		b := New()
+		for i := uint32(0); i < uint32(testSize); i++ {
+			b.Add(i)
+		}
+		it := Values(b)
+
+		count := 0
+		it(func(_ uint32) bool {
+			count++
+			return true
+		})
+
+		assert.Equal(t, testSize, count)
+	}
+}
+
+func TestBackward(t *testing.T) {
+	t.Run("#1", func(t *testing.T) {
+		values := []uint32{0, 2, 15, 16, 31, 32, 33, 9999, MaxUint16, MaxUint32}
+		b := New()
+		for n := 0; n < len(values); n++ {
+			b.Add(values[n])
+		}
+		it := Backward(b)
+		n := len(values) - 1
+
+		it(func(val uint32) bool {
+			assert.EqualValues(t, val, values[n])
+			n--
+			return true
+		})
+
+		it = Backward(b)
+		n = len(values) - 1
+		it(func(val uint32) bool {
+			assert.EqualValues(t, val, values[n])
+			assert.True(t, n >= 0)
+			n--
+			return true
+		})
+	})
+
+	t.Run("#2", func(t *testing.T) {
+		b := New()
+		it := Backward(b)
+
+		count := 0
+		it(func(_ uint32) bool {
+			count++
+			return true
+		})
+
+		assert.Equal(t, 0, count)
+	})
+
+	t.Run("#3", func(t *testing.T) {
+		b := New()
+		b.AddInt(0)
+		it := Backward(b)
+
+		// only one value zero
+		it(func(val uint32) bool {
+			assert.EqualValues(t, 0, val)
+			return true
+		})
+	})
+
+	t.Run("#4", func(t *testing.T) {
+		b := New()
+		b.AddInt(9999)
+		it := Backward(b)
+
+		// only one value 9999
+		it(func(val uint32) bool {
+			assert.EqualValues(t, 9999, val)
+			return true
+		})
+	})
+
+	t.Run("#5", func(t *testing.T) {
+		b := New()
+		b.AddInt(MaxUint16)
+		it := Values(b)
+
+		// only one value MaxUint16
+		it(func(val uint32) bool {
+			assert.EqualValues(t, MaxUint16, val)
+			return true
+		})
+	})
+
+	t.Run("#6", func(t *testing.T) {
+		b := New()
+		b.AddInt(MaxUint32)
+		it := Values(b)
+
+		// only one value MaxUint16
+		it(func(val uint32) bool {
+			assert.EqualValues(t, MaxUint32, val)
+			return true
+		})
+	})
+}
+
+func TestValues(t *testing.T) {
+	b := New()
+
+	testSize := 5000
+	for i := 0; i < testSize; i++ {
+		b.AddInt(i)
+	}
+
+	it := Values(b)
+	n := 0
+	it(func(val uint32) bool {
+		assert.Equal(t, uint32(n), val)
+		n++
+		return true
+	})
+
+	assert.Equal(t, testSize, n)
+}