DtStateCacheManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/DtAggregateState.h>
#include <vrfGuiCore/DtEnvironmentState.h>
#include <vrfGuiCore/DtIffStateData.h>
#include <vrfGuiCore/DtExtendedStateData.h>

#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtEntityState.h>

#include <vrvCore/DtSimDataProcessorInterface.h>

#include <map>

#include <boost/function.hpp>
#include <boost/bind.hpp>

#include <vlpi/appearance.h>

namespace makVrf
{
   namespace VRF_PROTOCOL_NAMESPACE
   {
      template <typename _StateType>
      class DtStateCacheManager
      {
      public:
         DtStateCacheManager(makVrv::DtSimDataProcessorInterface* iface)
         : myProcessor(iface)
         {
            myProcessor->signal_stateAdded.connect(boost::bind(&DtStateCacheManager::slot_stateAdded, this, _1, _2));
            myProcessor->signal_stateUpdated.connect(boost::bind(&DtStateCacheManager::slot_forceUpdateIfModified, this, _1, _2));
            myProcessor->signal_stateRemoved.connect(boost::bind(&DtStateCacheManager::slot_stateRemoved, this, _1));
         }

         virtual ~DtStateCacheManager()
         {
            myProcessor->signal_stateAdded.disconnect(boost::bind(&DtStateCacheManager::slot_stateAdded, this, _1, _2));
            myProcessor->signal_stateUpdated.disconnect(boost::bind(&DtStateCacheManager::slot_forceUpdateIfModified, this, _1, _2));
            myProcessor->signal_stateRemoved.disconnect(boost::bind(&DtStateCacheManager::slot_stateRemoved, this, _1));
         }

         void addIsModifiedCallbackCheck(const boost::function<bool (const _StateType& newState,
            const _StateType& originalState)>& function)
         {
            myIsModifiedFunctions.push_back(function);
         }

         void slot_stateRemoved(makVrv::DtUniqueID id)
         {
            typename std::map<makVrv::DtUniqueID, _StateType>::iterator iter;
            iter = myMap.find(id);

            if (iter != myMap.end())
            {
               myMap.erase(iter);
            }
         }

         void slot_stateAdded(makVrv::DtUniqueID id,
            const makVrv::DtVrlinkSimulatedBaseState& incoming)
         {
            const _StateType& state = (const _StateType&)incoming;
            myMap[id] = state;
         }

         void slot_forceUpdateIfModified(makVrv::DtUniqueID id,
            const makVrv::DtVrlinkSimulatedBaseState& incoming)
         {
            const _StateType& state = (const _StateType&)incoming;

            typename DtIsModifiedCallList::iterator iter =
               myIsModifiedFunctions.begin();
            typename std::map<makVrv::DtUniqueID, _StateType>::const_iterator
               cacheIter = myMap.find(id);

            while (iter != myIsModifiedFunctions.end())
            {
               if ((*iter)(state, cacheIter->second))
               {
                  myMap[id] = state;
                  myProcessor->forceObjectUpdate(id);
                  return;
               }

               ++iter;
            }
         }

      protected:
         std::map<makVrv::DtUniqueID, _StateType> myMap;
      
         typedef std::vector<boost::function<bool (const _StateType& newState,
            const _StateType& originalState)> > DtIsModifiedCallList;

         DtIsModifiedCallList                  myIsModifiedFunctions;
         makVrv::DtSimDataProcessorInterface*  myProcessor;
      };

      class DtEntityStateCacheManager : public DtStateCacheManager<makVrv::DtVrlinkSimulatedEntityState>
      {
      public:
         DtEntityStateCacheManager(makVrv::DtSimDataProcessorInterface* i)
         : DtStateCacheManager<makVrv::DtVrlinkSimulatedEntityState>(i)
         {
            addIsModifiedCallbackCheck(boost::bind(&DtEntityStateCacheManager::checkParentId, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtEntityStateCacheManager::checkGlobalId, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtEntityStateCacheManager::checkMarkingText, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtEntityStateCacheManager::checkDestroyed, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtEntityStateCacheManager::checkForceId, this, _1, _2));
         }

      protected:
         bool checkParentId(const makVrv::DtVrlinkSimulatedEntityState& newState,
            const makVrv::DtVrlinkSimulatedEntityState& cached) const
         {
            return (newState.myAttachedToId != cached.myAttachedToId);
         }

         bool checkForceId(const makVrv::DtVrlinkSimulatedEntityState& newState,
            const makVrv::DtVrlinkSimulatedEntityState& cached) const
         {
            return (newState.myForce != cached.myForce);
         }

         bool checkMarkingText(const makVrv::DtVrlinkSimulatedEntityState& newState,
            const makVrv::DtVrlinkSimulatedEntityState& cached) const
         {
            return (newState.myMarkingText != cached.myMarkingText);
         }

         bool checkGlobalId(const makVrv::DtVrlinkSimulatedEntityState& newState,
            const makVrv::DtVrlinkSimulatedEntityState& cached) const
         {
            return (newState.myGlobalId != cached.myGlobalId);
         }

         bool checkDestroyed(const makVrv::DtVrlinkSimulatedEntityState& newState,
            const makVrv::DtVrlinkSimulatedEntityState& state)
         {
            DtAppearance app1(DtEntityType(newState.myEntityType.c_str()));

            app1.setAppearance(newState.myAppearance);

            DtAppearance app2(DtEntityType(state.myEntityType.c_str()));

            app2.setAppearance(state.myAppearance);

            bool dest1 = (app1.damageState() == DtDamageDestroyed);
            bool dest2 = (app2.damageState() == DtDamageDestroyed);

            return (dest1 != dest2);
         }
      };

      class DtEnvironmentProcessCacheManager : public DtStateCacheManager<DtVrlinkSimulatedEnvironmentProcess>
      {
      public:
         DtEnvironmentProcessCacheManager(makVrv::DtSimDataProcessorInterface* i)
         : DtStateCacheManager<DtVrlinkSimulatedEnvironmentProcess>(i)
         {
            addIsModifiedCallbackCheck(boost::bind(&DtEnvironmentProcessCacheManager::checkAll, this, _1, _2));
         }

      protected:
         bool checkAll(const DtVrlinkSimulatedEnvironmentProcess& newState,
            const DtVrlinkSimulatedEnvironmentProcess& cached) const
         {
            return (newState != cached);
         }
      };

      class DtExtendedStateDataCacheManager : public DtStateCacheManager<DtExtendedStateData>
      {
      public:
         DtExtendedStateDataCacheManager(makVrv::DtSimDataProcessorInterface* i)
         : DtStateCacheManager<DtExtendedStateData>(i)
         {
            addIsModifiedCallbackCheck(boost::bind(&DtExtendedStateDataCacheManager::checkAll, this, _1, _2));
         }

      protected:
         bool checkAll(const DtExtendedStateData& newState,
            const DtExtendedStateData& cached) const
         {
            return (newState != cached);
         }
      };

      class DtIffStateCacheManager : public DtStateCacheManager<DtIffStateData>
      {
      public:
         DtIffStateCacheManager(makVrv::DtSimDataProcessorInterface* i)
         : DtStateCacheManager<DtIffStateData>(i)
         {
            addIsModifiedCallbackCheck(boost::bind(&DtIffStateCacheManager::checkAll, this, _1, _2));
         }

      protected:
         bool checkAll(const DtIffStateData& newState,
            const DtIffStateData& cached) const
         {
            return (newState.myStateData != cached.myStateData);
         }
      };

      class DtAggregateStateCacheManager : public DtStateCacheManager<DtVrlinkSimulatedAggregateState>
      {
      public:
         DtAggregateStateCacheManager(makVrv::DtSimDataProcessorInterface* i)
         : DtStateCacheManager<DtVrlinkSimulatedAggregateState>(i)
         {
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkParentId, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkGlobalId, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkAggregateState, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkMarkingText, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkSubAggregates, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkSubEntities, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkDestroyed, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkForceId, this, _1, _2));
         }

      protected:
         bool checkDestroyed(const DtVrlinkSimulatedAggregateState& newState,
            const DtVrlinkSimulatedAggregateState& state)
         {
            bool dest1 = (newState.myAppearance == DtDamageDestroyed);
            bool dest2 = (state.myAppearance == DtDamageDestroyed);

            return (dest1 != dest2);
         }

         bool checkSubAggregates(const DtVrlinkSimulatedAggregateState& newState,
            const DtVrlinkSimulatedAggregateState& state)
         {
            int numberOfAggs = newState.mySubAggregates.size();
            int i;
            DtGlobalObjectDesignator id;
            std::string sId;
            int curAggLimit = state.mySubAggregates.size();

            if (numberOfAggs != curAggLimit)
            {
               return true;
            }

            for (i = 0; i < numberOfAggs; i++)
            {
               if (state.mySubAggregates[i] != newState.mySubAggregates[i])
               {
                  return true;
               }
            }

            return false;
         }

         bool checkSubEntities(const DtVrlinkSimulatedAggregateState& newState,
            const DtVrlinkSimulatedAggregateState& state)
         {
            int numberOfAggs = newState.mySubEntities.size();
            int i;
            DtGlobalObjectDesignator id;
            std::string sId;
            int curAggLimit = state.mySubEntities.size();

            if (numberOfAggs != curAggLimit)
            {
               return true;
            }

            for (i = 0; i < numberOfAggs; i++)
            {
               if (state.mySubEntities[i] != newState.mySubEntities[i])
               {
                  return true;
               }
            }

            return false;
         }

         bool checkParentId(const DtVrlinkSimulatedAggregateState& newState,
            const DtVrlinkSimulatedAggregateState& cached) const
         {
            return (newState.myAttachedToId != cached.myAttachedToId);
         }

         bool checkForceId(const DtVrlinkSimulatedAggregateState& newState,
            const DtVrlinkSimulatedAggregateState& cached) const
         {
            return (newState.myForce != cached.myForce);
         }

         bool checkGlobalId(const DtVrlinkSimulatedAggregateState& newState,
            const DtVrlinkSimulatedAggregateState& cached) const
         {
            return (newState.myGlobalId != cached.myGlobalId);
         }

         bool checkMarkingText(const DtVrlinkSimulatedAggregateState& newState,
            const DtVrlinkSimulatedAggregateState& cached) const
         {
            return (newState.myMarkingText != cached.myMarkingText);
         }

         bool checkAggregateState(const DtVrlinkSimulatedAggregateState& newState,
            const DtVrlinkSimulatedAggregateState& cached) const
         {
            return (newState.myAggregateState != cached.myAggregateState);
         }
      };
   }
}