subscriber.h

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

#include "common.h"
#include "listener.h"
#include <list>


#define igs_add_listener(PUB, LIS, FUNC) add_listener( new LIS(PUB, FUNC)) ;

namespace listener { 

  class MultiplexerListener ;
  class Publisher ;

  class IGSLISTENER Subscriber {
  public:
    Subscriber() ;
    virtual ~Subscriber() ;
    
    Listener::ID add_listener(Listener* l) ;

    bool remove_listener_with_id(const Listener::ID& id) ;

    void remove_all_listener() ;

    void add_event_filter(Listener::ID, EventFilter*) ;

    void add_event_filter(EventFilter*) ;
    
    void remove_all_event_filters() ;

    Listener* get_listener_with_id(const Listener::ID&) const ;

    void block_events() ;
    
    void unblock_events() ;

    bool are_events_blocked() const ;

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

  protected:
    Publisher* get_source() ;

    template <typename LISTENER>
    Listener::ID register_listener() {return add_self_listener(dynamic_cast<LISTENER*>(this)) ;}

  private:
    friend class Publisher ;
    friend class MultiplexerListener ;
    typedef std::list<Listener*> Listeners ;
    typedef Listeners::const_iterator const_iterator ;
    typedef std::list<EventFilter_var> Filters ;
    const_iterator begin_listeners() const {return listeners_.begin() ;}
    const_iterator end_listeners() const {return listeners_.end() ;}
    Listener::ID add_self_listener(Listener* l) ;
    bool remove_listener_with_id_no_delegate(const Listener::ID& id) ;
    Listeners listeners_ ;
    Filters event_filters_ ;
    Publisher* source_ ; // only available when receiving an event
    bool blocked_ ;

  } ;


  inline Publisher* Subscriber::get_source() {
    return source_ ;
  }

  inline bool Subscriber::are_events_blocked() const {
    return blocked_ ;
  }

}

#endif

---