Add buffer.Ring(Growing)Options to initialize ring buffers

Author: nojnhuh

buffer/ring_growing.go

@@ -16,6 +16,14 @@ limitations under the License.
 
 package buffer
 
+// RingGrowingOptions sets parameters for [RingGrowing] and
+// [TypedRingGrowing].
+type RingGrowingOptions struct {
+	// InitialSize is the number of pre-allocated elements in the
+	// initial underlying storage buffer.
+	InitialSize int
+}
+
 // RingGrowing is a growing ring buffer.
 // Not thread safe.
 //
@@ -26,7 +34,7 @@ type RingGrowing = TypedRingGrowing[any]
 //
 // Deprecated: Use NewTypedRingGrowing[any] instead.
 func NewRingGrowing(initialSize int) *RingGrowing {
-	return NewTypedRingGrowing[any](initialSize)
+	return NewTypedRingGrowing[any](RingGrowingOptions{InitialSize: initialSize})
 }
 
 // TypedRingGrowing is a growing ring buffer.
@@ -39,10 +47,10 @@ type TypedRingGrowing[T any] struct {
 }
 
 // NewTypedRingGrowing constructs a new TypedRingGrowing instance with provided parameters.
-func NewTypedRingGrowing[T any](initialSize int) *TypedRingGrowing[T] {
+func NewTypedRingGrowing[T any](opts RingGrowingOptions) *TypedRingGrowing[T] {
 	return &TypedRingGrowing[T]{
-		data: make([]T, initialSize),
-		n:    initialSize,
+		data: make([]T, opts.InitialSize),
+		n:    opts.InitialSize,
 	}
 }
 
@@ -95,6 +103,16 @@ func (r *TypedRingGrowing[T]) Cap() int {
 	return r.n
 }
 
+// RingGrowingOptions sets parameters for [Ring].
+type RingOptions struct {
+	// InitialSize is the number of pre-allocated elements in the
+	// initial underlying storage buffer.
+	InitialSize int
+	// NormalSize is the number of elements to allocate for new storage
+	// buffers once the Ring is consumed.
+	NormalSize int
+}
+
 // Ring is a dynamically-sized ring buffer which can grow and shrink as-needed.
 // Not thread safe.
 type Ring[T any] struct {
@@ -103,10 +121,10 @@ type Ring[T any] struct {
 }
 
 // NewRing constructs a new Ring instance with provided parameters.
-func NewRing[T any](initialSize int) *Ring[T] {
+func NewRing[T any](opts RingOptions) *Ring[T] {
 	return &Ring[T]{
-		growing:    *NewTypedRingGrowing[T](initialSize),
-		normalSize: initialSize,
+		growing:    *NewTypedRingGrowing[T](RingGrowingOptions{InitialSize: opts.InitialSize}),
+		normalSize: opts.NormalSize,
 	}
 }
 

buffer/ring_growing_test.go

@@ -23,7 +23,7 @@ import (
 func TestGrowthGrowing(t *testing.T) {
 	t.Parallel()
 	initialSize := 1
-	g := NewTypedRingGrowing[int](initialSize)
+	g := NewTypedRingGrowing[int](RingGrowingOptions{InitialSize: initialSize})
 
 	if expected, actual := 0, g.Len(); expected != actual {
 		t.Fatalf("expected Len to be %d, got %d", expected, actual)
@@ -72,7 +72,8 @@ func TestGrowthGrowing(t *testing.T) {
 func TestGrowth(t *testing.T) {
 	t.Parallel()
 	initialSize := 1
-	g := NewRing[int](initialSize)
+	normalSize := 2
+	g := NewRing[int](RingOptions{InitialSize: initialSize, NormalSize: normalSize})
 
 	if expected, actual := 0, g.Len(); expected != actual {
 		t.Fatalf("expected Len to be %d, got %d", expected, actual)
@@ -113,14 +114,14 @@ func TestGrowth(t *testing.T) {
 	if expected, actual := 0, g.Len(); expected != actual {
 		t.Fatalf("expected Len to be %d, got %d", expected, actual)
 	}
-	if expected, actual := initialSize, g.Cap(); expected != actual {
+	if expected, actual := normalSize, g.Cap(); expected != actual {
 		t.Fatalf("expected Cap to be %d, got %d", expected, actual)
 	}
 }
 
 func TestEmpty(t *testing.T) {
 	t.Parallel()
-	g := NewTypedRingGrowing[struct{}](1)
+	g := NewTypedRingGrowing[struct{}](RingGrowingOptions{InitialSize: 1})
 	_, ok := g.ReadOne()
 	if ok != false {
 		t.Fatal("expected false")