EvBufferEventInternal.hpp

   1 #ifndef _EV_BUFFER_EVENT_INTERNAL__HPP_
   2 #define _EV_BUFFER_EVENT_INTERNAL__HPP_
   3
   4 #include <event.h>
   5
   6
   7 struct EvBufferEventInternal
   8 {
   9
  10         /* protected: */
  11                 /**
  12                  * Constructor to setup callbacks
  13                  */
  14                 EvBufferEventInternal()
  15                 {
  16                         _bufferevent = NULL;
  17                 }
  18
  19         /* protected: */
  20                 /**
  21                  * Open the bufferevent object with the file/socket descriptor
  22                  * by calling ::bufferevent_new()
  23                  */
  24                 struct bufferevent * _bufferevent_new(int fd) /* throw(...) */
  25                 {
  26                         return _bufferevent =
  27                                 ::bufferevent_new(fd, _readcb_wrapper, _writecb_wrapper, _errorcb_wrapper,
  28                                         reinterpret_cast< void * >(this));
  29                 }
  30
  31                 /**
  32                  * Open the bufferevent object with the listen socket descriptor
  33                  * by calling ::bufev_socket_accept()
  34                  */
  35                 struct bufferevent * _bufev_socket_accept(int listen_sock) /* throw(...) */
  36                 {
  37                         return _bufferevent =
  38                                 ::bufev_socket_accept(listen_sock, _readcb_wrapper, _writecb_wrapper, _errorcb_wrapper,
  39                                         reinterpret_cast< void * >(this));
  40                 }
  41
  42         /* TODO (future): protected: */
  43                 /**
  44                  * Enable certain bufferevent callbacks by calling ::bufferevent_enable()
  45                  */
  46                 int _enable(short ev)
  47                 {
  48                         return ::bufferevent_enable(_bufferevent, ev);
  49                 }
  50
  51                 /**
  52                  * Disable certain bufferevent callbacks by calling ::bufferevent_disable()
  53                  */
  54                 int _disable(short ev)
  55                 {
  56                         return ::bufferevent_disable(_bufferevent, ev);
  57                 }
  58
  59                 int _write(char * buf, int len)
  60                 {
  61                         return ::bufferevent_write(_bufferevent, buf, len);
  62                 }
  63
  64                 int _read(char * buf, int len)
  65                 {
  66                         return ::bufferevent_read(_bufferevent, buf, len);
  67                 }
  68
  69                 int _input_length()
  70                 {
  71                         return EVBUFFER_LENGTH(_bufferevent->input);
  72                 }
  73                 int _output_length()
  74                 {
  75                         return EVBUFFER_LENGTH(_bufferevent->output);
  76                 }
  77
  78         /* public: */
  79                 virtual ~EvBufferEventInternal()
  80                 {
  81                         if (_bufferevent != NULL)
  82                                 ::bufferevent_free(_bufferevent);
  83                 }
  84
  85         /* protected: */
  86                 struct bufferevent * _bufferevent;
  87
  88         /* TODO (future): protected: */
  89                 virtual void _readcb_handler()
  90                         { /* to be overridden by derived bufferevent class */ }
  91
  92                 virtual void _writecb_handler()
  93                         { /* to be overridden by derived bufferevent class */ }
  94
  95                 virtual void _errorcb_handler(short)
  96                         { /* to be overridden by derived bufferevent class */ }
  97
  98         /* TODO (future): private: */
  99                 static void _readcb_wrapper(bufferevent *, void * arg)
 100                 {
 101                         EvBufferEventInternal * bufferevent_self = reinterpret_cast< EvBufferEventInternal * >(arg);
 102
 103                         bufferevent_self->_readcb_handler();
 104                 }
 105
 106                 static void _writecb_wrapper(bufferevent *, void * arg)
 107                 {
 108                         EvBufferEventInternal * bufferevent_self = reinterpret_cast< EvBufferEventInternal * >(arg);
 109
 110                         bufferevent_self->_writecb_handler();
 111                 }
 112
 113                 static void _errorcb_wrapper(bufferevent *, short what, void * arg)
 114                 {
 115                         EvBufferEventInternal * bufferevent_self = reinterpret_cast< EvBufferEventInternal * >(arg);
 116
 117                         bufferevent_self->_errorcb_handler(what);
 118                 }
 119
 120 };
 121
 122 #endif // _EV_BUFFER_EVENT_INTERNAL__HPP_
 123
 124 // vim: set filetype=cpp :