feat: Add Incr and Decr convenience methods for numeric cache operations.

Author: mysamimi

cache.go

@@ -437,6 +437,18 @@ func (c *NumericCache[N]) ModifyNumeric(k string, operand N, isIncrement bool) (
 	return newVal, nil
 }
 
+// Incr increments a numeric item in the cache by the specified operand.
+// This is a convenience method that calls ModifyNumeric with isIncrement=true.
+func (c *NumericCache[N]) Incr(k string, operand N) (N, error) {
+	return c.ModifyNumeric(k, operand, true)
+}
+
+// Decr decrements a numeric item in the cache by the specified operand.
+// This is a convenience method that calls ModifyNumeric with isIncrement=false.
+func (c *NumericCache[N]) Decr(k string, operand N) (N, error) {
+	return c.ModifyNumeric(k, operand, false)
+}
+
 // Delete an item from the cache. Does nothing if the key is not in the cache.
 func (c *cache[V]) Delete(k string) {
 	c.mu.Lock()

cache_test.go

@@ -423,6 +423,67 @@ func TestModifyNumericTypeMismatch(t *testing.T) {
 	t.Log("Skipping direct type mismatch test for ModifyNumeric on NumericCache[N] as it implies cache stores N.")
 }
 
+func TestIncrDecr(t *testing.T) {
+	nc := newNumericTestCache[int](t, DefaultExpiration, 0)
+	nc.Set("val", 10, DefaultExpiration)
+
+	// Test Incr
+	newVal, err := nc.Incr("val", 5)
+	if err != nil {
+		t.Fatalf("Incr failed: %v", err)
+	}
+	if newVal != 15 {
+		t.Errorf("Expected 15 after Incr, got %d", newVal)
+	}
+
+	// Test Decr
+	newVal, err = nc.Decr("val", 3)
+	if err != nil {
+		t.Fatalf("Decr failed: %v", err)
+	}
+	if newVal != 12 {
+		t.Errorf("Expected 12 after Decr, got %d", newVal)
+	}
+}
+
+func TestIncrOverflow(t *testing.T) {
+	nc := newNumericTestCache[int8](t, DefaultExpiration, 0)
+	nc.Set("int8", int8(127), DefaultExpiration)
+
+	newVal, err := nc.Incr("int8", 1)
+	if err != nil {
+		t.Fatalf("Incr failed: %v", err)
+	}
+	if newVal != -128 {
+		t.Errorf("Expected -128 after overflow, got %d", newVal)
+	}
+}
+
+func TestDecrUnderflow(t *testing.T) {
+	nc := newNumericTestCache[uint8](t, DefaultExpiration, 0)
+	nc.Set("uint8", uint8(0), DefaultExpiration)
+
+	newVal, err := nc.Decr("uint8", 1)
+	if err != nil {
+		t.Fatalf("Decr failed: %v", err)
+	}
+	if newVal != 255 {
+		t.Errorf("Expected 255 after underflow, got %d", newVal)
+	}
+}
+
+func TestIncrWithoutSet(t *testing.T) {
+	nc := newNumericTestCache[int](t, DefaultExpiration, 0)
+
+	newVal, err := nc.Incr("newval", 5)
+	if err != nil {
+		t.Fatalf("Incr failed: %v", err)
+	}
+	if newVal != 5 {
+		t.Errorf("Expected 5 after Incr on empty key, got %d", newVal)
+	}
+}
+
 // --- End of ModifyNumeric Tests ---
 
 func TestAdd(t *testing.T) {

sharded.go

@@ -236,6 +236,18 @@ func (sc *ShardedNumericCache[N]) ModifyNumeric(k string, operand N, isIncrement
 	return nc.ModifyNumeric(k, operand, isIncrement)
 }
 
+// Incr increments a numeric item in the cache by the specified operand.
+// This is a convenience method that calls ModifyNumeric with isIncrement=true.
+func (sc *ShardedNumericCache[N]) Incr(k string, operand N) (N, error) {
+	return sc.ModifyNumeric(k, operand, true)
+}
+
+// Decr decrements a numeric item in the cache by the specified operand.
+// This is a convenience method that calls ModifyNumeric with isIncrement=false.
+func (sc *ShardedNumericCache[N]) Decr(k string, operand N) (N, error) {
+	return sc.ModifyNumeric(k, operand, false)
+}
+
 // Helper function to create a new ShardedNumericCache
 func NewShardedNumeric[N Number](shards int, defaultExpiration, cleanupInterval time.Duration) *ShardedNumericCache[N] {
 	// Create the underlying shardedCache

sharded_test.go

@@ -128,6 +128,67 @@ func TestShardedModifyNumeric(t *testing.T) {
 	}
 }
 
+func TestShardedIncrDecr(t *testing.T) {
+	snc := NewShardedNumeric[int](5, DefaultExpiration, 0)
+	snc.Set("val", 10, DefaultExpiration)
+
+	// Test Incr
+	newVal, err := snc.Incr("val", 5)
+	if err != nil {
+		t.Fatalf("Incr failed: %v", err)
+	}
+	if newVal != 15 {
+		t.Errorf("Expected 15 after Incr, got %d", newVal)
+	}
+
+	// Test Decr
+	newVal, err = snc.Decr("val", 3)
+	if err != nil {
+		t.Fatalf("Decr failed: %v", err)
+	}
+	if newVal != 12 {
+		t.Errorf("Expected 12 after Decr, got %d", newVal)
+	}
+}
+
+func TestShardedIncrOverflow(t *testing.T) {
+	snc := NewShardedNumeric[int8](5, DefaultExpiration, 0)
+	snc.Set("int8", int8(127), DefaultExpiration)
+
+	newVal, err := snc.Incr("int8", 1)
+	if err != nil {
+		t.Fatalf("Incr failed: %v", err)
+	}
+	if newVal != -128 {
+		t.Errorf("Expected -128 after overflow, got %d", newVal)
+	}
+}
+
+func TestShardedDecrUnderflow(t *testing.T) {
+	snc := NewShardedNumeric[uint8](5, DefaultExpiration, 0)
+	snc.Set("uint8", uint8(0), DefaultExpiration)
+
+	newVal, err := snc.Decr("uint8", 1)
+	if err != nil {
+		t.Fatalf("Decr failed: %v", err)
+	}
+	if newVal != 255 {
+		t.Errorf("Expected 255 after underflow, got %d", newVal)
+	}
+}
+
+func TestShardedIncrWithoutSet(t *testing.T) {
+	snc := NewShardedNumeric[int](5, DefaultExpiration, 0)
+
+	newVal, err := snc.Incr("newval", 5)
+	if err != nil {
+		t.Fatalf("Incr failed: %v", err)
+	}
+	if newVal != 5 {
+		t.Errorf("Expected 5 after Incr on empty key, got %d", newVal)
+	}
+}
+
 func BenchmarkShardedCacheGetExpiring(b *testing.B) {
 	benchmarkShardedCacheGet(b, 5*time.Minute)
 }