geventhandler.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// ===

#ifndef G_EVENT_HANDLER_H
#define G_EVENT_HANDLER_H

#include "gdef.h"
#include "gnet.h"
#include "gdatetime.h"
#include "gdescriptor.h"
#include <map>
#include <string>

namespace GNet
{
        class EventHandler ;
        class EventHandlerList ;
        class TimerList ;
}

class GNet::EventHandler 
{
public:
        virtual ~EventHandler() ;

        virtual void readEvent() ;

        virtual void writeEvent() ;

        virtual void exceptionEvent() ;

        virtual void onException( std::exception & ) = 0 ;

private:
        void operator=( const EventHandler & ) ; // not implemented
} ;

class GNet::EventHandlerList 
{
public:
        typedef std::map<Descriptor,EventHandler*> Map ;
        typedef Map::const_iterator Iterator ;

public:
        explicit EventHandlerList( const std::string & type ) ;

        void add( Descriptor fd , EventHandler * handler ) ;

        void remove( Descriptor fd ) ;

        bool contains( Descriptor fd ) const ;

        EventHandler * find( Descriptor fd ) ;

        void lock() ; 

        void unlock() ; 

        Iterator begin() const ;

        Iterator end() const ;

        static Descriptor fd( Iterator i ) ;

        static EventHandler * handler( Iterator i ) ;

private:
        EventHandlerList( const EventHandlerList & ) ;
        void operator=( const EventHandlerList & ) ;
        void collectGarbage() ;

private:
        std::string m_type ;
        Map m_map ;
        unsigned int m_lock ;
        bool m_has_garbage ;
} ;

inline
GNet::Descriptor GNet::EventHandlerList::fd( Iterator i )
{
        return (*i).first ;
}

inline
GNet::EventHandler * GNet::EventHandlerList::handler( Iterator i )
{
        return (*i).second ;
}

#endif