/home/vlg/develop/libASSA/libassa/assa/EventHandler.h

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                            EventHandler.h
//------------------------------------------------------------------------------
//  Copyright (C) 1997-2002,2005  Vladislav Grinchenko
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//---------------------------------------------------------------------------
#ifndef _EventHandler_h
#define _EventHandler_h

#include "assa/Assure.h"

namespace ASSA {

typedef unsigned long TimerId;

enum EventType
{   
    READ_EVENT    = 0x01,   
    WRITE_EVENT   = 0x02,   
    EXCEPT_EVENT  = 0x04,   
    TIMEOUT_EVENT = 0x10,   
    SIGNAL_EVENT  = 0x20,   
    RWE_EVENTS    = 0x07,   
    ALL_EVENTS    = 0x37    
};

inline 
bool isReadEvent (EventType e_) 
{     
    return (e_ & READ_EVENT) == READ_EVENT;
}

inline 
bool isWriteEvent (EventType e_) 
{
    return (e_ & WRITE_EVENT) == WRITE_EVENT;
}

inline 
bool isExceptEvent (EventType e_) 
{
    return (e_ & EXCEPT_EVENT) == EXCEPT_EVENT;
}

inline
bool isTimeoutEvent (EventType e_) 
{
    return (e_ & TIMEOUT_EVENT) == TIMEOUT_EVENT;
}

inline
bool isSignalEvent (EventType e_) 
{
    return (e_ & SIGNAL_EVENT) == SIGNAL_EVENT;
}

inline 
bool isRWEEvents (EventType e_) 
{
    return isReadEvent (e_) && isWriteEvent (e_) && isExceptEvent (e_);
}

inline 
bool isAllEvents (EventType e_) 
{
    return isReadEvent (e_) && isWriteEvent (e_) && isExceptEvent (e_) &&
        isSignalEvent (e_) && isTimeoutEvent (e_) ;
}

class EventHandler
{
public:
    EventHandler();

    virtual ~EventHandler () { /* no-op */ }

    virtual int handle_read (int fd);

    virtual int handle_write (int fd);

    virtual int handle_except (int fd);

    virtual int handle_timeout (TimerId tid);

    virtual int handle_signal (int signum_); 

    virtual int handle_close (int fd);

    virtual void resetState (void);

    void set_id (const std::string& id_) { m_id = id_; }

    std::string get_id () const { return m_id; }

protected:
    std::string m_id;           
};

inline
EventHandler::
EventHandler() : m_id ("EventHandler")
{
    trace_with_mask("EventHandler::EventHandler",REACTTRACE);
}

inline int 
EventHandler::
handle_read (int /* fd */)
{
    trace_with_mask("EventHandler::handle_read",REACTTRACE);
    return -1;
}

inline int 
EventHandler::
handle_write (int /* fd */)
{
    trace_with_mask("EventHandler::handle_write",REACTTRACE);
    return -1;
}

inline int 
EventHandler::
handle_except (int /* fd */)
{
    trace_with_mask("EventHandler::handle_except",REACTTRACE);
    return -1;
}

inline int 
EventHandler::
handle_timeout (TimerId /* timer_id */)
{
    trace_with_mask("EventHandler::handle_timeout",REACTTRACE);
    return -1;
}

inline int 
EventHandler::
handle_signal (int /* signum_ */) 
{
    trace_with_mask("EventHandler::handle_signal",REACTTRACE);
    return -1;
}

inline int 
EventHandler::
handle_close (int /* fd */)
{
    trace_with_mask("EventHandler::handle_close",REACTTRACE);
    return -1;
}

inline void 
EventHandler::
resetState (void) 
{
    trace_with_mask("EventHandler::reset",REACTTRACE);
}

typedef int (EventHandler::*EH_IO_Callback) (int);

} // end namespace ASSA

#endif // _EventHandler_h

---