Release V1.0.0-rc2 (#20)

- Finshes disk restore feature
- Improved and expanded test suite
- Performance patches
- Improved error handling
- Patches security alerts
- Reduces data need for lazy disk deleter

Author: JustinTimperio

README.md

@@ -6,8 +6,12 @@
 	GPQ is an extremely fast and flexible priority queue, capable of millions transactions a second. GPQ supports a complex "Double Priority Queue" which allows for priorities to be distributed across N buckets, with each bucket holding a second priority queue which allows for internal escalation and timeouts of items based on parameters the user can specify during submission combined with how frequently you ask GPQ to prioritize the queue.
 </h4>
 
+## Notice
+While GPQ is largely stable, bugs are more than likely present at this early stage, and you should carefully consider if your application can tolerate any down time or lost messages that may result from adopting this project into a production workflow. If you run into any bugs please submit an issue or better a PR! Check out the guide to contributing below.
+
 
 ## Table of Contents
+- [Notice](#notice)
 - [Table of Contents](#table-of-contents)
 - [Background](#background)
 	- [Should I Use GPQ?](#should-i-use-gpq)
@@ -44,7 +48,7 @@ GPQ is a concurrency safe, embeddable priority queue that can be used in a varie
 
 
 ## Benchmarks
-Due to the fact that most operations are done in constant time `O(1)` or logarithmic time `O(log n)`, with the exception of the prioritize function which happens in linear time `O(n)`, all GPQ operations are extremely fast. A single GPQ can handle a few million transactions a second and can be tuned depending on your work load. I have included some basic benchmarks using C++, Rust, Zig, and Go to measure GPQ's performance against the standard implementations of other languages that can be found here at: [pq-bench](https://github.com/JustinTimperio/pq-bench) 
+Due to the fact that most operations are done in constant time `O(1)` or logarithmic time `O(log n)`, with the exception of the prioritize function which happens in linear time `O(n)`, all GPQ operations are extremely fast. A single GPQ can handle a few million transactions a second and can be tuned depending on your work load. I have included some basic benchmarks using C++, Rust, Zig, Python, and Go to measure GPQ's performance against the standard implementations of other languages that can be found here at: [pq-bench](https://github.com/JustinTimperio/pq-bench) 
 
 |                                                                                                             |                                                                                                          |
 |-------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
@@ -68,8 +72,8 @@ For this you will need Go >= `1.22` and gpq itself uses [hashmap](https://github
   - `ActiveBuckets() uint` - Returns the number of active buckets.
   - `Enqueue(item schema.Item[d]) error` - Enqueues an item into the queue.
   - `EnqueueBatch(items []schema.Item[d]) error` - Enqueues a batch of items into the queue.
-  - `Dequeue() (schema.Item[d], error)` - Dequeues an item from the queue.
-  - `DequeueBatch(batchSize uint) ([]schema.Item[d], error)` - Dequeues a batch of items from the queue.
+  - `Dequeue() (*schema.Item[d], error)` - Dequeues an item from the queue.
+  - `DequeueBatch(batchSize uint) ([]*schema.Item[d], error)` - Dequeues a batch of items from the queue.
   - `Prioritize() error` - Prioritizes the queue based on the values in each item.
   - `Close()` - Closes the queue and saves the queue to disk.
 
@@ -86,7 +90,7 @@ import (
 )
 
 func main() {
-	defaultMessageOptions := schema.EnQueueOptions{
+	defaultMessageOptions := schema.EnqueueOptions{
 		ShouldEscalate: true,
 		EscalationRate: time.Duration(time.Second),
 		CanTimeout:     true,

disk/disk.go

@@ -86,7 +86,7 @@ func (d *Disk[T]) ProcessBatch(batch []*schema.Item[T]) error {
 	return nil
 }
 
-func (d *Disk[T]) DeleteBatch(batch []*schema.Item[T]) error {
+func (d *Disk[T]) DeleteBatch(batch []*schema.DeleteMessage) error {
 	txn := d.diskCache.NewTransaction(true)
 	defer txn.Discard()
 

go.mod

@@ -1,30 +1,25 @@
 module github.com/JustinTimperio/gpq
 
-go 1.22.0
+go 1.22
 
 require (
 	github.com/cornelk/hashmap v1.0.8
-	github.com/dgraph-io/badger/v4 v4.2.0
+	github.com/dgraph-io/badger/v4 v4.5.0
 	github.com/google/uuid v1.6.0
 	github.com/tidwall/btree v1.7.0
 )
 
 require (
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/dgraph-io/ristretto v0.1.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/dgraph-io/ristretto/v2 v2.0.1 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/glog v1.0.0 // indirect
-	github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/flatbuffers v23.5.26+incompatible // indirect
-	github.com/google/go-cmp v0.5.9 // indirect
-	github.com/klauspost/compress v1.16.7 // indirect
+	github.com/golang/groupcache v0.0.0-20241129210726-2c02b8208cf8 // indirect
+	github.com/google/flatbuffers v24.3.25+incompatible // indirect
+	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
-	github.com/stretchr/testify v1.9.0 // indirect
-	go.opencensus.io v0.22.5 // indirect
-	golang.org/x/net v0.22.0 // indirect
-	golang.org/x/sys v0.18.0 // indirect
-	google.golang.org/protobuf v1.31.0 // indirect
+	go.opencensus.io v0.24.0 // indirect
+	golang.org/x/net v0.33.0 // indirect
+	golang.org/x/sys v0.28.0 // indirect
+	google.golang.org/protobuf v1.36.0 // indirect
 )