DtAgentManagerInterface.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2010 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
/****************************************************************************** 
** $RCSfile: DtAgentManagerInterface.h,v $ $Revision: 1.23 $ $State: Exp $ 
******************************************************************************/ 
 
 
#pragma once

#include <vrvCore/vrvCore.h> 
#include <vrvCore/DtUniqueID.h>
#include <vrvUtil/DtMessage.h>

#include <boost/signal.hpp>

#include <list>
#include <map>
#include <string>
#include <vector>

#include <tbb/tbb_allocator.h>
 
namespace makVrv 
{
   class DtMessage;
   class DtAgent;
   class DtAgentFactory;

   class DT_DLL_VRVCORE DtAgentManagerInterface 
   { 
   public:
      //The scene manager (typically will need to interact directly with
      friend class DtAgentManager;

      //Allow base Driver access to Master Scene, used to call protected functions.
      friend class DtAgent;
      
      static const double IgnoreSimulationTime;

      DtAgentManagerInterface(const DtAgentFactory* factory, 
         unsigned char myNamespaceId);

      virtual ~DtAgentManagerInterface();

      inline DtUniqueID createNewUniqueId()     
      {            
         ++myFreeID;
         //Clear most significant byte and place namespace id there.
         return (myFreeID & 0x00FFFFFFFFFFFFFFULL) | (myNamespaceId << 56);
      }

      static inline unsigned char namespaceFromUniqueId(DtUniqueID id)
      {         
         return (unsigned char) (id >> 56);
      }

      unsigned char namespaceId() const;

      inline bool uniqueIdFromAgentManagerInterface(const DtUniqueID& id) const
      {
         return namespaceId() == DtAgentManagerInterface::namespaceFromUniqueId(id);
      }

      inline unsigned int createNewCallID()
      {
         return ++myUpdateCallIndex;
      }

      virtual DtAgent* createNewObject(const std::string& objectClass, bool bDistribute);

      virtual void recreateObject(DtAgent* proxy);

      bool encodeUpdate( DtMessage& masterMsg, DtMessage& distributedMsg, double simulationTime );

      virtual void tick() = 0;
      
   protected:

      void deleteObject(DtAgent*);

      void queueObjectForUpdate(DtAgent* object);

   protected:

      struct IndexedMessage
      {
         unsigned int index;
         DtMessage message;
         bool distributeMessage;

         static inline bool sortCriteria(const IndexedMessage& a, const IndexedMessage& b)
         {
            return a.index < b.index;
         }
      };

      typedef std::list<IndexedMessage, tbb::tbb_allocator<IndexedMessage> > OrderedCallList;

      
      typedef std::list<DtAgent*> AgentList;

      DtUniqueID myNamespaceId;
      DtUniqueID myFreeID;
      unsigned int myUpdateCallIndex;
      AgentList myUpdatedObjects;
      AgentList myToBeDeletedObjects;
      //Pointer to constant Driver Factory.
      const DtAgentFactory* myDriverFactory;
      OrderedCallList myMasterList;
   }; 
}