EvBufferEvent.hpp

   1 #ifndef _EV_BUFFER_EVENT__HPP_
   2 #define _EV_BUFFER_EVENT__HPP_
   3
   4 #include <EvBufferEventInternal.hpp>
   5
   6
   7 struct EvBufferEvent : EvBufferEventInternal
   8 {
   9
  10         /// C read/write callback function used in the C evbuffer API.
  11         typedef void (*readwritecb)(struct bufferevent *, void *);
  12
  13         /// C error callback function used in the C evbuffer API.
  14         typedef void (*errorcb)(struct bufferevent *, short, void *);
  15
  16         // TODO: EvBufferEvent(int fd, ...) throw(...) { ... }
  17
  18         // Future: to be deprecated by EvBufferEvent(int fd, ...) throw(...)
  19         /* public: for now */
  20                 /**
  21                  * Constructor to setup callbacks
  22                  */
  23                 EvBufferEvent(readwritecb readcb, readwritecb writecb, errorcb errcb, void * arg)
  24                 {
  25                         _readcb = readcb;
  26                         _writecb = writecb;
  27                         _errorcb = errcb;
  28
  29                         _arg = arg;
  30                 }
  31
  32         // Future: to be deprecated by EvBufferEvent(...) throw(...)
  33         /* public: for now */
  34                 /**
  35                  * Open the bufferevent object with the file/socket descriptor
  36                  */
  37                 void open(int fd) /* throw(...) */
  38                 {
  39                         (void)_bufferevent_new(fd);
  40                 }
  41
  42                 /**
  43                  * Open the bufferevent object by accepting a connection on the socket descriptor
  44                  */
  45                 void accept(int listen_sock) /* throw(...) */
  46                 {
  47                         (void)_bufev_socket_accept(listen_sock);
  48                 }
  49
  50         /* public: */
  51
  52                 /**
  53                  * Write data to the buffer.
  54                  *
  55                  * @param buf Buffer of data to be written.
  56                  *
  57                  * @param len Length of data to be written.
  58                  *
  59                  */
  60                 int write(const void * buf, int len)
  61                 {
  62                         return _write((char *)buf, len);
  63                 }
  64
  65                 /**
  66                  * Read data from the buffer.
  67                  *
  68                  * @param buf Buffer to store data.
  69                  *
  70                  * @param len Size of buffer to store data.
  71                  *
  72                  */
  73                 int read(char * buf, int len)
  74                 {
  75                         return _read(buf, len);
  76                 }
  77
  78         /* protected: */
  79                 /* virtual */
  80                 void _readcb_handler()
  81                 {
  82                         (*_readcb)(_bufferevent, _arg);
  83                 }
  84
  85                 /* virtual */
  86                 void _writecb_handler()
  87                 {
  88                         (*_writecb)(_bufferevent, _arg);
  89                 }
  90
  91                 /* virtual */
  92                 void _errorcb_handler(short what)
  93                 {
  94                         (*_errorcb)(_bufferevent, what, _arg);
  95                 }
  96
  97         protected:
  98                 EvBufferEvent() { }
  99
 100         /* private: */
 101                 readwritecb _readcb, _writecb;
 102                 errorcb _errorcb;
 103                 void * _arg;
 104 };
 105
 106 #endif // _EV_BUFFER_EVENT__HPP_
 107
 108 // vim: set filetype=cpp :