publisherList.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2014 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/

#pragma once


#include "managedInterface/delegate.h"

#include <map>

template <typename Publisher>
class DtPublisherList
{
public:
   typedef DtDelegate<void, Publisher*> DtPublisherListDelegate;

   DtPublisherList()
   {

   }

   ~DtPublisherList()
   {
      clear();
   }

   void tick()
   {
      typename std::map<std::string, Publisher*>::iterator iter=myPublishers.begin();
      for(iter; iter!=myPublishers.end(); ++iter)
      {
         iter->second->tick();
      }
   }

   void add(Publisher* pub)
   {
      myPublishers[pub->globalId().string()] = pub;
      typename std::list<DtPublisherListDelegate*>::iterator iter=myAddedDelegates.begin();
      for(iter; iter!=myAddedDelegates.end(); ++iter)
      {
         (*(*iter))(pub);
      }
   }
   void add(Publisher* pub, const std::string& id)
   {
      myPublishers[id] = pub;
      typename std::list<DtPublisherListDelegate*>::iterator iter = myAddedDelegates.begin();
      for (iter; iter != myAddedDelegates.end(); ++iter)
      {
         (*(*iter))(pub);
      }
   }

   void remove(Publisher* pub)
   {
      myPublishers.erase(pub->globalId().string());
      typename std::list<DtPublisherListDelegate*>::iterator iter=myRemovedDelegates.begin();
      for(iter; iter!=myRemovedDelegates.end(); ++iter)
      {
         DtPublisherListDelegate* del=(*iter);
         (*del)(pub);
      }
   }

   void remove(const std::string& id)
   {
      Publisher* pub = myPublishers[id];
      myPublishers.erase(id);
      typename std::list<DtPublisherListDelegate*>::iterator iter = myRemovedDelegates.begin();
      for (iter; iter != myRemovedDelegates.end(); ++iter)
      {
         DtPublisherListDelegate* del = (*iter);
         (*del)(pub);
      }
   }

   Publisher* find(std::string id)
   {
      Publisher* result = NULL;
      typename std::map<std::string, Publisher*>::iterator pubIter;
      pubIter = myPublishers.find(id);
      if (pubIter != myPublishers.end())
      {
         result = myPublishers[id];
      }
      return result;
   }

   void addPublisherAddedDelegate(DtPublisherListDelegate* del)
   {
      myAddedDelegates.push_back(del);
   }

   void removePublisherAddedDelegate(DtPublisherListDelegate* del)
   {
      myAddedDelegates.remove(del);
   }

   void addPublisherRemovedDelegate(DtPublisherListDelegate* del)
   {
      myRemovedDelegates.push_back(del);
   }

   void removePublisherRemovedDelegate(DtPublisherListDelegate* del)
   {
      myRemovedDelegates.remove(del);
   }

   typename std::map< std::string, Publisher* >::iterator begin()
   {
      return myPublishers.begin();
   }
   
   typename std::map< std::string, Publisher*>::iterator end()
   {
      return myPublishers.end();
   }

   void clear()
   {
      typename std::map<std::string, Publisher*>::iterator iter=myPublishers.begin();
      for(iter; iter!=myPublishers.end(); ++iter)
      {
         delete (iter->second);
      }
      myPublishers.clear();

      typename std::list<DtPublisherListDelegate*>::iterator iter2=myAddedDelegates.begin();
      for(iter2; iter2!=myAddedDelegates.end(); ++iter2)
      {
         delete (*iter2);
      }
      myAddedDelegates.clear();

      typename std::list<DtPublisherListDelegate*>::iterator iter3=myRemovedDelegates.begin();
      for(iter3; iter3!=myRemovedDelegates.end(); ++iter3)
      {
         delete (*iter3);
      }
      myRemovedDelegates.clear();
   }

protected:
   typename std::map< std::string, Publisher*> myPublishers;
   std::list<DtPublisherListDelegate*> myAddedDelegates;
   std::list<DtPublisherListDelegate*> myRemovedDelegates;
};