src/net-core/poll.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *   Copyright (C) 2006 David Brodsky                                      *
   4  *                                                                         *
   5  *   This library is free software; you can redistribute it and/or         *
   6  *   modify it under the terms of the GNU Library General Public           *
   7  *   License as published by the Free Software Foundation and appearing    *
   8  *   in the file LICENSE.LGPL included in the packaging of this file.      *
   9  *                                                                         *
  10  *   This library is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU      *
  13  *   Library General Public License for more details.                      *
  14  *                                                                         *
  15  ***************************************************************************/
  16
  17 #ifndef _tairon_net_core_poll_h
  18 #define _tairon_net_core_poll_h
  19
  20 #include <sys/epoll.h>
  21 #include <map>
  22
  23 #include <tairon/core/exceptions.h>
  24 #include <tairon/core/signals.h>
  25
  26 using Tairon::Core::String;
  27
  28 namespace Tairon
  29 {
  30
  31 namespace Net
  32 {
  33
  34 /** \brief I/O event notification facility.
  35  *
  36  * This class provides interface to epoll(7) functionality.
  37  */
  38 class Poll
  39 {
  40         public:
  41                 /** Creates Poll object.
  42                  *
  43                  * \param maxSockets Size of the internal table of descriptors.
  44                  */
  45                 Poll(size_t maxSockets);
  46
  47                 /** Destroys the object.
  48                  */
  49                 ~Poll();
  50
  51                 /** Sets error handler of the socket.
  52                  *
  53                  * \param fd Descriptor of the socket.
  54                  * \param functor Functor that will be called when an socket error
  55                  * occurs.
  56                  */
  57                 void addSocketErrorHandler(int fd, Tairon::Core::Functor0<void> *functor);
  58
  59                 /** Adds socket to be available to read operation.
  60                  *
  61                  * \param fd Descriptor of the socket.
  62                  * \param functor Functor that will be called when the event occurs.
  63                  */
  64                 void addSocketToRead(int fd, Tairon::Core::Functor0<void> *functor);
  65
  66                 /** Adds socket to be available to write operation.
  67                  *
  68                  * \param fd Descriptor of the socket.
  69                  * \param functor Functor that will be called when the event occurs.
  70                  */
  71                 void addSocketToWrite(int fd, Tairon::Core::Functor0<void> *functor);
  72
  73                 /** Deletes error handler associated with a socket.
  74                  *
  75                  * \param fd Descriptor of the socket.
  76                  */
  77                 void delSocketErrorHandler(int fd);
  78
  79                 /** Deletes socket from read event notifications.
  80                  *
  81                  * \param fd Descriptor of the socket to delete.
  82                  */
  83                 void delSocketToRead(int fd);
  84
  85                 /** Deletes socket from write event notifications.
  86                  *
  87                  * \param fd Descriptor of the socket to delete.
  88                  */
  89                 void delSocketToWrite(int fd);
  90
  91                 /** Waits for events to occur.
  92                  *
  93                  * \param timeout Specifies how many miliseconds should this method
  94                  * wait for an event. Specifying a timeout of -1 makes this method wait
  95                  * indefinitely, while specifying a timeout equal to zero makes this
  96                  * method return immediately even if no events are available.
  97                  */
  98                 void poll(int timeout);
  99
 100                 /** Returns pointer to the instance of this class.
 101                  */
 102                 static Poll *self() {
 103                         return pollInstance;
 104                 };
 105
 106         private:
 107                 /** Adds a socket to the epoll.
 108                  *
 109                  * \param fd Descriptor of the socket.
 110                  * \param events Events for polling.
 111                  */
 112                 void addSocket(int fd, uint32_t events);
 113
 114                 /** Changes a socket in the epoll.
 115                  *
 116                  * \param fd Descriptor of the socket.
 117                  * \param events Events for polling.
 118                  */
 119                 void changeSocket(int fd, uint32_t events);
 120
 121                 /** Deletes a socket from the epoll.
 122                  *
 123                  * \param fd Descriptor of the socket.
 124                  */
 125                 void delSocket(int fd);
 126
 127         private:
 128                 /** Epoll descriptor.
 129                  */
 130                 int epfd;
 131
 132                 /** Table of descriptors and their associated error handlers.
 133                  */
 134                 std::map<int, Tairon::Core::Functor0<void> *> errorFunctors;
 135
 136                 /** Buffer for the catched events.
 137                  */
 138                 struct epoll_event *events;
 139
 140                 /** Size of the events array.
 141                  */
 142                 size_t eventsSize;
 143
 144                 /** Holds pointer to the instance of this class.
 145                  */
 146                 static Poll *pollInstance;
 147
 148                 /** Table of descriptors waiting for read.
 149                  */
 150                 std::map<int, Tairon::Core::Functor0<void> *> readFunctors;
 151
 152                 /** Table of descriptors waiting for write.
 153                  */
 154                 std::map<int, Tairon::Core::Functor0<void> *> writeFunctors;
 155
 156 };
 157
 158 /** \brief Exception for poll errors.
 159  */
 160 class PollException : public Tairon::Core::Exception
 161 {
 162         public:
 163                 /** Constructor that takes as parameters description of the exception
 164                  * and its error number.
 165                  */
 166                 PollException(const String &desc, int err) : Tairon::Core::Exception(desc), errorNumber(err) {};
 167
 168                 /** Standard destructor.
 169                  */
 170                 virtual ~PollException() {};
 171
 172                 /** Returns error number of the exception.
 173                  */
 174                 int getErrorNumber() const {
 175                         return errorNumber;
 176                 };
 177
 178         private:
 179                 /** Error number of this exception.
 180                  */
 181                 int errorNumber;
 182 };
 183
 184 }; // namespace Net
 185
 186 }; // namespace Tairon
 187
 188 #endif
 189
 190 // vim: ai sw=4 ts=4 noet fdm=marker