Make RESPChannelHandler work as a base-class

... so that we subclass it.

Intention: workaround NIOAny wrapping overhead.

Author: helje5

Sources/NIORedis/RESPChannelHandler.swift

@@ -14,48 +14,47 @@
 
 import NIO
 
-final class RedisChannelHandler : ChannelInboundHandler,
-                                  ChannelOutboundHandler
+open class RedisChannelHandler : ChannelInboundHandler,
+                                 ChannelOutboundHandler
 {
 
-  typealias InboundErr  = RESPParserError
+  public typealias InboundErr  = RESPParserError
 
-  typealias InboundIn   = ByteBuffer
-  typealias InboundOut  = RESPValue
+  public typealias InboundIn   = ByteBuffer
+  public typealias InboundOut  = RESPValue
 
-  typealias OutboundIn  = RESPEncodable
-  typealias OutboundOut = ByteBuffer
+  public typealias OutboundIn  = RESPEncodable
+  public typealias OutboundOut = ByteBuffer
 
-  let nilStringBuffer = ConstantBuffers.nilStringBuffer
-  let nilArrayBuffer  = ConstantBuffers.nilArrayBuffer
+  private final let nilStringBuffer = ConstantBuffers.nilStringBuffer
+  private final let nilArrayBuffer  = ConstantBuffers.nilArrayBuffer
 
-  private final var parser = RESPParser()
+  public final var parser = RESPParser()
 
   // MARK: - Channel Open/Close
 
-  func channelActive(ctx: ChannelHandlerContext) {
+  public func channelActive(ctx: ChannelHandlerContext) {
     ctx.fireChannelActive()
   }
-  func channelInactive(ctx: ChannelHandlerContext) {
-    switch state {
-      case .protocolError, .start: break // all good
-      default:
-        ctx.fireErrorCaught(InboundErr.ProtocolError)
-    }
-    
-    overflowBuffer = nil
-    
+  public func channelInactive(ctx: ChannelHandlerContext) {
+    #if false // this doesn't gain us anything?
+      switch parser.state {
+        case .protocolError, .start: break // all good
+        default:
+          ctx.fireErrorCaught(InboundErr.ProtocolError)
+      }
+    #endif
     ctx.fireChannelInactive()
   }
-  
+
 
   // MARK: - Reading
 
   public func channelRead(ctx: ChannelHandlerContext, data: NIOAny) {
     do {
       let buffer = self.unwrapInboundIn(data)
       try parser.feed(buffer) { respValue in
-        ctx.fireChannelRead(self.wrapInboundOut(respValue))
+        self.channelRead(ctx: ctx, value: respValue)
       }
     }
     catch {
@@ -64,84 +63,28 @@ final class RedisChannelHandler : ChannelInboundHandler,
       return
     }
   }
-
+  
+  open func channelRead(ctx: ChannelHandlerContext, value: RESPValue) {
+    ctx.fireChannelRead(self.wrapInboundOut(value))
+  }
+  
   public func errorCaught(ctx: ChannelHandlerContext, error: Error) {
     ctx.fireErrorCaught(InboundErr.TransportError(error))
   }
 
 
-  // MARK: - Parsing
+  // MARK: - Writing
 
-  private enum ParserState {
-    case protocolError
-    case start
-    case error
-    case integer
-    case bulkStringLen
-    case bulkStringValue
-    case simpleString
-    case arrayCount
-    case telnet
-  }
-  
-  @inline(__always)
-  private func makeArrayParseContext(_ parent: ArrayParseContext? = nil,
-                                     _ count: Int) -> ArrayParseContext
+  public func write(ctx: ChannelHandlerContext, data: NIOAny,
+                    promise: EventLoopPromise<Void>?)
   {
-    if parent == nil && cachedParseContext != nil {
-      let ctx = cachedParseContext!
-      cachedParseContext = nil
-      ctx.count = count
-      ctx.values.reserveCapacity(count)
-      return ctx
-    }
-    else {
-      return ArrayParseContext(parent, count)
-    }
-  }
-  private final var cachedParseContext : ArrayParseContext? = nil
-  
-  final private class ArrayParseContext {
-    
-    let parent : ArrayParseContext?
-    var values = ContiguousArray<RESPValue>()
-    var count  : Int
-    
-    init(_ parent: ArrayParseContext?, _ count: Int) {
-      self.parent = parent
-      self.count  = count
-    }
-    
-    var isDone   : Bool { return count <= values.count }
-    var isNested : Bool { return parent != nil }
-    
-    @inline(__always)
-    func append(value v: InboundOut) -> Bool {
-      assert(!isNested || !isDone,
-             "attempt to add to a context which is not TL or done")
-      values.append(v)
-      return isDone
-    }
+    let data : RESPEncodable = self.unwrapOutboundIn(data)
+    write(ctx: ctx, value: data.toRESPValue(), promise: promise)
   }
 
-  private var state          = ParserState.start
-  private var overflowSkipNL = false
-  private var hadMinus       = false
-  
-  private var countValue     = 0
-  private var overflowBuffer : ByteBuffer?
-  
-  private var arrayContext   : ArrayParseContext?
-  
-  
-  // MARK: - Writing
-  
-  func write(ctx: ChannelHandlerContext, data: NIOAny,
-             promise: EventLoopPromise<Void>?)
+  public final func write(ctx: ChannelHandlerContext, value: RESPValue,
+                          promise: EventLoopPromise<Void>?)
   {
-    let data  : RESPEncodable = self.unwrapOutboundIn(data)
-    let value = data.toRESPValue()
-    
     var out : ByteBuffer
     switch value {
       case .simpleString(var s): // +
@@ -190,8 +133,8 @@ final class RedisChannelHandler : ChannelInboundHandler,
   }
 
   @inline(__always)
-  func encode<S: ContiguousCollection>(simpleString bytes: S,
-                                       out: inout ByteBuffer)
+  final func encode<S: ContiguousCollection>(simpleString bytes: S,
+                                             out: inout ByteBuffer)
          where S.Element == UInt8
   {
     out.write(integer : UInt8(43)) // +
@@ -200,15 +143,15 @@ final class RedisChannelHandler : ChannelInboundHandler,
   }
 
   @inline(__always)
-  func encode(simpleString bytes: ByteBuffer, out: inout ByteBuffer) {
+  final func encode(simpleString bytes: ByteBuffer, out: inout ByteBuffer) {
     var s = bytes
     out.write(integer : UInt8(43)) // +
     out.write(buffer  : &s)
     out.write(bytes   : eol)
   }
 
   @inline(__always)
-  func encode(bulkString bytes: ByteBuffer?, out: inout ByteBuffer) {
+  final func encode(bulkString bytes: ByteBuffer?, out: inout ByteBuffer) {
     if var s = bytes {
       out.write(integer         : UInt8(36)) // $
       out.write(integerAsString : s.readableBytes)
@@ -222,8 +165,8 @@ final class RedisChannelHandler : ChannelInboundHandler,
   }
 
   @inline(__always)
-  func encode<S: ContiguousCollection>(bulkString bytes: S?,
-                                       out: inout ByteBuffer)
+  final func encode<S: ContiguousCollection>(bulkString bytes: S?,
+                                             out: inout ByteBuffer)
          where S.Element == UInt8
   {
     if let s = bytes {
@@ -239,32 +182,32 @@ final class RedisChannelHandler : ChannelInboundHandler,
   }
 
   @inline(__always)
-  func encode(integer i: Int, out: inout ByteBuffer) {
+  final func encode(integer i: Int, out: inout ByteBuffer) {
     out.write(integer         : UInt8(58)) // :
     out.write(integerAsString : i)
     out.write(bytes           : eol)
   }
 
   @inline(__always)
-  func encode(error: RESPError, out: inout ByteBuffer) {
+  final func encode(error: RESPError, out: inout ByteBuffer) {
     out.write(integer : UInt8(45)) // -
     out.write(string  : error.code)
     out.write(integer : UInt8(32)) // ' '
     out.write(string  : error.message)
     out.write(bytes   : eol)
   }
 
-  func encode(ctx  : ChannelHandlerContext,
-              data : RESPValue,
-              out  : inout ByteBuffer)
+  final func encode(ctx  : ChannelHandlerContext,
+                    data : RESPValue,
+                    out  : inout ByteBuffer)
   {
     encode(ctx: ctx, data: data, level: 0, out: &out)
   }
 
-  func encode(ctx   : ChannelHandlerContext,
-              data  : RESPValue,
-              level : Int,
-              out   : inout ByteBuffer)
+  final func encode(ctx   : ChannelHandlerContext,
+                    data  : RESPValue,
+                    level : Int,
+                    out   : inout ByteBuffer)
   {
     // FIXME: Creating a String for an Int is expensive, there is something
     //        something better in the HTTP-API async imp.