LambdaCodableEncoder should be less Foundation biased

[fabianfett]

Motivation

Currently the LambdaCodableEncoder is based on the method signature defined by NIOFoundationCompat. But this might not be the most efficient API.

The current API looks like this:

public protocol LambdaCodableEncoder {
    func encode<T: Encodable>(_ value: T, into buffer: inout ByteBuffer) throws
}

The problem here is that the ByteBuffer has already been created with a fixed size by the LambdaHandler default implementation:

/// Implementation of  `Out` to `ByteBuffer` encoding
public extension EventLoopLambdaHandler where Out: Encodable {
    func encode(allocator: ByteBufferAllocator, value: Out) throws -> ByteBuffer? {
        // nio will resize the buffer if necessary
        var buffer = allocator.buffer(capacity: 1024)
        try self.encoder.encode(value, into: &buffer)
        return buffer
    }
}

Other encoders might be able to create a ByteBuffer of the correct size right the beginning though.

extension PureSwiftJSONCoding.JSONEncoder: LambdaCodableEncoder {
    public func encode<T>(_ value: T, into byteBuffer: ByteBuffer) throws -> ByteBuffer where T : Encodable {
        let bytes = try self.encode(value) // byte buffer could be created to the right size right away
        buffer.writeBytes(bytes)
        return buffer
    }
}

Changes

This PR changes the LambdaCodableEncoder protocol to hand over the ByteBufferAllocator to the LambdaCodableEncoder instead of creating a ByteBuffer for the encoder right away. For this reason encoders can size the needed ByteBuffer correctly from the very beginning. The example from above could look like this:

extension PureSwiftJSONCoding.JSONEncoder: LambdaCodableEncoder {
    public func encode<T>(_ value: T, using allocator: ByteBufferAllocator) throws -> ByteBuffer where T : Encodable {
        let bytes = try self.encode(value)
        var buffer = allocator.buffer(capacity: bytes.count)
        buffer.writeBytes(bytes)
        return buffer
    }
}