template <class Context>
class HandlerBase {
public:
- virtual ~HandlerBase() {}
+ virtual ~HandlerBase() = default;
virtual void attachPipeline(Context* ctx) {}
- virtual void attachTransport(Context* ctx) {}
-
virtual void detachPipeline(Context* ctx) {}
- virtual void detachTransport(Context* ctx) {}
Context* getContext() {
if (attachCount_ != 1) {
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) {
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();
}
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) {}
*/
};
typedef Rin rin;
typedef Rout rout;
- typedef Nothing win;
- typedef Nothing wout;
+ typedef Unit win;
+ typedef Unit wout;
typedef InboundHandlerContext<Rout> Context;
- virtual ~InboundHandler() {}
+ virtual ~InboundHandler() = default;
virtual void read(Context* ctx, Rin msg) = 0;
virtual void readEOF(Context* ctx) {
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>
public:
static const HandlerDir dir = HandlerDir::OUT;
- typedef Nothing rin;
- typedef Nothing rout;
+ typedef Unit rin;
+ typedef Unit rout;
typedef Win win;
typedef Wout wout;
typedef OutboundHandlerContext<Wout> Context;
- virtual ~OutboundHandler() {}
+ virtual ~OutboundHandler() = default;
- 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();
}
};
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));
}
};