hlaMessageFactory.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/


#ifndef hlaMessageFactory_H_
#define hlaMessageFactory_H_

#if DtHLA

#include <lgrSim/lgrSim.h>
#include <lgrSim/hlaTimeStampedAttr.h>
#include <lgrSim/lgrHlaAttribute.h>
#include "lgrHlaNetStructures.h"
#include "subscriptionListFile.h"

#include <list>
#include <utility>
#include <vlutil/vlNetTypes.h>

#include <vl/rtiCompatibility.h>
#include <vl/hlaObject.h>

namespace MAKLogger
{

   class DtPacket;
   class DtAbsoluteTime;

#ifdef DtHLA_1516
   typedef DtString DtRegionID;
#else
   typedef RTI::RegionToken DtRegionID;
#endif

   typedef DtSubscriptionListFile::DimensionDesc DtDimensionDesc;
   typedef DtSubscriptionListFile::ExtentDesc DtExtentDesc;
   typedef DtSubscriptionListFile::RegionDesc DtRegionDesc;
   typedef std::set<DtRegionDesc> DtRegionDescSet;
   typedef std::set<DtDimensionDesc> DtDimensionDescSet;
   typedef std::set<DtExtentDesc> DtExtentDescSet;
   typedef std::set<DtRegionID> DtRegionIDSet;
   typedef std::map<DtRegionID,DtDDMRegionSP> DtIDRegionMap;

   class DT_DLL_LGRSIM DtLgrHlaMessageFactory
   {
   public:
      static DtLgrHlaHandle decodeUpdateObjectHandle(const DtPacket* packet);

      static DtLgrHlaHandle decodeRemoveObjectHandle(const DtPacket* packet);

      static void setUpdateObjectHandle(DtPacket* packet,DtLgrHlaHandle handle);

      static void setRemoveObjectHandle(DtPacket* packet,DtLgrHlaHandle handle);

      static DtLgrHlaHandle decodeUpdateObjectClassHandle(const DtPacket* packet);

      static DtLgrHlaHandle decodeRemoveObjectClassHandle(const DtPacket* packet);

      static DtLgrHlaHandle decodeInteractionClassHandle(const DtPacket* packet);

      static void setUpdateObjectClassHandle( DtPacket* packet, DtLgrHlaHandle handle);

      static void setRemoveObjectClassHandle( DtPacket* packet, DtLgrHlaHandle handle);

      static void setInteractionClassHandle( DtPacket* packet,DtLgrHlaHandle handle);

      static const char* decodeUpdateObjectName(const DtPacket* packet,int& length);

      static const char* decodeRemoveObjectName(const DtPacket* packet,int& length);

      static const char* decodeUpdateObjectTag(const DtPacket* packet,int& length);

      static const char* decodeRemoveObjectTag(const DtPacket* packet,int& length);

      static const char* decodeInteractionTag(const DtPacket* packet,int& length);

      static void decodeRegionID( const DtNetDDMRegionHeader *regionHeader, DtRegionID& regionID, unsigned int index /* = 0 */ );

      static bool decodeInteractionRegionID( const DtPacket *packet, DtRegionID& regionID, unsigned int index = 0);

      static bool decodeObjectRegionID( const DtPacket *packet, DtRegionID& regionID, unsigned int index = 0 );

      static void decodeRegionIdSet( const DtNetDDMRegionHeader *regionHeader, unsigned int numRegions, DtRegionIDSet& regionIDSet );

      static unsigned int decodeObjectRegionIdSet( const DtPacket *packet, DtRegionIDSet& regionIDSet );

      static unsigned int decodeInteractionRegionIdSet( const DtPacket *packet, DtRegionIDSet& regionIDSet );

      static DtPacket* encodeUpdate( const DtAbsoluteTime& time,
         DtLgrHlaHandle objectHandle,
         DtLgrHlaHandle classHandle,
         const DtLgrHandleValueReferenceMap& referenceMap,
         const DtString& objectName,
         const DtLgrValueReference& tag );

      static DtPacket* encodeUpdate( const DtAbsoluteTime& time,
         DtLgrHlaHandle objectHandle,
         DtLgrHlaHandle classHandle,
         const DtLgrHandleValueReferenceMap& referenceMap,
         const DtString& objectName,
         const DtLgrValueReference& tag,
         const DtRegionDescSet& regionDescSet );

      static DtPacket* encodeUpdates(const DtAbsoluteTime& time,
         const DtTimedHandleValueMapList& outputList, DtLgrHlaHandle objectHandle,
         DtLgrHlaHandle classHandle, const DtString& objectName);

      static DtTimedHandleValueMapList* decodeUpdates(const DtPacket* packet);

      static DtPacket* encodeRemoval(DtAbsoluteTime time,DtLgrHlaHandle objectId,
         DtLgrHlaHandle classHandle,   DtString name,DtString tag);

      static size_t calculateInteractionSize(
         const DtLgrHandleValueReferenceMap& parameters,
         const DtLgrValueReference& tag);

      static size_t calculateInteractionSize(
         const DtLgrHandleValueReferenceMap& parameters,
         const DtLgrValueReference& tag,
         const DtRegionDescSet& regionDescSet 
      );

      static void encodeInteraction(DtPacket&,
         DtLgrHlaHandle classHandle,
         const DtLgrHandleValueReferenceMap& parameters,
         const DtLgrValueReference& tag
         );

      static void encodeInteraction(DtPacket&,
         DtLgrHlaHandle classHandle,
         const DtLgrHandleValueReferenceMap& parameters,
         const DtLgrValueReference& tag,
         const DtRegionDescSet& regionDescSet
         );

      static std::auto_ptr<DtLgrHandleValueMap> decodeParameterHandleValues(const DtPacket* packet);
      static std::auto_ptr<DtLgrHandleValueReferenceMap> decodeParameterReferences(const DtPacket* packet);

      static void decodeParameterHandles(const DtPacket* packet,std::vector<DtLgrHlaHandle>& handles);
      static void setParameterHandles(DtPacket* packet,const std::vector<DtLgrHlaHandle>& handles);

      static std::auto_ptr<DtLgrHandleValueMap> decodeAttributeHandleValues(const DtPacket* packet);
      static std::auto_ptr<DtLgrHandleValueReferenceMap> decodeAttributeReferences(const DtPacket* packet);

      static void decodeAttributeHandles(const DtPacket* packet,std::vector<DtLgrHlaHandle>& handles);
      static void setAttributeHandles(DtPacket* packet,const std::vector<DtLgrHlaHandle>& handles);

      static DtDDMRegionSP decodeInteractionDDMRegion( const DtPacket *packet,
         const DtExerciseConn *exerciseConn, unsigned int index=0,
         DtIDRegionMap* regionCache=0, bool updateRegionExtents=false);

      static DtDDMRegionSP decodeObjectDDMRegion( const DtPacket *packet,
         const DtExerciseConn *exerciseConn, unsigned int index=0,
         DtIDRegionMap* regionCache=0, bool updateRegionExtents=false);

      static unsigned int decodeInteractionDDMRegionSet( const DtPacket *packet,
         const DtExerciseConn *exerciseConn, DtDDMRegionSet& regionSet,
         DtIDRegionMap* regionCache=0, bool updateRegionExtents=false );

      static unsigned int decodeObjectDDMRegionSet( const DtPacket *packet,
         const DtExerciseConn *exerciseConn, DtDDMRegionSet& regionSet,
         DtIDRegionMap* regionCache=0, bool updateRegionExtents=false );

      static unsigned int decodeInteractionDDMRegionDescSet( const DtPacket *packet,
         DtRegionDescSet& regionSet );

      static unsigned int decodeObjectDDMRegionDescSet( const DtPacket *packet,
         DtRegionDescSet& regionSet );

   protected:


      static NetUpdateRecord* netUpdateRecord(DtPacket* packet);
      static const NetUpdateRecord* netUpdateRecord(const DtPacket* packet);
      static NetRemovalRecord* netRemovalRecord(DtPacket* packet);
      static const NetRemovalRecord* netRemovalRecord(const DtPacket* packet);
      static NetInteractionRecord* netInteractionRecord(DtPacket* packet);
      static const NetInteractionRecord* netInteractionRecord(const DtPacket* packet);

#if DtHLA_1516
      static int bufferSizeOfMap(const RTI::AttributeHandleValueMap& map);
      static int bufferSizeOfMap(const RTI::ParameterHandleValueMap& map);
#else
      static int bufferSizeOfSet(const RTI::ParameterHandleValuePairSet& set);
      static int bufferSizeOfSet(const RTI::AttributeHandleValuePairSet& set);
#endif
      static int bufferSizeOfMap(const DtLgrHandleValueMap& map);
      static int bufferSizeOfMap(const DtLgrHandleValueReferenceMap& map);

      static int bufferSizeOfRegionDimensionSet( const DtDimensionDescSet& set );
      static int bufferSizeOfRegionDescriptorSet( const DtRegionDescSet& set );

      static void getRegionExtents(const char* data,
         DtExtentDescSet& extentSet, unsigned int numExtents, std::set<DtString>* dimensionNameSet=0);

      static bool decodeDDMRegion( const DtNetDDMRegionHeader *regionHeader, DtRegionDesc& regionDesc);

      static void updateRegion(DtDDMRegionSP region, DtExtentDescSet& extentSet);

      static DtDDMRegionSP decodeAndCreateDDMRegion( const DtNetDDMRegionHeader *regionHeader,
         const DtExerciseConn *exerciseConn, DtIDRegionMap* regionCache=0, bool updateRegionExtents=false );

      static bool readFromBufferToMap(DtLgrHandleValueMap& map,
         const void* buffer,unsigned int memorySize, int numItems);

      static bool readFromBufferToMap(DtLgrHandleValueReferenceMap& map,
         const void* buffer,unsigned int memorySize, int numItems);

      static bool readFromMapToBuffer(const DtLgrHandleValueMap& map,
         void* buffer,unsigned int memorySize);

      static bool readFromMapToBuffer(const DtLgrHandleValueReferenceMap& map,
         void* buffer,unsigned int memorySize);

      //static bool readFromRegionSetToBuffer( const DtDimensionDescSet& set,

      static bool readFromRegionSetToBuffer( const DtRegionDescSet& rset,
         void *buffer, unsigned int memorySize );

   };





}

#endif
#endif