vrfStatePropertyPrinter.h

Go to the documentation of this file.

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


#pragma once

class DtExerciseConn;
class DtClock;
class DtReflectedVrfExtEntityList;
class DtReflectedVrfExtAggregateList;
class DtReflectedVrfControlObjectList;
class DtSmsLoader;

#if DtHLA
namespace makVrfVrlinkExtToolkit
{
   class DtReflectedExtendedAttributesObjectList;
   class DtReflectedExtendedAttributesObject;
}
#endif

#include <vl/globalObjectDesignator.h>
#include <vrfExtObjects/controlObjectRepository.h>
#include <readerWriter/propertyUtils.h>
#include <vlutil/vlPrint.h>
#include <vlutil/vlPrintUtil.h>

class DtVrfStatePropertyPrinter
{
private:

   DtVrfStatePropertyPrinter();
   DtVrfStatePropertyPrinter(const DtVrfStatePropertyPrinter& orig);
   DtVrfStatePropertyPrinter& operator=(const DtVrfStatePropertyPrinter& orig);

public:

   DtVrfStatePropertyPrinter(DtExerciseConn* exConn);
   virtual ~DtVrfStatePropertyPrinter();

   virtual bool init(DtSmsLoader* smsLoader);

protected:


   template<class ReflectedObjType, class StateRepType>
   static void objectAddedCallback(ReflectedObjType* object, void* usr);

   template<class ReflectedObjType, class StateRepType>
   void processObjectAdded(ReflectedObjType* object);


   template<class ReflectedObjType, class StateRepType>
   static void objectUpdatedCallback(ReflectedObjType* object, void* usr);

   template<class ReflectedObjType, class StateRepType>
   void processObjectUpdated(ReflectedObjType* object);


   template<class ReflectedObjType, class StateRepType>
   static void objectRemovedCallback(ReflectedObjType* object, void* usr);

   template<class ReflectedObjType, class StateRepType>
   void processObjectRemoved(ReflectedObjType* object);

protected:

   DtExerciseConn* myExConn;
   DtReflectedVrfExtEntityList* myReflectedEntityList;
   DtReflectedVrfExtAggregateList* myReflectedAggregateList;
   DtReflectedVrfControlObjectList* myReflectedControlObjectList;
#if DtHLA
   makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* myReflectedExtendedAttributesList;
#endif
   
   DtClock myClock;
   std::map<DtGlobalObjectDesignator, DtTime> myLastUpdateTimes;
};


template<class StateRepType>
void printStateRepBasicInfo(StateRepType* stateRep)
{
   DtPrintAttribute(DtInfo, "EntityId", stateRep->entityId().string());
   DtPrintAttribute(DtInfo, "EntityType", stateRep->entityType().string());
}

template<>
inline void printStateRepBasicInfo<DtControlObjectRepository>(DtControlObjectRepository* stateRep)
{
   DtPrintAttribute(DtInfo, "EnvironmentProcessId", stateRep->environmentalProcessID().string());
   DtPrintAttribute(DtInfo, "EnvironmentType", stateRep->environmentType().string());
}

template<class ReflectedObjType, class StateRepType>
void DtVrfStatePropertyPrinter::objectAddedCallback(ReflectedObjType* object, void* usr)
{
   static_cast<DtVrfStatePropertyPrinter*>(usr)->
      processObjectAdded<ReflectedObjType, StateRepType>(object);
}

template<class ReflectedObjType, class StateRepType>
void DtVrfStatePropertyPrinter::processObjectAdded(ReflectedObjType* object)
{
   if (object)
   {
      object->addPostUpdateCallback(objectUpdatedCallback<ReflectedObjType, StateRepType>, this);
      myLastUpdateTimes[object->globalId()] = 0;
      processObjectUpdated<ReflectedObjType, StateRepType>(object);
   }
}

template<class ReflectedObjType, class StateRepType>
void DtVrfStatePropertyPrinter::objectUpdatedCallback(ReflectedObjType* object, void* usr)
{
   static_cast<DtVrfStatePropertyPrinter*>(usr)->
      processObjectUpdated<ReflectedObjType, StateRepType>(object);
}

template<class ReflectedObjType, class StateRepType>
void DtVrfStatePropertyPrinter::processObjectUpdated(ReflectedObjType* object)
{
   if (object)
   {
      bool headerPrinted = false;

      DtTime lastUpdateTime = myLastUpdateTimes[object->globalId()];

      StateRepType* sr = dynamic_cast<StateRepType*>(object->stateRep());
      if (sr)
      {
         // Iterate over all attributes, printing only those attributes which have been
         // updated since last we checked
         std::vector<DtReaderWriterRegistryData *>::const_iterator propIter =
            sr->stateProperties().registry().registryData().begin();
         std::vector<DtReaderWriterRegistryData *>::const_iterator propEnd =
            sr->stateProperties().registry().registryData().end();
         for (; propIter != propEnd; ++propIter)
         {
            DtReaderWriter* propRw = (*propIter)->readerWriter();
            if (propRw->wasUpdatedSince(lastUpdateTime))
            {
               DtPropertyInterface* prop = propRw->property();

               if (prop)
               {
                  if (!headerPrinted)
                  {
                     DtInfo << "****************************************" << std::endl;
                     DtInfo << "******  Updated State Properties *******" << std::endl;
                     DtInfo << "****************************************" << std::endl;
                     printStateRepBasicInfo<StateRepType>(sr);

                     headerPrinted = true;
                  }

                  DtInfo << prop->stringRep() << std::endl;
               }
            }
         }
      }

      myLastUpdateTimes[object->globalId()] = myClock.absRealTime();
   }
}

template<class ReflectedObjType, class StateRepType>
void DtVrfStatePropertyPrinter::objectRemovedCallback(ReflectedObjType* object, void* usr)
{
   static_cast<DtVrfStatePropertyPrinter*>(usr)->
      processObjectRemoved<ReflectedObjType, StateRepType>(object);
}

template<class ReflectedObjType, class StateRepType>
void DtVrfStatePropertyPrinter::processObjectRemoved(ReflectedObjType* object)
{
   if (object)
   {
      object->removePostUpdateCallback(objectUpdatedCallback<ReflectedObjType, StateRepType>, this);
   }
}