DtSimObjectEntryCollection.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2009 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/
/******************************************************************************
** $RCSfile: DtSimObjectEntryCollection.h,v $ $Revision: 1.10 $ $State: Exp $
******************************************************************************/


#ifndef DtSimObjectEntryCollection_H_
#define DtSimObjectEntryCollection_H_

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtDe.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtSimObjectEntry.h>
#include <vrvCore/DtDataBank.h>
#include <vrvCore/DtStateView.h>
#include <boost/bind.hpp>

namespace makVrv
{
   template<class T>
   class DtSimObjectEntryCollection
   {

   public:

      typedef std::map<DtUniqueID, DtSimObjectEntry*> SimObjectEntryMap;

      DtSimObjectEntryCollection(DtDe& de);

      virtual ~DtSimObjectEntryCollection();

      size_t size() const;

      const SimObjectEntryMap& simObjectEntryMap() const;

      const DtSimObjectEntry* findSimObjectEntry(DtUniqueID id) const;

      boost::signal<void (DtSimObjectEntry&)> signal_simObjectEntryAdded;

      boost::signal<void (DtSimObjectEntry&)> signal_simObjectEntryAboutToBeRemoved;

   protected:

      void onSimObjectEntryAdded(DtSimObjectEntry& entry);

      void onSimObjectEntryAboutToBeRemoved(DtSimObjectEntry& entry);

      bool isCompatible(DtSimObjectEntry& entry);

      void populateFromExistingEntries();

   private:
      DtSimObjectEntryCollection();
      DtSimObjectEntryCollection(const DtSimObjectEntryCollection&);
      DtSimObjectEntryCollection& operator=(const DtSimObjectEntryCollection&);

   protected:

      DtDe& myDe;
      SimObjectEntryMap mySimObjectEntryMap;

   };

   template<class T>
   DtSimObjectEntryCollection<T>::DtSimObjectEntryCollection(DtDe& de)
   : myDe(de)
   , mySimObjectEntryMap()
   {
      myDe.dataBank().simData().signal_simObjectEntryAdded.connect(boost::bind(
         &DtSimObjectEntryCollection<T>::onSimObjectEntryAdded, this, _1));

      myDe.dataBank().simData().signal_simObjectEntryToBeRemoved.connect(boost::bind(
         &DtSimObjectEntryCollection<T>::onSimObjectEntryAboutToBeRemoved, this, _1));

      myDe.dataBank().simData().signal_simStateAdded.connect(boost::bind(
         &DtSimObjectEntryCollection<T>::onSimObjectEntryAdded, this, _1));

      myDe.dataBank().simData().signal_simStateToBeRemoved.connect(boost::bind(
         &DtSimObjectEntryCollection<T>::onSimObjectEntryAboutToBeRemoved, this, _1));

      populateFromExistingEntries();
   }

   template<class T>
   DtSimObjectEntryCollection<T>::~DtSimObjectEntryCollection()
   {
      myDe.dataBank().simData().signal_simObjectEntryAdded.disconnect(boost::bind(
         &DtSimObjectEntryCollection<T>::onSimObjectEntryAdded, this, _1));

      myDe.dataBank().simData().signal_simObjectEntryToBeRemoved.disconnect(boost::bind(
         &DtSimObjectEntryCollection<T>::onSimObjectEntryAboutToBeRemoved, this, _1));

      myDe.dataBank().simData().signal_simStateAdded.disconnect(boost::bind(
         &DtSimObjectEntryCollection<T>::onSimObjectEntryAdded, this, _1));

      myDe.dataBank().simData().signal_simStateToBeRemoved.disconnect(boost::bind(
         &DtSimObjectEntryCollection<T>::onSimObjectEntryAboutToBeRemoved, this, _1));
   }

   template<class T>
   void DtSimObjectEntryCollection<T>::onSimObjectEntryAdded(DtSimObjectEntry& entry)
   {
      if(isCompatible(entry))
      {
         onSimObjectEntryAboutToBeRemoved(entry);

         mySimObjectEntryMap[ entry.id() ] = &entry;
         signal_simObjectEntryAdded(entry);
      }
   }

   template<class T>
   void DtSimObjectEntryCollection<T>::onSimObjectEntryAboutToBeRemoved(DtSimObjectEntry& entry)
   {
      if(isCompatible(entry))
      {
         SimObjectEntryMap::iterator iter = mySimObjectEntryMap.find(entry.id());
         if(iter != mySimObjectEntryMap.end())
         {
            signal_simObjectEntryAboutToBeRemoved(entry);
            mySimObjectEntryMap.erase(iter);
         }
      }
   } 

   template<class T>
   bool DtSimObjectEntryCollection<T>::isCompatible(DtSimObjectEntry& entry)
   {
      return DtStateView<T>::isCompatible(entry);
   }

   template<class T>
   size_t DtSimObjectEntryCollection<T>::size() const
   {
      return mySimObjectEntryMap.size();
   }

   template<class T>
   void DtSimObjectEntryCollection<T>::populateFromExistingEntries()
   {
      DtSimData::SimEntryMap::const_iterator pos;
      for(pos=myDe.dataBank().simData().simEntryMap().begin(); pos != 
         myDe.dataBank().simData().simEntryMap().end(); ++pos )
      {
         DtSimObjectEntry* pEntry = 0;
         if(pEntry = dynamic_cast<DtSimObjectEntry*>(pos->second))
         {
            onSimObjectEntryAdded(*pEntry);
         }         
      }
   }

   template<class T>
   const typename DtSimObjectEntryCollection<T>::SimObjectEntryMap& 
      DtSimObjectEntryCollection<T>::simObjectEntryMap() const
   {
      return mySimObjectEntryMap;
   }

   template<class T>
   const DtSimObjectEntry* DtSimObjectEntryCollection<T>::findSimObjectEntry(
      DtUniqueID id) const
   {
      DtSimObjectEntry* entry = 0;
      SimObjectEntryMap::const_iterator iter = mySimObjectEntryMap.find(id);
      if(iter != mySimObjectEntryMap.end())
      {
         entry = iter->second;
      }
      return entry;
   }
}

#endif