Future<Unit> wangle fixup

[folly.git] / folly / wangle / channel / Handler.h

diff --git a/folly/wangle/channel/Handler.h b/folly/wangle/channel/Handler.h
index 062d23a2fd5576d243f64cd352cbb51bd4864a52..127ac97314648ec462fb092ab34109e8376eebaf 100644 (file)
--- a/folly/wangle/channel/Handler.h
+++ b/folly/wangle/channel/Handler.h
@@ -23,15 +23,39 @@
 
 namespace folly { namespace wangle {
 
+template <class Context>
+class HandlerBase {
+ public:
+  virtual ~HandlerBase() = default;
+
+  virtual void attachPipeline(Context* ctx) {}
+  virtual void detachPipeline(Context* ctx) {}
+
+  Context* getContext() {
+    if (attachCount_ != 1) {
+      return nullptr;
+    }
+    CHECK(ctx_);
+    return ctx_;
+  }
+
+ private:
+  friend PipelineContext;
+  uint64_t attachCount_{0};
+  Context* ctx_{nullptr};
+};
+
 template <class Rin, class Rout = Rin, class Win = Rout, class Wout = Rin>
-class Handler {
+class Handler : public HandlerBase<HandlerContext<Rout, Wout>> {
  public:
+  static const HandlerDir dir = HandlerDir::BOTH;
+
   typedef Rin rin;
   typedef Rout rout;
   typedef Win win;
   typedef Wout wout;
   typedef HandlerContext<Rout, Wout> Context;
-  virtual ~Handler() {}
+  virtual ~Handler() = default;
 
   virtual void read(Context* ctx, Rin msg) = 0;
   virtual void readEOF(Context* ctx) {
@@ -40,18 +64,18 @@ class Handler {
   virtual void readException(Context* ctx, exception_wrapper e) {
     ctx->fireReadException(std::move(e));
   }
+  virtual void transportActive(Context* ctx) {
+    ctx->fireTransportActive();
+  }
+  virtual void transportInactive(Context* ctx) {
+    ctx->fireTransportInactive();
+  }
 
-  virtual Future<void> write(Context* ctx, Win msg) = 0;
-  virtual Future<void> close(Context* ctx) {
+  virtual Future<Unit> write(Context* ctx, Win msg) = 0;
+  virtual Future<Unit> close(Context* ctx) {
     return ctx->fireClose();
   }
 
-  virtual void attachPipeline(Context* ctx) {}
-  virtual void attachTransport(Context* ctx) {}
-
-  virtual void detachPipeline(Context* ctx) {}
-  virtual void detachTransport(Context* ctx) {}
-
   /*
   // Other sorts of things we might want, all shamelessly stolen from Netty
   // inbound
@@ -60,26 +84,69 @@ class Handler {
       exception_wrapper e) {}
   virtual void channelRegistered(HandlerContext* ctx) {}
   virtual void channelUnregistered(HandlerContext* ctx) {}
-  virtual void channelActive(HandlerContext* ctx) {}
-  virtual void channelInactive(HandlerContext* ctx) {}
   virtual void channelReadComplete(HandlerContext* ctx) {}
   virtual void userEventTriggered(HandlerContext* ctx, void* evt) {}
   virtual void channelWritabilityChanged(HandlerContext* ctx) {}
 
   // outbound
-  virtual Future<void> bind(
+  virtual Future<Unit> bind(
       HandlerContext* ctx,
       SocketAddress localAddress) {}
-  virtual Future<void> connect(
+  virtual Future<Unit> connect(
           HandlerContext* ctx,
           SocketAddress remoteAddress, SocketAddress localAddress) {}
-  virtual Future<void> disconnect(HandlerContext* ctx) {}
-  virtual Future<void> deregister(HandlerContext* ctx) {}
-  virtual Future<void> read(HandlerContext* ctx) {}
+  virtual Future<Unit> disconnect(HandlerContext* ctx) {}
+  virtual Future<Unit> deregister(HandlerContext* ctx) {}
+  virtual Future<Unit> read(HandlerContext* ctx) {}
   virtual void flush(HandlerContext* ctx) {}
   */
 };
 
+template <class Rin, class Rout = Rin>
+class InboundHandler : public HandlerBase<InboundHandlerContext<Rout>> {
+ public:
+  static const HandlerDir dir = HandlerDir::IN;
+
+  typedef Rin rin;
+  typedef Rout rout;
+  typedef Unit win;
+  typedef Unit wout;
+  typedef InboundHandlerContext<Rout> Context;
+  virtual ~InboundHandler() = default;
+
+  virtual void read(Context* ctx, Rin msg) = 0;
+  virtual void readEOF(Context* ctx) {
+    ctx->fireReadEOF();
+  }
+  virtual void readException(Context* ctx, exception_wrapper e) {
+    ctx->fireReadException(std::move(e));
+  }
+  virtual void transportActive(Context* ctx) {
+    ctx->fireTransportActive();
+  }
+  virtual void transportInactive(Context* ctx) {
+    ctx->fireTransportInactive();
+  }
+};
+
+template <class Win, class Wout = Win>
+class OutboundHandler : public HandlerBase<OutboundHandlerContext<Wout>> {
+ public:
+  static const HandlerDir dir = HandlerDir::OUT;
+
+  typedef Unit rin;
+  typedef Unit rout;
+  typedef Win win;
+  typedef Wout wout;
+  typedef OutboundHandlerContext<Wout> Context;
+  virtual ~OutboundHandler() = default;
+
+  virtual Future<Unit> write(Context* ctx, Win msg) = 0;
+  virtual Future<Unit> close(Context* ctx) {
+    return ctx->fireClose();
+  }
+};
+
 template <class R, class W = R>
 class HandlerAdapter : public Handler<R, R, W, W> {
  public:
@@ -89,7 +156,7 @@ class HandlerAdapter : public Handler<R, R, W, W> {
     ctx->fireRead(std::forward<R>(msg));
   }
 
-  Future<void> write(Context* ctx, W msg) override {
+  Future<Unit> write(Context* ctx, W msg) override {
     return ctx->fireWrite(std::forward<W>(msg));
   }
 };
@@ -97,4 +164,10 @@ class HandlerAdapter : public Handler<R, R, W, W> {
 typedef HandlerAdapter<IOBufQueue&, std::unique_ptr<IOBuf>>
 BytesToBytesHandler;
 
+typedef InboundHandler<IOBufQueue&, std::unique_ptr<IOBuf>>
+InboundBytesToBytesHandler;
+
+typedef OutboundHandler<std::unique_ptr<IOBuf>>
+OutboundBytesToBytesHandler;
+
 }}