DtAgentManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtAgentManagerInterface.h>
#include <vrvUtil/DtLockedBufferedQueue.h>

#include <boost/smart_ptr/detail/atomic_count.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/signals.hpp>
#include <boost/unordered_map.hpp>

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

namespace makVrv
{
   class DtAsynchronousAgentManager;
   class DtCoordinateSystem;
   class DtDe;
   class DtMessage;   
   class DtSceneProctor;
   class DtAgentUpdateResolverInterface;
   class DtAgent;

   class DT_DLL_VRVCORE DtAgentManager : public DtAgentManagerInterface
   {
   public:

      friend class DtAsynchronousAgentManager;

      DtAgentManager(DtDe&);

      virtual ~DtAgentManager();

      virtual void cleanup();

      virtual void tick();

      virtual void updateScene(DtMessage& message); 

      virtual DtAgentUpdateResolverInterface* findUpdater(DtUniqueID id);

      DtElementID findElementId(DtUniqueID id);

      virtual bool sceneObjectIsVisible(DtElementID id) const;

      //@name DtAsynchronousAgentManagerInterfaces related functions.

      virtual DtAsynchronousAgentManager* createAsynchronousManager(const std::string& ownerName);

      void checkForIgLock(bool forceLock = false);

      virtual DtDe& acquireLockedIg();

      virtual void releaseLockedIg();


      inline DtDe& de()
      {
         return myDe;
      }

      void clear();

      boost::signal<void (DtUniqueID id)> signal_objectCreated;

   protected:

      virtual unsigned char acquireNamespaceId(
         DtAsynchronousAgentManager* sceneManagerInterface,
         const std::string& ownerName);

      virtual void releaseNamespaceId(unsigned char nsId);

      struct MessageParcel
      {

      public:

         MessageParcel()
            : message(0)
            , distribute(false)
         {        
         }

         bool distribute;
         DtMessage* message;

      };

      typedef std::vector<MessageParcel> MessageParcelVector;

      virtual void addAsynchronousUpdateMessages(MessageParcelVector& messages);

      typedef std::vector<DtMessage*> MessageList;

      void distributeAndUpdate( MessageList& masterMessages, MessageList& distributedMessages );

      virtual void localEncodeAndUpdateScene();

      virtual void createObject(const std::string& className, DtUniqueID id);

      virtual void updateObject(DtUniqueID id,DtMessage& msg, unsigned int updatesize);

      virtual void destroyObject(DtUniqueID id);

   protected:

      typedef boost::function< void (DtAgentManagerInterface*) > 
         AgentManagerInterfaceFunction;

      typedef DtLockedBufferedQueue<AgentManagerInterfaceFunction> 
         AsynchronousAgentManagerInterfaceFunctionQueue;      
      struct AsynchronousInterfaceEntry
      {
         //Local copy.
         std::string name;
         //Used to pass functions to be executed on the asynchronous interface.
         AsynchronousAgentManagerInterfaceFunctionQueue* asyncFunctionQueue;
      };

      typedef boost::unordered_map<DtUniqueID,AsynchronousInterfaceEntry> NamespaceMap;
      typedef boost::unordered_map<DtUniqueID,DtAgentUpdateResolverInterface*> UpdaterMap;
      typedef std::vector<DtAgent*> DriverVector;


      DtDe& myDe;

      UpdaterMap myUpdaterMap;
      std::pair<DtUniqueID,DtAgentUpdateResolverInterface*> myLastObjectCache;
      DtSceneProctor* mySceneProctor;
      DtLockedBufferedQueue< MessageParcel > myAsynchronousMessageQueue;
      NamespaceMap myNamespaceMap;
      unsigned char myNextValidNamespaceIdGuess;

      boost::detail::atomic_count myAtomicWaitingCount;
      boost::condition myRequestIgCondition;
      boost::condition myReleaseIgCondition;
      boost::mutex myMonitor;

      //Force checking the asynchronous messages.
      bool myForceCheckAysncMessages;

   };

   class DT_DLL_VRVCORE DtSceneManagerCreator : public DtVirtualBaseClass
   {

   public:
      static DtSceneManagerCreator& instance(DtDe& theIG);

      static void registerInstance(DtDe& theIG,DtSceneManagerCreator* anInstance);     

      virtual DtAgentManager* create(DtDe&);
   };

}