Port MessageToByteEncoder from netty

Sources/NIO/Codec.swift

@@ -80,3 +80,24 @@ public extension ByteToMessageDecoder {
         
     }
 }
+
+public protocol MessageToByteEncoder : ChannelOutboundHandler {
+    func encode(ctx: ChannelHandlerContext, data: IOData, out: inout ByteBuffer) throws
+    func allocateOutBuffer(ctx: ChannelHandlerContext, data: IOData) throws -> ByteBuffer
+}
+
+public extension MessageToByteEncoder {
+    public func write(ctx: ChannelHandlerContext, data: IOData, promise: Promise<Void>?) {
+        do {
+            var buffer: ByteBuffer = try allocateOutBuffer(ctx: ctx, data: data)
+            try encode(ctx: ctx, data: data, out: &buffer)
+            ctx.write(data: .byteBuffer(buffer), promise: promise)
+        } catch let err {
+            promise?.fail(error: err)
+        }
+    }
+    
+    public func allocateOutBuffer(ctx: ChannelHandlerContext, data: IOData) throws -> ByteBuffer {
+        return ctx.channel!.allocator.buffer(capacity: 256)
+    }
+}

Tests/LinuxMain.swift

@@ -31,6 +31,7 @@ import XCTest
          testCase(ByteBufferTest.allTests),
          testCase(ChannelPipelineTest.allTests),
          testCase(ByteToMessageDecoderTest.allTests),
+         testCase(MessageToByteEncoderTest.allTests),
          testCase(EmbeddedChannelTest.allTests),
          testCase(AdaptiveRecvByteBufferAllocatorTest.allTests),
     ])

Tests/NIOTests/CodecTest+XCTest.swift

@@ -31,3 +31,12 @@ extension ByteToMessageDecoderTest {
    }
 }
 
+extension MessageToByteEncoderTest {
+
+   static var allTests : [(String, (MessageToByteEncoderTest) -> () throws -> Void)] {
+      return [
+                ("testEncoder", testEncoder),
+           ]
+   }
+}
+

Tests/NIOTests/CodecTest.swift

@@ -77,3 +77,34 @@ public class ByteToMessageDecoderTest: XCTestCase {
         XCTAssertEqual(Int32(3), dataArray[2])
     }
 }
+
+public class MessageToByteEncoderTest: XCTestCase {
+    
+    private final class Int32ToByteEncoder : MessageToByteEncoder {
+        public func encode(ctx: ChannelHandlerContext, data: IOData, out: inout ByteBuffer) throws {
+            XCTAssertEqual(MemoryLayout<Int32>.size, out.writableBytes)
+            let value: Int32 = data.forceAsOther()
+            out.write(integer: value);
+        }
+        
+        public func allocateOutBuffer(ctx: ChannelHandlerContext, data: IOData) throws -> ByteBuffer {
+            return ctx.channel!.allocator.buffer(capacity: MemoryLayout<Int32>.size)
+        }
+    }
+    
+    func testEncoder() throws {
+        let channel = EmbeddedChannel()
+        
+        _ = try channel.pipeline.add(handler: Int32ToByteEncoder()).wait()
+        
+        _ = try channel.writeAndFlush(data: .other(Int32(5))).wait()
+        
+        XCTAssertEqual(1, channel.outboundBuffer.count)
+        
+        var buffer = channel.outboundBuffer[0] as! ByteBuffer
+        XCTAssertEqual(Int32(5), buffer.readInteger())
+        XCTAssertEqual(0, buffer.readableBytes)
+        
+        try channel.close().wait()
+    }
+}