PhxListeners.h

Go to the documentation of this file.

#ifndef PHX_LISTENERS_H
#define PHX_LISTENERS_H

#include <map>
#include <Phx/PhxConfig.h>
#include <Phx/PhxTypes.h>

namespace Phx {

  template <class Notifier, class Listener>
  class BaseListener : public LockedPtrInterface<BaseListener<Notifier, Listener> > {
  public:
    class Manager;
    
    BaseListener(void) : mNotifier(0) {
    }

    virtual ~BaseListener(void) {
      if (mNotifier) {
        std::clog << "Deleting a listener without uninstalling." << std::endl;
      }
    }

  protected:
    
    Notifier* notifier(void) { return mNotifier; }

  private:
    // no copy or assignment
    BaseListener(BaseListener<Notifier, Listener>&);
    BaseListener<Notifier, Listener>&
      operator=(BaseListener<Notifier, Listener>&);
    
    friend class Manager;
    void setNotifier(Notifier* notifier) {
      mNotifier = notifier;
    }

    Notifier*  mNotifier;
  };

  template<class Notifier, class Listener>
  class BaseListener<Notifier, Listener>::Manager {
    typedef BaseListener<Notifier, Listener>  BaseListener;
  public:
    
    Manager(Notifier* notifier) : mListener(0), mNotifier(notifier) {
      if (mNotifier == 0) {
        std::clog << "Cannot create listener "
                  << "manager without notifier." << std::endl;
        throw InternalException(); // lame
      }
    }

    virtual ~Manager() {
      if (mListener) {
        // Setting notifier is okay since manager is not calling back
        // the listener at this time and the client has been told that
        // the notifier attribute is only safe then.
        ((BaseListener*)mListener)->setNotifier(0);
      }
    }

    void listener(Listener* listener) {
      // If listener already has a notifier that isn't the same as
      // ours, throw an exception.
      if (listener &&
          ((BaseListener*)listener)->notifier() != mNotifier &&
          ((BaseListener*)listener)->notifier() != 0) {
        std::clog << "Cannot install listener into a second notifier." << std::endl;
        throw PermissionException();
      }

      // If we have an existing listener, set its notifier() to 0.
      if (mListener) ((BaseListener*)mListener)->setNotifier(0);

      if (listener) {
        // Set listener's notifier() attribute
        ((BaseListener*)listener)->setNotifier(mNotifier);
      }

      // Set our listener attribute
      mListener = listener;
    }

    Listener* listener(void) { return mListener; }

  private:
    // no copy or assignment
    Manager(Manager&);
    Manager& operator=(Manager&);

    Listener* mListener;
    Notifier* mNotifier;
  };


  template <class Notifier, class Listener, class Selector>
  class BaseMultiListener : public LockedPtrInterface<BaseMultiListener<Notifier, Listener, Selector> > {
  public:
    class Manager;

    BaseMultiListener(void) : mNotifier(0) {}

    virtual ~BaseMultiListener(void) {
      if (mNotifier) {
        std::clog << "Deleting a multi-listener without uninstalling." << std::endl;
      }
    }

  protected:
    Notifier* notifier(void) { return mNotifier; }
    const Notifier* notifier(void) const { return mNotifier; }

  private:
    // no copy or assignment
    BaseMultiListener(BaseMultiListener<Notifier, Listener, Selector>&);
    BaseMultiListener<Notifier, Listener, Selector>& 
    operator=(BaseMultiListener<Notifier, Listener, Selector>&);
    
    friend class Manager;
    void setNotifier(Notifier* notifier) {
      mNotifier = notifier;
    }

    Notifier* mNotifier;
  };
  
  template<class Notifier, class Listener, class Selector>
  class BaseMultiListener<Notifier, Listener, Selector>::Manager {
  public:
    typedef BaseMultiListener<Notifier, Listener, Selector>  BaseListener;
    typedef std::map<Selector, Listener*> ListenerMapType;
    typedef typename ListenerMapType::iterator Iterator;
    typedef typename ListenerMapType::value_type ValueType;

    Manager(Notifier* notifier) : mNotifier(notifier) {
      if (notifier == 0) {
        std::clog << "Cannot create multi-listener "
                  << "manager without notifier." << std::endl;
        throw InternalException(); // lame
      }
    }

    virtual ~Manager() {
      for (Iterator itr = begin(); itr != end();  ++itr) {
        if (itr->second) ((BaseListener*)(itr->second))->setNotifier(0);
      }
    }

    Iterator begin() { return mListeners.begin(); }
    Iterator end() { return mListeners.end(); }

    void listener(Selector selector, Listener* listener) {
      // @optimization This code implements idempotency in an
      // inefficient way by first removing, then reinserting the
      // listener.

      if (listener) {
        // Listener is non-null -- put it into the collection.
        if (((BaseListener*)listener)->notifier() != mNotifier &&
            ((BaseListener*)listener)->notifier() != 0) {
          std::clog << "Cannot install listener into a second notifier." << std::endl;
          throw PermissionException();
        }

        // First remove any existing listener for this selector
        Manager::listener(selector, 0);

        // Update listener's notifier() attribute
        ((BaseListener*)listener)->setNotifier(mNotifier);
        // Insert into listeners list with given selector
        mListeners.insert(ValueType(selector, listener));
      } else {
        // listener == 0 means erase element with given selector.
        Iterator itr = mListeners.find(selector);
        if (itr != mListeners.end()) {
          // set notifier of old listener to 0
          itr->second->setNotifier(0);
          // remove the listener from the collection
          mListeners.erase(itr);
        } // else, do nothing (required by idempotence).
      }
    }

    Listener* listener(Selector selector) {
      Iterator itr = mListeners.find(selector);
      if (itr != mListeners.end()) {
        return itr->second;
      }
      return 0;
    }

  private:
    // no copy or assignment
    Manager(Manager&);
    Manager& operator=(Manager&);

    ListenerMapType   mListeners;
    Notifier*         mNotifier;
  };

}; // namespace Phx

#endif /* PHX_LISTENERS_H */

---