listener.h

//-*- C++ -*-
//
#ifndef __LISTENER__listener_h__
#define __LISTENER__listener_h__

#include "common.h"
#include "event_filter.h"
#include "event_filtering.h"
#include <list>

//
// INFO: This file contains 2 classes, one concrete (Listener) and one 
//       templated (ListenerForEvent)
//


namespace listener { 

  class SubscriberDeletePtr ;
  class Publisher ;
  class Event ;
  class Subscriber ;

  class IGSLISTENER Listener {
  public:
    typedef unsigned int ID ;

    Listener(unsigned int priority = 0) ;
    Listener(Publisher*, unsigned int priority = 0) ;
    virtual ~Listener() ;

    void set_publisher(Publisher*) ;

    ID get_id() const ;

    unsigned int get_priority() const ;

    void set_priority(unsigned int) ;

    void add_event_filter(EventFilter*) ;

    void add_permanent_event_filter(EventFilter*) ;

    void remove_all_event_filters() ;

    void block_events() ;
    
    void unblock_events() ;

    bool are_events_blocked() const ;

    template <typename LISTENER>
    bool inherits_from() {return dynamic_cast<LISTENER*>(this) != NULL ;}

    virtual void dump_listener(std::ostream&, int spaces=0) ;

    bool operator<(const Listener& l) const ;
    bool operator>(const Listener& l) const ;

  protected:
    Subscriber* subscriber() ;

    Publisher*  publisher() ;

    virtual bool process_event(Event*) = 0 ;

    void dump_infos(std::ostream&, int spaces=0) ;

  private:
    friend class SubscriberDeletePtr ;
    friend class Subscriber ;
    friend class Publisher ;
    typedef std::list<EventFilter_var> Filters ;
    Listener(const Listener&) ;
    void set_subscriber(Subscriber* subscriber) ;
    void unregister() ;
    // \return true if the event was posted
    bool delegate_post(Event* e) ;
    bool accept_event(Event* e) const ;
    Subscriber* subscriber_ ;
    Publisher* publisher_ ;
    Filters event_filters_ ;
    Filters permanent_event_filters_ ;
    bool to_delete_ ;
    ID id_ ;
    bool blocked_ ;
    static ID static_id_ ;
    unsigned int priority_ ;

  } ;


  template <typename EVENT>
  class ListenerForEvent: public Listener {
  public:
    ListenerForEvent(unsigned int priority = 0) ;
    ListenerForEvent(Publisher* p, unsigned int priority = 0) ;
    virtual ~ListenerForEvent() ;

  protected:
    virtual bool process_event(EVENT* e) = 0 ;
    virtual bool process_event(Event* e) ;
  } ;

}

#include "inline_src/listener.hxx"
#endif

---