multiplexer.h

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

#include "common.h"
#include "listener.h"
#include "publisher.h"
#include "subscriber.h"
#include "utils/functions.h"
#include <map>


#define igs_functor(S,M)   basic::bind(&M, S)
#define igs_function(F)    basic::bind(F)
#define IGS_CONNECT(P,S,M) igs_connect(P,S,igs_functor(S,M))


namespace listener { 

  class EventMultiplexer ;

  /*__LICENCE_HERE__*/

  class IGSLISTENER MultiplexerListener: public Listener {
  public:
    MultiplexerListener(unsigned int priority = 0) ;
    MultiplexerListener(Publisher* p, unsigned int priority = 0) ;
    virtual ~MultiplexerListener() ;

    template <typename E>
    void connect(const basic::function1<void, E*>& f) {multiplexer()->connect<E>(f) ;}

    template <typename E>
    static Listener::ID connect(Publisher* p, Subscriber* s, 
                                const basic::function1<void, E*>& f, 
                                unsigned int priority=0) 
    {
      MultiplexerListener* m = new MultiplexerListener(p, priority) ;
      m->connect(f) ;
      s->add_listener(m) ;
      return m->get_id() ;
    }

    template <typename E1, typename E2>
    static Listener::ID connect(Publisher* p, Subscriber* s, 
                                const basic::function1<void, E1*>& f1, 
                                const basic::function1<void, E2*>& f2,
                                unsigned int priority=0) 
    {
      MultiplexerListener* m = new MultiplexerListener(p,priority) ;
      m->connect(f1) ;
      m->connect(f2) ;
      s->add_listener(m) ;
      return m->get_id() ;
    }

    template <typename E1, typename E2, typename E3>
    static Listener::ID connect(Publisher* p, Subscriber* s, 
                                const basic::function1<void, E1*>& f1, 
                                const basic::function1<void, E2*>& f2,
                                const basic::function1<void, E3*>& f3,
                                unsigned int priority=0) 
    {
      MultiplexerListener* m = new MultiplexerListener(p,priority) ;
      m->connect(f1) ;
      m->connect(f2) ;
      m->connect(f3) ;
      s->add_listener(m) ;
      return m->get_id() ;
    }

    template <typename E>
    static bool disconnect(Publisher* p, Subscriber* s, const basic::function1<void, E*>& f) {
      Subscriber::const_iterator it = s->begin_listeners() ;
      for (; it != s->end_listeners(); it++) {
        MultiplexerListener* ml = dynamic_cast<MultiplexerListener*>(*it) ;
        if (ml && ml->publisher()==p) {
          if (ml->multiplexer()->disconnect(f)) {
            s->remove_listener_with_id(ml->get_id()) ;
            return true ;
          }
        }
      }
      return false ;
    }

    template <typename E>
    static Listener* get_listener(Publisher* p, Subscriber* s, const basic::function1<void, E*>& f) {
      Subscriber::const_iterator it = s->begin_listeners() ;
      for (; it != s->end_listeners(); it++) {
        MultiplexerListener* ml = dynamic_cast<MultiplexerListener*>(*it) ;
        if (ml && ml->publisher()==p) {
          if (ml->multiplexer()->has_function(f)) {
            return ml ;
          }
        }
      }
      return NULL ;
    }

    virtual void dump_listener(std::ostream&, int spaces=0) ;
    
  protected:
    bool process_event(Event* e) ;

  private:
    EventMultiplexer* multiplexer() ;
    EventMultiplexer* multiplexer_ ;
  } ;

  template <typename E>
  Listener::ID igs_connect(Publisher* p, Subscriber* s, 
                           const basic::function1<void, E*>& f, 
                           unsigned int priority=0) 
  {
    return MultiplexerListener::connect(p,s,f,priority) ;
  }

  template <typename E1, typename E2>
  Listener::ID igs_connect(Publisher* p, Subscriber* s, 
                           const basic::function1<void, E1*>& f1, 
                           const basic::function1<void, E2*>& f2,
                           unsigned int priority=0) 
  {
    return MultiplexerListener::connect(p,s,f1,f2,priority) ;
  }

  template <typename E1, typename E2, typename E3>
  Listener::ID igs_connect(Publisher* p, Subscriber* s, 
                           const basic::function1<void, E1*>& f1, 
                           const basic::function1<void, E2*>& f2,
                           const basic::function1<void, E3*>& f3,
                           unsigned int priority=0) 
  {
    return MultiplexerListener::connect(p,s,f1,f2,f3,priority) ;
  }
  
  template <typename E>
  bool igs_disconnect(Publisher* p, Subscriber* s, const basic::function1<void, E*>& f) {
    return MultiplexerListener::disconnect(p,s,f) ;
  }

  template <typename E>
  Listener* igs_get_listener(Publisher* p, Subscriber* s, const basic::function1<void, E*>& f) {
    return MultiplexerListener::get_listener(p,s,f) ;
  }
  



























  // ========================================================

  class IGSLISTENER EventMultiplexer {
  public:
    template <typename E>
    void connect(const basic::function1<void, E*>& f) {c_.bind<E>(f) ;}

    template <typename E>
    bool disconnect(const basic::function1<void, E*>& f) {return c_.disconnect<E>(f);}

    template <typename E>
    bool has_function(const basic::function1<void, E*>& f) {return c_.has_function<E>(f);}

    void proceed(Event* e) ;

    void dump(std::ostream&, int spaces=0) ;
    
  private:
    struct IGSLISTENER caller {
      virtual ~caller() ;
      virtual void call(Event*) = 0 ;
      virtual void dump(std::ostream&, int spaces=0) = 0 ;
    } ;
    
    template <typename E>
    struct real_caller: public caller {
      real_caller(const basic::function1<void, E*>&) ;
      virtual void call(Event* e) ;
      virtual void dump(std::ostream&, int spaces=0) ;
      basic::function1<void, E*> f_ ;
    } ;
    
    class IGSLISTENER Calls {
    public:
      ~Calls() ;
      template <typename E>
      void bind(const basic::function1<void, E*>& f) {v_.push_back(new real_caller<E>(f)) ;}
      template <typename E>
      void call(E* e) {
        for (V::iterator it = v_.begin(); it != v_.end(); it++) {
          (*it)->call(e) ;
        }
      }
      void dump(std::ostream&, int spaces=0) ;
      template <typename E>
      bool disconnect(const basic::function1<void, E*>& f) {
        for (V::iterator it = v_.begin(); it != v_.end(); it++) {
          const real_caller<E>* rc = dynamic_cast<const real_caller<E>*>(*it) ;
          if (rc && (rc->f_ == f)) {
            v_.erase(it) ;
            return true ;
          }
        }
        return false ;
      }
      template <typename E>
      bool has_function(const basic::function1<void, E*>& f) {
        for (V::iterator it = v_.begin(); it != v_.end(); it++) {
          const real_caller<E>* rc = dynamic_cast<const real_caller<E>*>(*it) ;
          if (rc && (rc->f_ == f))
            return true ;
        }
        return false ;
      }
    private:
      typedef std::vector<caller*> V ;
      V v_ ;
    } ;
    
    Calls c_ ;
  } ;



}

#include "inline_src/multiplexer.hxx"
#endif

---