1

#ifndef NETWORK_REACTOR_HH

     2

#define NETWORK_REACTOR_HH

     3

     4

// forward-declare

     5

class NetworkReactor;

     6

     7

/**

     8

 * Events to poll for

     9

 */

    10

enum NetworkPollBit {

    11

    POLL_READ       = 0x01,

    12

    POLL_WRITE      = 0x02,

    13

};

    14

    15

/**

    16

 * Poll event bitmask of NetworkPollBit's

    17

 */

    18

typedef int NetworkPollMask;

    19

    20

#include "Socket.hh"

    21

#include "Error.hh"

    22

    23

/*

    24

 * Platform-specific includes

    25

 */

    26

#ifndef WIN32

    27

    // linux

    28

    #include <sys/select.h>

    29

#else

    30

    #error "This network code won't compile on win32 :)"

    31

#endif

    32

    33

#include <list>

    34

    35

/**

    36

 * A Reactor manages a set of NetworkSockets, providing readyness notification and a poll method

    37

 */

    38

class NetworkReactor {

    39

    protected:

    40

        std::list<NetworkSocket*> sockets;

    41

    42

    public:

    43

        /**

    44

         * Construct the empty reactor

    45

         */

    46

        NetworkReactor (void);

    47

    48

        /**

    49

         * Our static global reactor

    50

         */

    51

        static NetworkReactor *current;

    52

    53

        /**

    54

         * Add a NetworkSocket to our list of sockets. The desired notification states are fetched directly from the

    55

         * socket itself.

    56

         *

    57

         * @param socket the socket to watch

    58

         */

    59

        void add_socket (NetworkSocket *socket) { sockets.push_back(socket); }

    60

    61

        /**

    62

         * Remove a NetworkSocket from our list of sockets.

    63

         *

    64

         * @param socket the socket to stop watching

    65

         */

    66

        void remove_socket (NetworkSocket *socket) { sockets.remove(socket); }

    67

    68

        /**

    69

         * Poll our sockets and drive any I/O, optionally sleeping for the given timeout. This is efficient if our

    70

         * sockets list is empty.

    71

         */

    72

        void poll (timeval *timeout = NULL);

    73

};

    74

    75

/**

    76

 * Reactor error

    77

 */

    78

class NetworkReactorError : public NetworkErrno {

    79

    public:

    80

        NetworkReactorError (std::string op) : NetworkErrno(op) { }

    81

};

    82

    83

#endif