Improve ring buffer performance and add tests

Author: keithknott26

example/main.go

@@ -3,80 +3,143 @@ package main
 import (
 	"fmt"
 
-	"github.com/keithknott26/easyringbuffer"
+	"github.com/keithknott26/easyringbuffer/ringbuffer"
 )
 
 type App struct {
-	Info   *easyringbuffer.StringRingBuffer
-	Warn   *easyringbuffer.StringRingBuffer
-	Error  *easyringbuffer.StringRingBuffer
-	Fatal  *easyringbuffer.StringRingBuffer
-	Floats *easyringbuffer.Float64RingBuffer
+	Info   *ringbuffer.RingBuffer[string]
+	Warn   *ringbuffer.RingBuffer[string]
+	Error  *ringbuffer.RingBuffer[string]
+	Fatal  *ringbuffer.RingBuffer[string]
+	Floats *ringbuffer.RingBuffer[float64]
 }
 
 func NewApp() *App {
+	// Initialize ring buffers with a capacity of 128 (must be a power of two)
+	infoBuffer, _ := ringbuffer.NewRingBuffer
+	warnBuffer, _ := ringbuffer.NewRingBuffer
+	errorBuffer, _ := ringbuffer.NewRingBuffer
+	fatalBuffer, _ := ringbuffer.NewRingBuffer
+	floatBuffer, _ := ringbuffer.NewRingBuffer
+
 	return &App{
-		//initialize the ring buffers with a length of 100
-		Info:   easyringbuffer.NewStringRingBuffer(100),
-		Warn:   easyringbuffer.NewStringRingBuffer(100),
-		Error:  easyringbuffer.NewStringRingBuffer(100),
-		Fatal:  easyringbuffer.NewStringRingBuffer(100),
-		Floats: easyringbuffer.NewFloat64RingBuffer(100),
+		Info:   infoBuffer,
+		Warn:   warnBuffer,
+		Error:  errorBuffer,
+		Fatal:  fatalBuffer,
+		Floats: floatBuffer,
 	}
 }
 
 func main() {
-	// simulate INFO, WARN, ERROR, FATAL log messages
-	infoText := "INFO: Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+	// Simulate INFO, WARN, ERROR, FATAL log messages
+	infoText := "INFO: Lorem ipsum dolor sit amet..."
 	warnText := "WARN: Application has bad references"
 	errorText := "ERROR: Line count not found"
 	fatalText := "FATAL: Application failed to compile"
-	pi := 3.145926
+	pi := 3.1415926
 
-	// initialize the string ring buffer
+	// Initialize the app with ring buffers
 	app := NewApp()
 
-	// add the log messages to the string ring buffer
-	app.Info.Add(infoText)
-	app.Warn.Add(warnText)
-	app.Error.Add(errorText)
-	app.Fatal.Add(fatalText)
+	// Add the log messages to the ring buffers
+	app.Info.Enqueue(infoText)
+	app.Warn.Enqueue(warnText)
+	app.Error.Enqueue(errorText)
+	app.Fatal.Enqueue(fatalText)
 
-	// add the floats onto the float64 ring buffer
-	for i := 0; i <= 300; i += 1 {
-		app.Floats.Add(float64(i) + pi)
+	// Add float values to the float64 ring buffer
+	for i := 0; i <= 300; i++ {
+		app.Floats.Enqueue(float64(i) + pi)
 	}
 
-	// print out the last 10 string messages on the buffer
-	info := fmt.Sprintf("Last 10 INFO Messages: %s", app.Info.Last(10))
-	warn := fmt.Sprintf("Last 10 WARN Messages: %s", app.Warn.Last(10))
-	error := fmt.Sprintf("Last 10 ERROR Messages: %s", app.Error.Last(10))
-	fatal := fmt.Sprintf("Last 10 FATAL Messages: %s", app.Fatal.Last(10))
-	fmt.Println(info)
-	fmt.Println(warn)
-	fmt.Println(error)
-	fmt.Println(fatal)
+	// Print out the last 10 INFO messages
+	infoMessages := getLastN(app.Info, 10)
+	fmt.Printf("Last %d INFO Messages: %v\n", len(infoMessages), infoMessages)
+
+	// Similarly for other log levels
+	warnMessages := getLastN(app.Warn, 10)
+	fmt.Printf("Last %d WARN Messages: %v\n", len(warnMessages), warnMessages)
+
+	errorMessages := getLastN(app.Error, 10)
+	fmt.Printf("Last %d ERROR Messages: %v\n", len(errorMessages), errorMessages)
 
-	// print out the last 10 float64 values on the buffer
-	float := fmt.Sprintf("Last 10 Floats: %v", app.Floats.Last(10))
-	fmt.Println(float)
+	fatalMessages := getLastN(app.Fatal, 10)
+	fmt.Printf("Last %d FATAL Messages: %v\n", len(fatalMessages), fatalMessages)
 
-	// print the float64 buffer capacity
-	fmt.Println(app.Floats.BufCapacity())
+	// Print out the last 10 float64 values
+	floatValues := getLastN(app.Floats, 10)
+	fmt.Printf("Last %d Floats: %v\n", len(floatValues), floatValues)
 
-	// print the float64 buffer length
-	fmt.Println(app.Floats.Len())
+	// Print the float64 buffer capacity and size
+	fmt.Printf("Float Buffer Capacity: %d\n", app.Floats.Capacity())
+	fmt.Printf("Float Buffer Size: %d\n", app.Floats.Size())
 
-	// print all the buffer values
-	fmt.Println(app.Floats.Values())
+	// Print all buffer values (may be large)
+	allFloats := getAllValues(app.Floats)
+	fmt.Printf("All Floats: %v\n", allFloats)
 
-	// print all the buffer values between position 1 and 15
-	fmt.Println(app.Floats.Slice(1, 15))
+	// Print buffer values between positions 1 and 15
+	slice1 := getSlice(app.Floats, 1, 15)
+	fmt.Printf("Floats from position 1 to 15: %v\n", slice1)
 
-	// print all the buffer values between position 10 and 25
-	fmt.Println(app.Floats.Position(10, 25))
+	// Print buffer values between positions 10 and 25
+	slice2 := getSlice(app.Floats, 10, 25)
+	fmt.Printf("Floats from position 10 to 25: %v\n", slice2)
 
-	// clear all the buffer values
+	// Clear all buffer values
 	app.Floats.Reset()
+	fmt.Println("Float buffer reset.")
+
+	// Ensure the buffer is empty
+	if app.Floats.IsEmpty() {
+		fmt.Println("Float buffer is now empty.")
+	}
+}
+
+// Helper functions to retrieve values from the ring buffer
+
+// getLastN retrieves the last n items from the ring buffer
+func getLastN[T any](rb *ringbuffer.RingBuffer[T], n int) []T {
+	size := int(rb.Size())
+	if n > size {
+		n = size
+	}
+	result := make([]T, 0, n)
+	for i := size - n; i < size; i++ {
+		item, _ := rb.GetAt(i)
+		result = append(result, item)
+	}
+	return result
+}
+
+// getAllValues retrieves all items from the ring buffer
+func getAllValues[T any](rb *ringbuffer.RingBuffer[T]) []T {
+	size := int(rb.Size())
+	result := make([]T, 0, size)
+	for i := 0; i < size; i++ {
+		item, _ := rb.GetAt(i)
+		result = append(result, item)
+	}
+	return result
+}
 
+// getSlice retrieves items between start and end positions
+func getSlice[T any](rb *ringbuffer.RingBuffer[T], start, end int) []T {
+	size := int(rb.Size())
+	if start < 0 {
+		start = 0
+	}
+	if end > size {
+		end = size
+	}
+	if start >= end {
+		return []T{}
+	}
+	result := make([]T, 0, end-start)
+	for i := start; i < end; i++ {
+		item, _ := rb.GetAt(i)
+		result = append(result, item)
+	}
+	return result
 }

go.mod

@@ -0,0 +1,3 @@
+module github.com/keithknott26/easyringbuffer
+
+go 1.23.1

go.sum

@@ -0,0 +1,2 @@
+github.com/keithknott26/easyringbuffer v0.0.0-20200116011729-75d310231b7a h1:C891BKvHNI9raHlCJtjO0+imHnqVxB2NlMaEJ/RF5GM=
+github.com/keithknott26/easyringbuffer v0.0.0-20200116011729-75d310231b7a/go.mod h1:h01TcxJRGkXdpUt0B5xNVaWjMZQjcivnY6tG8yBgh68=