---

sue_sel.hpp

Go to the documentation of this file.

#ifndef SENTRY_SUE_SEL_HPP
#define SENTRY_SUE_SEL_HPP



class SUEEventSelector {
    struct TimeoutsListItem {
        TimeoutsListItem *next;
        class SUETimeoutHandler *handler; 
    } *timeouts;
    struct SignalListItem {
        SignalListItem *next;
        class SUESignalHandler *handler;
    } *signalhandlers;

    class SUEFdHandler** fdhandlers;
    int fdhandlerssize;

    bool breakflag;
private:
    void ResizeFdHandlers(int newsize);
public:
    SUEEventSelector();
    virtual ~SUEEventSelector();

    void RegisterFdHandler(SUEFdHandler *h);

    void RemoveFdHandler(SUEFdHandler *h);
       

    void RegisterTimeoutHandler(SUETimeoutHandler *h);

    void RemoveTimeoutHandler(SUETimeoutHandler *h);



    void RegisterSignalHandler(SUESignalHandler *h);
    void RemoveSignalHandler(SUESignalHandler *h);
        
        

    void Go();   

    void Break();
        

    virtual void HandleSelectFailure(int rc) {}
private:
    // several private functions used to decomposite Go()
    struct timeval* ComputeClosestTimeout(struct timeval &timeout);
    void SetupFdSets(struct SelectDescriptorsSet &);
    void HandleSignals();
    void HandleFds(struct SelectDescriptorsSet &);
    void HandleTimeouts(struct timeval &current);
};


class SUEFdHandler {
    friend class SUEEventSelector;
protected:
    int fd;               
public:

    SUEFdHandler(int a_fd = -1); 

    virtual ~SUEFdHandler();


    virtual void FdHandle(bool a_r, bool a_w, bool a_ex) = 0; 


    void SetFd(int a_fd) { fd = a_fd; }



    virtual bool WantRead() const { return true; }

    virtual bool WantWrite() const { return false; }

    virtual bool WantExcept() const { return false; }
};




class SUETimeoutHandler {
    friend class SUEEventSelector;
    long sec;  
    long usec;
public:

    SUETimeoutHandler(long a_sec, long a_usec);


    SUETimeoutHandler();


    virtual ~SUETimeoutHandler();


    void Set(long a_sec, long a_usec);


    void SetFromNow(long a_sec, long a_usec = 0);

    void Get(long &a_sec, long &a_usec) const;

    void GetRemainingTime(long &a_sec, long &a_usec) const;

    bool operator < (const SUETimeoutHandler &other) const
     { return (sec < other.sec)||(sec == other.sec && usec < other.usec); }

    bool IsBefore(long a_sec, long a_usec) const
     { return (sec < a_sec)||(sec == a_sec && usec < a_usec); }
 

    virtual void TimeoutHandle() = 0; 
};





class SUESignalHandler {
    friend class SUEEventSelector;
protected:
    int signo;
public:
    SUESignalHandler(int a_sig) : signo(a_sig) {}
    virtual ~SUESignalHandler() {}

    virtual void SignalHandle() = 0;
};



class SUEException {
    const char *s;
public:
    SUEException(const char* a) : s(a) {}
    SUEException() : s("") {}
    SUEException(const SUEException &e) : s(e.s) {}
    ~SUEException() {}
    const char* Get() { return s; }
};



#endif // sentry

---