WsfDisInput.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company.
// ****************************************************************************
 
#ifndef WSFDISINPUT_HPP
#define WSFDISINPUT_HPP
 
#include <map>
#include <set>
#include <string>
#include <vector>
 
class DisBeam;
class DisSystem;
#include "DisEntityId.hpp"
#include "DisEntityType.hpp"
class UtInput;
#include "WsfComponentList.hpp"
#include "WsfDisArticulatedPart.hpp"
#include "WsfDisDevice.hpp"
class WsfDisEmission;
class WsfEM_Xmtr;
#include "ext/WsfExtEntityType.hpp"
class WsfExtInterface;
#include "WsfExtension.hpp"
class WsfScenario;
#include "WsfStringId.hpp"
 
class WsfDisInput;
 
class WSF_EXPORT WsfDisComponent : public WsfComponentT<WsfDisInput>
{
public:
   virtual void PrepareComponent(double aSimTime) {}
   virtual void AddedToDisInterface(WsfDisInterface* aDisInterfacePtr) {}
   virtual bool TransferPlatformToInternalControl(double         aSimTime,
                                                  WsfPlatform*   aPlatformPtr,
                                                  DisEntityId&   aEntityId,
                                                  DisEntityType& aEntityType)
   {
      return false;
   }
   virtual bool TransferPlatformToExternalControl(double aSimTime, WsfPlatform* aPlatformPtr) { return false; }
   virtual void PlatformCreated(WsfDisPlatform* aPlatformPtr) {}
 
   virtual bool UpdateEmissionSystem(WsfPlatform* aPlatformPtr, WsfDisEmission* aEmissionPtr, DisSystem* aSystemPtr)
   {
      return false;
   }
 
   virtual bool AddEmissionSystem(WsfPlatform* aPlatformPtr, WsfDisEmission* aEmissionPtr, DisSystem* aSystemPtr)
   {
      return false;
   }
 
   virtual bool UpdateXmtrFromBeam(WsfDisEmission* aEmissionPtr, DisBeam* aBeamPtr, WsfEM_Xmtr* aXmtrPtr, bool& aBeamOn)
   {
      return false;
   }
};

class WSF_EXPORT WsfDisInput
{
public:
   using Component     = WsfDisComponent;
   using ComponentList = WsfComponentListT<WsfDisComponent>;
 
   struct Articulation
   {
      int         mPartNumber;
      WsfStringId mVariableId;
      WsfStringId mScriptId;
   };
 
   using ArticulationVec = std::vector<Articulation>;
   using ArticulationMap = std::map<WsfStringId, ArticulationVec>;
   struct DeviceConfiguration
   {
      DeviceConfiguration()
         : mDeviceType(WsfDisDevice::cDEVICE_NONE)
         , mRecvPort(0)
         , mSendPort(0)
      {
      }
 
      bool IsComplete();
 
      bool IsInputDevice() const
      {
         return ((mDeviceType == WsfDisDevice::cDEVICE_PLAYBACK) || (mDeviceType >= WsfDisDevice::cDEVICE_MULTICAST));
      }
 
      bool IsOutputDevice() const
      {
         return ((mDeviceType == WsfDisDevice::cDEVICE_RECORD) || (mDeviceType >= WsfDisDevice::cDEVICE_MULTICAST));
      }
 
      bool IsExternalDevice() const { return (mDeviceType >= WsfDisDevice::cDEVICE_MULTICAST); }
 
      bool IsDefined() const { return (mDeviceType != WsfDisDevice::cDEVICE_NONE); }
 
      WsfDisDevice::DeviceType            mDeviceType;
      std::string                         mAddress;
      std::string                         mInterfaceAddress;
      int                                 mRecvPort;
      int                                 mSendPort;
      std::vector<WsfDisFilterAllowance*> mFilterAllowances;
   };
   WsfDisInput();
 
   bool        ProcessInput(WsfScenario& aScenario, UtInput& aInput);
   bool        ProcessBlockInput(WsfScenario& aScenario, UtInput& aInput);
   static bool ValidSignatureTypeName(std::string& aType);

   std::vector<DeviceConfiguration>& GetDeviceConfigurations() { return mDeviceConfigurations; }
   bool ProcessDeviceInput(WsfScenario& aScenario, UtInput& aInput, DeviceConfiguration& aConfiguration);
   bool ProcessFilterAllowance(UtInput& aInput, WsfDisFilterAllowance& aAllowance);

   std::set<std::pair<unsigned short, unsigned short>>& GetIgnoredSiteAndApps() { return mIgnoredSiteAndApps; }
   bool GetIgnoredSiteAndApplicationPair(unsigned int aIndex, std::pair<unsigned short, unsigned short>& aSiteAndAppPair);
   bool IgnoreSiteAndApplication(unsigned short aSite, unsigned short aApp);

   bool IsTerseMode() const { return mTerseMode; }

   bool UseSimpleAccelerations() const { return mUseSimpleAccelerations; }

   bool SuppressNonStandardData() const { return mSuppressNonStandardData; }
 
   bool MultiThreaded() const { return mMultiThreaded; }
 
   bool DebugEnabled() const { return mDebugEnabled; }
 
   void SuppressNonStandardData(bool aDoSupress);
   bool   UseTrackJamForTrackingRequests() { return mUseTrackJamForTrackingRequests; }
   bool   SuppressCME_PassiveSensor() const { return mSuppressCME_PassiveSensor; }
   bool   SuppressCME_EntityData() const { return mSuppressCME_EntityData; }
   bool   SuppressCME_DetectBeam() const { return mSuppressCME_DetectBeam; }
   double GetSensorUpdateInterval() const { return mSensorUpdateInterval; }
   int    GetTimeToLive() const { return mMulticastTimeToLive; }
   const WsfDisArticulatedPart::ArticulationList& GetArticulationList() const { return mArticulationList; }
 
   void                 AddComponent(Component* aComponentPtr) { mComponents.AddComponent(aComponentPtr); }
   const ComponentList& GetComponents() const { return mComponents; }
 
protected:
   bool ProcessArticulatedPart(UtInput& aInput);
 
   using RangeFilteredPlatforms = std::vector<std::tuple<WsfStringId, size_t, double>>; // Name, Id, range
   using NameTypeToStateIdPair  = std::pair<WsfStringId, int>;
   using StringToStateIdPair    = std::pair<std::string, WsfStringId>;
   using StringToStateIdVec     = std::vector<StringToStateIdPair>;
   using IdIdToStringIDMap      = std::map<NameTypeToStateIdPair, StringToStateIdVec>;
   using IdIdToStringIDMapIter  = std::map<NameTypeToStateIdPair, StringToStateIdVec>::iterator;
 
public:
   union
   {
      struct
      {
         bool mMultiThreaded : 1;
         bool mDebugEnabled : 1;
         bool mShadowAll : 1;
         bool mLogCreatedEntities : 1;
         bool mSuppressCommData : 1;
         bool mSuppressEmissionsData : 1;
         bool mSendPeriodicsWhilePaused : 1;
         bool mDebugAppearanceUpdates : 1;
         bool mUsePduTime : 1;
         bool mAutostart : 1;
         bool mUseSimpleAccelerations : 1;
         bool mTerseMode : 1;
         bool mUseSimpleOrientRates : 1;
         bool mJoinExercise : 1;
         bool mUseTrackJamForTrackingRequests : 1;
         bool mSimpleMissReporting : 1;
         bool mDebugThread : 1;
         bool mUseWorldToBodyAngularVelocities : 1;
         bool mZeroBodyAngularVelocities : 1;
         bool mIgnoreStopFreezePDU : 1;


         bool mSuppressCME_DetectBeam : 1;
         bool mSuppressCME_EntityData : 1;
         bool mSuppressCME_DrawData : 1;
         bool mSuppressCME_PassiveSensor : 1;
         bool mUseDeprecatedCME_DrawData : 1;
         bool mSuppressNonStandardData : 1;
      };
      unsigned int mFlags;
   };
   unsigned mMaxBadPDU_Count;
   int      mMulticastTimeToLive;
   double   mThreadSleepTime;
 
protected:
   std::set<WsfStringId>                               mShadowTypeId;
   std::set<WsfStringId>                               mShadowNameId;
   std::vector<DeviceConfiguration>                    mDeviceConfigurations;
   RangeFilteredPlatforms                              mRangeFilteredPlatforms;
   std::set<WsfExtEntityType>                          mIgnoredTypes;
   std::set<DisEnum8>                                  mIgnoredPduTypes;
   std::set<std::pair<unsigned short, unsigned short>> mIgnoredSiteAndApps;
   std::set<std::pair<unsigned short, unsigned short>> mIgnoredKindAndDomain;
   double                                              mInputHeartbeatMultiplier;
   double                                              mSensorUpdateInterval;
   IdIdToStringIDMap mAfterBurnerByName;
   IdIdToStringIDMap mAfterBurnerByType;

   ArticulationMap mArticulationByName;
   ArticulationMap mArticulationByType;
 
   IdIdToStringIDMap mConfigIdByName;
   IdIdToStringIDMap mConfigIdByType;
 
   WsfDisArticulatedPart::ArticulationList mArticulationList;
 
   bool          sDebugEnabled;
   std::set<int> sExcludedPlatformTypes;
 
   ComponentList mComponents;
};
 
#endif