wip serializers

Author: tanner0101

.gitignore

@@ -2,3 +2,5 @@
 /.build
 /Packages
 /*.xcodeproj
+Package.resolved
+

Package.swift

@@ -1,28 +1,20 @@
 // swift-tools-version:4.0
-// The swift-tools-version declares the minimum version of Swift required to build this package.
-
 import PackageDescription
 
 let package = Package(
-    name: "postgresql",
+    name: "PostgreSQL",
     products: [
-        // Products define the executables and libraries produced by a package, and make them visible to other packages.
-        .library(
-            name: "postgresql",
-            targets: ["postgresql"]),
+        .library(name: "PostgreSQL", targets: ["PostgreSQL"]),
     ],
     dependencies: [
-        // Dependencies declare other packages that this package depends on.
-        // .package(url: /* package url */, from: "1.0.0"),
+        // Swift Promises, Futures, and Streams.
+        .package(url: "https://github.com/vapor/async.git", .branch("beta")),
+        
+        // Core extensions, type-aliases, and functions that facilitate common tasks.
+        .package(url: "https://github.com/vapor/core.git", .branch("beta")),
     ],
     targets: [
-        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
-        // Targets can depend on other targets in this package, and on products in packages which this package depends on.
-        .target(
-            name: "postgresql",
-            dependencies: []),
-        .testTarget(
-            name: "postgresqlTests",
-            dependencies: ["postgresql"]),
+        .target(name: "PostgreSQL", dependencies: ["Async", "Bits"]),
+        .testTarget(name: "PostgreSQLTests", dependencies: ["PostgreSQL"]),
     ]
 )

Sources/postgresql/PostgresMessage.swift

@@ -0,0 +1,23 @@
+import Bits
+
+enum PostgresMessage {
+    case startupMessage(
+        /// The protocol version number. The most significant 16 bits are the major
+        /// version number (3 for the protocol described here). The least significant
+        /// 16 bits are the minor version number (0 for the protocol described here).
+        protocolVersion: Int32,
+        /// The protocol version number is followed by one or more pairs of parameter
+        /// name and value strings. A zero byte is required as a terminator after
+        /// the last name/value pair. Parameters can appear in any order. user is required,
+        /// others are optional. Each parameter is specified as:
+        parameters: [String: String]
+    )
+
+
+    /// The first byte of a message identifies the message type
+    var identifier: Byte? {
+        switch self {
+        case .startupMessage: return nil
+        }
+    }
+}

Sources/postgresql/PostgresSerializer.swift

@@ -0,0 +1,60 @@
+import Async
+import Bits
+import Foundation
+
+struct PostgresSerializerState {
+    var remaining: Data
+}
+
+final class PostgresSerializer: ByteSerializer {
+    var state: ByteSerializerState<PostgresSerializer>
+
+    typealias Input = PostgresMessage
+    typealias Output = ByteBuffer
+
+    let buffer: MutableByteBuffer
+
+    init() {
+        buffer = MutableByteBuffer(start: .allocate(capacity: 4096), count: 4096)
+        state = .init()
+    }
+
+    func serialize(
+        _ message: PostgresMessage,
+        state: PostgresSerializerState?
+    ) throws -> ByteSerializerResult<PostgresSerializer> {
+        if let state = state {
+            return serialize(data: state.remaining)
+        }
+
+        switch message {
+        case .startupMessage(let protocolVersion, let parameters):
+            var data = Data([0, 0, 0, 0])
+            for word in protocolVersion.words {
+                data.append(Byte(word))
+            }
+            for (key, val) in parameters {
+                data.append(contentsOf: key.data(using: .ascii)!)
+                data.append(contentsOf: [0])
+                data.append(contentsOf: val.data(using: .ascii)!)
+                data.append(contentsOf: [0])
+            }
+            data.append(contentsOf: [0])
+            return serialize(data: data)
+        }
+    }
+
+    func serialize(data: Data) -> ByteSerializerResult<PostgresSerializer> {
+        let count = data.copyBytes(to: buffer)
+        let view = ByteBuffer(start: buffer.baseAddress, count: count)
+        if data.count > count {
+            return .incomplete(view, state: .init(remaining: data[count..<data.count]))
+        } else {
+            return .complete(view)
+        }
+    }
+
+    deinit {
+        buffer.baseAddress?.deallocate(capacity: buffer.count)
+    }
+}