---

pubsub.hpp

См. документацию.

/*
 * Copyright (C) Sergey P. Derevyago, 2003-2004.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#ifndef __PUBSUB_HPP__
 #define __PUBSUB_HPP__

#include <list>

namespace PubSub_private {

 struct PubImpl {
        typedef std::list<void*> list_type;
        list_type subs;

        bool subscribe(void* sub);

        bool unsubscribe(void* sub);

        bool isSubscribed(void* sub) const;

        int subCount() const { return subs.size(); }
 };

}

template<class M> class Subscriber;

template<class M>
class Publisher {
      friend class Subscriber<M>;

      PubSub_private::PubImpl impl;

      Publisher(const Publisher&);
      Publisher& operator=(const Publisher&);

 public:
      Publisher() {}

      virtual ~Publisher();

      bool subscribe(Subscriber<M>& sub);

      bool unsubscribe(Subscriber<M>& sub);

      bool isSubscribed(Subscriber<M>& sub) const
      {
       return impl.isSubscribed(&sub);
      }

      int subCount() const { return impl.subCount(); }

      int send(const M& msg);
};

template<class M>
class Subscriber {
      friend class Publisher<M>;

      typedef typename std::list<Publisher<M>*> list_type;
      list_type pubs;

      Subscriber(const Subscriber&);
      Subscriber& operator=(const Subscriber&);

 public:
      Subscriber() {}

      virtual ~Subscriber();

      virtual bool regularMsg(const Publisher<M>& pub, const M& msg);

      virtual void subscribedMsg(const Publisher<M>& pub);

      virtual void unsubscribedMsg(const Publisher<M>& pub);
};

template<class M>
Publisher<M>::~Publisher()
{
 for (PubSub_private::PubImpl::list_type::const_iterator cit=impl.subs.begin(),
      cend=impl.subs.end(); cit!=cend; ++cit) {
     Subscriber<M>* psub=static_cast<Subscriber<M>*>(*cit);
     psub->pubs.remove(this);

     try { psub->unsubscribedMsg(*this); }
     catch (...) {}  // игнорируем
 }
}

template<class M>
bool Publisher<M>::subscribe(Subscriber<M>& sub)
{
 bool ret=impl.subscribe(&sub);

 if (ret) {
    sub.pubs.push_back(this);

    try { sub.subscribedMsg(*this); }
    catch (...) {}  // игнорируем
 }

 return ret;
}

template<class M>
bool Publisher<M>::unsubscribe(Subscriber<M>& sub)
{
 bool ret=impl.unsubscribe(&sub);

 if (ret) {
    sub.pubs.remove(this);

    try { sub.unsubscribedMsg(*this); }
    catch (...) {}  // игнорируем
 }

 return ret;
}

template<class M>
int Publisher<M>::send(const M& msg) 
{
 int count=0;
 for (PubSub_private::PubImpl::list_type::iterator it=impl.subs.begin(),
      end=impl.subs.end(); it!=end; count++) {
     Subscriber<M>* psub=static_cast<Subscriber<M>*>(*it);

     bool ret=1;
     try { ret=psub->regularMsg(*this, msg); }
     catch (...) {}  // игнорируем

     ++it;
     if (!ret) unsubscribe(*psub);
 }

 return count;
}

template<class M>
Subscriber<M>::~Subscriber()
{
 for (typename list_type::const_iterator cit=pubs.begin(), cend=pubs.end();
      cit!=cend; ++cit) {
     (*cit)->impl.unsubscribe(this);
 }
}

template<class M>
bool Subscriber<M>::regularMsg(const Publisher<M>&, const M&)
{
 return 1;
}

template<class M>
void Subscriber<M>::subscribedMsg(const Publisher<M>&)
{
}

template<class M>
void Subscriber<M>::unsubscribedMsg(const Publisher<M>&)
{
}

#endif

---