stateCacheManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/aggregateState.h>
#include <vrfGuiCore/vrlinkSimulatedEnvironmentProcess.h>
#include <vrfGuiCore/vrlinkSimulatedWeatherState.h>
#include <vrfGuiCore/extendedStateData.h>
#include <vrfGuiCore/vrfObjectDataState.h>

#include <vrvUtil/DtSignalConnectionManager.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)
         {
            myConnectionManager += myProcessor->signal_stateAdded.connect(boost::bind(&DtStateCacheManager::slot_stateAdded, this, _1, _2));
            myConnectionManager += myProcessor->signal_stateUpdated.connect(boost::bind(&DtStateCacheManager::slot_forceUpdateIfModified, this, _1, _2));
            myConnectionManager += myProcessor->signal_stateRemoved.connect(boost::bind(&DtStateCacheManager::slot_stateRemoved, this, _1));
         }

         virtual ~DtStateCacheManager()
         {
         }

         void enable()
         {
            myConnectionManager.blockConnections(false);
         }

         void disable()
         {
            myConnectionManager.blockConnections(true);
         }

         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::DtSimState& incoming)
         {
            const _StateType& state = static_cast<const _StateType&>(incoming);
            myMap[id] = state;
         }

         void slot_forceUpdateIfModified(makVrv::DtUniqueID id,
            const makVrv::DtSimState& incoming)
         {
            const _StateType& state = static_cast<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;
         makVrv::DtSignalConnectionManager     myConnectionManager;
      };

      class VRF_PROTOCOL_EXPORT 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::checkAppearance, 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 checkAppearance(const makVrv::DtVrlinkSimulatedEntityState& newState,
            const makVrv::DtVrlinkSimulatedEntityState& state)
         {
            return (newState.myAppearance != state.myAppearance);
         }
      };

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

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

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

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

      class VRF_PROTOCOL_EXPORT 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 VRF_PROTOCOL_EXPORT DtObjectStateStateCacheManager : public DtStateCacheManager<DtVrfObjectDataState>
      {
      public:
         DtObjectStateStateCacheManager(makVrv::DtSimDataProcessorInterface* i)
         : DtStateCacheManager<DtVrfObjectDataState>(i)
         {
            addIsModifiedCallbackCheck(boost::bind(&DtObjectStateStateCacheManager::checkEchelonId, this, _1, _2));
         }

      protected:
         bool checkEchelonId(const DtVrfObjectDataState& newState,
            const DtVrfObjectDataState& state)
         {
            return (newState.myEchelonIdString != state.myEchelonIdString);
         }
      };

      class VRF_PROTOCOL_EXPORT DtAggregateStateCacheManager : public DtStateCacheManager<DtVrlinkNetworkUpdateSimulatedAggregateState>
      {
      public:
         DtAggregateStateCacheManager(makVrv::DtSimDataProcessorInterface* i)
         : DtStateCacheManager<DtVrlinkNetworkUpdateSimulatedAggregateState>(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::checkAppearance, this, _1, _2));
            addIsModifiedCallbackCheck(boost::bind(&DtAggregateStateCacheManager::checkForceId, this, _1, _2));
         }

      protected:
         bool checkAppearance(const DtVrlinkNetworkUpdateSimulatedAggregateState& newState,
            const DtVrlinkNetworkUpdateSimulatedAggregateState& state)
         {
            return (newState.myAppearance != state.myAppearance);
         }

         bool checkSubAggregates(const DtVrlinkNetworkUpdateSimulatedAggregateState& newState,
            const DtVrlinkNetworkUpdateSimulatedAggregateState& state)
         {
            int numberOfAggs = newState.mySubAggregates.size();
            int curAggLimit = state.mySubAggregates.size();

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

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

            return false;
         }

         bool checkSubEntities(const DtVrlinkNetworkUpdateSimulatedAggregateState& newState,
            const DtVrlinkNetworkUpdateSimulatedAggregateState& state)
         {
            int numberOfAggs = newState.mySubEntities.size();
            int curAggLimit = state.mySubEntities.size();

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

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

            return false;
         }

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

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

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

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

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