Implement an Arithmetic Request supporting increment and decrement operations

Sources/SwiftMemcache/Extensions/ByteBuffer+SwiftMemcache.swift

@@ -101,6 +101,22 @@ extension ByteBuffer {
                 self.writeInteger(UInt8.R)
             }
         }
+
+        if let arithmeticMode = flags.arithmeticMode {
+            self.writeInteger(UInt8.whitespace)
+            self.writeInteger(UInt8.M)
+            switch arithmeticMode {
+            case .decrement:
+                self.writeInteger(UInt8.decrement)
+            case .increment:
+                self.writeInteger(UInt8.increment)
+            }
+            if let arithmeticDelta = flags.arithmeticDelta {
+                self.writeInteger(UInt8.whitespace)
+                self.writeInteger(UInt8.D)
+                self.writeIntegerAsASCII(arithmeticDelta)
+            }
+        }
     }
 }
 

Sources/SwiftMemcache/Extensions/UInt8+Characters.swift

@@ -20,13 +20,17 @@ extension UInt8 {
     static var s: UInt8 = .init(ascii: "s")
     static var g: UInt8 = .init(ascii: "g")
     static var d: UInt8 = .init(ascii: "d")
+    static var a: UInt8 = .init(ascii: "a")
     static var v: UInt8 = .init(ascii: "v")
     static var T: UInt8 = .init(ascii: "T")
     static var M: UInt8 = .init(ascii: "M")
     static var P: UInt8 = .init(ascii: "P")
     static var A: UInt8 = .init(ascii: "A")
     static var E: UInt8 = .init(ascii: "E")
     static var R: UInt8 = .init(ascii: "R")
+    static var D: UInt8 = .init(ascii: "D")
     static var zero: UInt8 = .init(ascii: "0")
     static var nine: UInt8 = .init(ascii: "9")
+    static var increment: UInt8 = .init(ascii: "+")
+    static var decrement: UInt8 = .init(ascii: "-")
 }

Sources/SwiftMemcache/MemcachedConnection.swift

@@ -424,4 +424,58 @@ public actor MemcachedConnection {
             throw MemcachedConnectionError.connectionShutdown
         }
     }
+
+    // MARK: - Increment a Value
+
+    /// Increment the value for an existing key in the Memcache server by a specified amount.
+    ///
+    /// - Parameters:
+    ///   - key: The key for the value to increment.
+    ///   - amount: The `UInt64` amount to increment the value by.
+    /// - Throws: A `MemcachedConnectionError` if the connection to the Memcached server is shut down.
+    public func increment(_ key: String, amount: UInt64) async throws {
+        switch self.state {
+        case .initial(_, _, _, _),
+             .running:
+
+            var flags = MemcachedFlags()
+            flags.arithmeticMode = .increment
+            flags.arithmeticDelta = amount
+
+            let command = MemcachedRequest.ArithmeticCommand(key: key, flags: flags)
+            let request = MemcachedRequest.arithmetic(command)
+
+            _ = try await self.sendRequest(request)
+
+        case .finished:
+            throw MemcachedConnectionError.connectionShutdown
+        }
+    }
+
+    // MARK: - Decrement a Value
+
+    /// Decrement the value for an existing key in the Memcache server by a specified amount.
+    ///
+    /// - Parameters:
+    ///   - key: The key for the value to decrement.
+    ///   - amount: The `UInt64` amount to decrement the value by.
+    /// - Throws: A `MemcachedConnectionError` if the connection to the Memcached server is shut down.
+    public func decrement(_ key: String, amount: UInt64) async throws {
+        switch self.state {
+        case .initial(_, _, _, _),
+             .running:
+
+            var flags = MemcachedFlags()
+            flags.arithmeticMode = .decrement
+            flags.arithmeticDelta = amount
+
+            let command = MemcachedRequest.ArithmeticCommand(key: key, flags: flags)
+            let request = MemcachedRequest.arithmetic(command)
+
+            _ = try await self.sendRequest(request)
+
+        case .finished:
+            throw MemcachedConnectionError.connectionShutdown
+        }
+    }
 }

Sources/SwiftMemcache/MemcachedFlags.swift

@@ -37,6 +37,16 @@ struct MemcachedFlags {
     /// The default mode is 'set'.
     var storageMode: StorageMode?
 
+    /// Flag 'M' for the 'ma' (meta arithmetic) command.
+    ///
+    /// Represents the mode of the 'ma' command, which determines the behavior of the arithmetic operation.
+    var arithmeticMode: ArithmeticMode?
+
+    /// Flag 'D' for the 'ma' (meta arithmetic) command.
+    ///
+    /// Represents the delta to apply to the 'ma' command. The default value is 1.
+    var arithmeticDelta: UInt64?
+
     init() {}
 }
 
@@ -60,4 +70,12 @@ enum StorageMode: Equatable, Hashable {
     case replace
 }
 
+/// Enum representing the mode for the 'ma' (meta arithmetic) command in Memcached (corresponding to the 'M' flag).
+enum ArithmeticMode: Equatable, Hashable {
+    /// 'increment' command. If applied, it increases the numerical value of the item.
+    case increment
+    /// 'decrement' command. If applied, it decreases the numerical value of the item.
+    case decrement
+}
+
 extension MemcachedFlags: Hashable {}

Sources/SwiftMemcache/MemcachedRequest.swift

@@ -29,7 +29,13 @@ enum MemcachedRequest {
         let key: String
     }
 
+    struct ArithmeticCommand {
+        let key: String
+        var flags: MemcachedFlags
+    }
+
     case set(SetCommand)
     case get(GetCommand)
     case delete(DeleteCommand)
+    case arithmetic(ArithmeticCommand)
 }

Sources/SwiftMemcache/MemcachedRequestEncoder.swift

@@ -73,6 +73,22 @@ struct MemcachedRequestEncoder: MessageToByteEncoder {
             out.writeInteger(UInt8.whitespace)
             out.writeBytes(command.key.utf8)
 
+            // write separator
+            out.writeInteger(UInt8.carriageReturn)
+            out.writeInteger(UInt8.newline)
+
+        case .arithmetic(let command):
+            precondition(!command.key.isEmpty, "Key must not be empty")
+
+            // write command and key
+            out.writeInteger(UInt8.m)
+            out.writeInteger(UInt8.a)
+            out.writeInteger(UInt8.whitespace)
+            out.writeBytes(command.key.utf8)
+
+            // write flags if there are any
+            out.writeMemcachedFlags(flags: command.flags)
+
             // write separator
             out.writeInteger(UInt8.carriageReturn)
             out.writeInteger(UInt8.newline)

Sources/SwiftMemcache/MemcachedValue.swift

@@ -33,14 +33,15 @@ extension MemcachedValue where Self: FixedWidthInteger {
     ///
     /// - Parameter buffer: The ByteBuffer to which the integer should be written.
     public func writeToBuffer(_ buffer: inout ByteBuffer) {
-        buffer.writeInteger(self)
+        buffer.writeString(String(self))
     }
 
     /// Reads a FixedWidthInteger from a ByteBuffer.
     ///
     /// - Parameter buffer: The ByteBuffer from which the value should be read.
     public static func readFromBuffer(_ buffer: inout ByteBuffer) -> Self? {
-        return buffer.readInteger()
+        guard let string = buffer.readString(length: buffer.readableBytes)?.trimmingCharacters(in: .whitespacesAndNewlines) else { return nil }
+        return Self(string)
     }
 }
 

Tests/SwiftMemcacheTests/IntegrationTest/MemcachedIntegrationTests.swift

@@ -434,6 +434,62 @@ final class MemcachedIntegrationTest: XCTestCase {
         }
     }
 
+    func testIncrementValue() async throws {
+        let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        defer {
+            XCTAssertNoThrow(try! group.syncShutdownGracefully())
+        }
+        let memcachedConnection = MemcachedConnection(host: "memcached", port: 11211, eventLoopGroup: group)
+
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            group.addTask { try await memcachedConnection.run() }
+
+            // Set key and initial value
+            let initialValue: UInt64 = 1
+            try await memcachedConnection.set("increment", value: initialValue)
+
+            // Increment value
+            let incrementAmount: UInt64 = 100
+            try await memcachedConnection.increment("increment", amount: incrementAmount)
+
+            // Get new value
+            let newValue: UInt64? = try await memcachedConnection.get("increment")
+
+            // Check if new value is equal to initial value plus increment amount
+            XCTAssertEqual(newValue, initialValue + incrementAmount, "Incremented value is incorrect")
+
+            group.cancelAll()
+        }
+    }
+
+    func testDecrementValue() async throws {
+        let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        defer {
+            XCTAssertNoThrow(try! group.syncShutdownGracefully())
+        }
+        let memcachedConnection = MemcachedConnection(host: "memcached", port: 11211, eventLoopGroup: group)
+
+        try await withThrowingTaskGroup(of: Void.self) { group in
+            group.addTask { try await memcachedConnection.run() }
+
+            // Set key and initial value
+            let initialValue: UInt64 = 100
+            try await memcachedConnection.set("decrement", value: initialValue)
+
+            // Increment value
+            let decrementAmount: UInt64 = 10
+            try await memcachedConnection.decrement("decrement", amount: decrementAmount)
+
+            // Get new value
+            let newValue: UInt64? = try await memcachedConnection.get("decrement")
+
+            // Check if new value is equal to initial value plus increment amount
+            XCTAssertEqual(newValue, initialValue - decrementAmount, "Incremented value is incorrect")
+
+            group.cancelAll()
+        }
+    }
+
     func testMemcachedConnectionWithUInt() async throws {
         let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
         defer {

Tests/SwiftMemcacheTests/UnitTest/MemcachedRequestEncoderTests.swift

@@ -169,4 +169,34 @@ final class MemcachedRequestEncoderTests: XCTestCase {
         let expectedEncodedData = "md foo\r\n"
         XCTAssertEqual(outBuffer.getString(at: 0, length: outBuffer.readableBytes), expectedEncodedData)
     }
+
+    func testEncodeIncrementRequest() {
+        // Prepare a MemcachedRequest
+        var flags = MemcachedFlags()
+        flags.arithmeticMode = .increment
+        flags.arithmeticDelta = 100
+        let command = MemcachedRequest.ArithmeticCommand(key: "foo", flags: flags)
+        let request = MemcachedRequest.arithmetic(command)
+
+        // pass our request through the encoder
+        let outBuffer = self.encodeRequest(request)
+
+        let expectedEncodedData = "ma foo M+ D100\r\n"
+        XCTAssertEqual(outBuffer.getString(at: 0, length: outBuffer.readableBytes), expectedEncodedData)
+    }
+
+    func testEncodeDecrementRequest() {
+        // Prepare a MemcachedRequest
+        var flags = MemcachedFlags()
+        flags.arithmeticMode = .decrement
+        flags.arithmeticDelta = 100
+        let command = MemcachedRequest.ArithmeticCommand(key: "foo", flags: flags)
+        let request = MemcachedRequest.arithmetic(command)
+
+        // pass our request through the encoder
+        let outBuffer = self.encodeRequest(request)
+
+        let expectedEncodedData = "ma foo M- D100\r\n"
+        XCTAssertEqual(outBuffer.getString(at: 0, length: outBuffer.readableBytes), expectedEncodedData)
+    }
 }