---

EventSender.hh

Go to the documentation of this file.

#ifndef EVENT_SENDER_H
#define EVENT_SENDER_H

#include <list>
#include <typeinfo>
#include <string>
#include <sstream>

#include "Listener.hh" // uses inline
#include "EventFWD.hh"
class PolymorphEvent;

template <typename EvType>
class EventSender
{
    public: // types
        typedef Listener<EvType> TListener;
        
    private: // types
        friend class Listener<EvType>;
        typedef std::list<TListener*> Registry;
    
    public: // static methods
        class IllegalSendError;
        inline static void remove(TListener&);
        inline static void add(TListener&);
        inline static void send(const EvType&);
        inline static bool isSending();
        inline static bool hasListeners();
        inline static unsigned int getNumListeners();
        inline static unsigned int getMinNumIgnored();
        
    private: // construct/destroy singleton
        EventSender(): _isBusySending(false), _eventIgnored(0) {}
        ~EventSender();
        
    private: // methods called by Listener
        void registerListener(TListener*);
        void removeListener(TListener*);
        void incEventIgnored() {_eventIgnored ++;}
        static EventSender<EvType>& instance(); // MUST NOT BE INLINE
        
    private: // utility methods 
        void sendEvent(const EvType&);
        void cleanupQueues();
        bool removeFrom(Registry&, TListener*);
        inline std::string lisnrID(TListener* = NULL) const;
        //bool hasListener(TListener*) const;
    
    private: // data
        Registry _registry;
    
        bool _isBusySending;
        unsigned int _eventIgnored;
        Registry _registrationQueue;
        Registry _removalQueue;
};
        
template <>
class EventSender<PolymorphEvent>
{
    public: 
        static void send(const PolymorphEvent& event)
        {
            event.send();
        }
};

/*  Include IllegalSendError in this header so users don't have 
    to include manually. It has to be included after class definition
    since it is an inner class to EventSender. 
    */
#include "IllegalSendError.hh" 

template<typename EvType>
inline bool 
EventSender<EvType>::hasListeners()
{
    return ! instance()._registry.empty();
}

template<typename EvType>
inline unsigned int 
EventSender<EvType>::getMinNumIgnored() 
{
    return instance()._eventIgnored;
}
       
template<typename EvType>
inline unsigned int 
EventSender<EvType>::getNumListeners() 
{
    return instance()._registry.size();
}
        
template<typename EvType>
inline void 
EventSender<EvType>::send(const EvType& event) 
{
    instance().sendEvent(event);
}

template<typename EvType>
inline bool 
EventSender<EvType>::isSending() 
{
    return instance()._isBusySending;
}

template<typename EvType>
inline void 
EventSender<EvType>::remove(TListener& listener) 
{
    listener.TListener::ignoreEvents();
}

template<typename EvType>
inline void 
EventSender<EvType>::add(TListener& listener) 
{
    listener.TListener::listenForEvents();
}

template<typename EvType>
inline std::string 
EventSender<EvType>::lisnrID(TListener* lisnr)
const 
{
    std::ostringstream lisnrStr;
    lisnrStr << typeid(TListener).name();
    if (lisnr) lisnrStr << ":" << lisnr;
    return lisnrStr.str();
}
            
#ifdef __GNUG__ 
  // because gcc doesn't handle separate template definition
  #include "EventSender.cc"
#endif

#endif // EVENT_SENDER_H

---