WsfScenario.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.
// ****************************************************************************
 
#ifndef WSFSCENARIO_HPP
#define WSFSCENARIO_HPP
 
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <vector>
 
#include "UtAtmosphere.hpp"
#include "UtCallback.hpp"
#include "UtCast.hpp"
#include "UtColor.hpp"
class UtInput;
#include "UtScriptEnvironment.hpp"
class UtScriptTypes;
class WsfApplication;
#include "WsfComponentFactory.hpp"
#include "WsfDeferredInput.hpp"
#include "WsfEnvironment.hpp"
#include "WsfExtensionList.hpp"
class WsfGrammarInterface;
#include "WsfIFF_Manager.hpp"
#include "WsfMessageTable.hpp"
class WsfObject;
#include "WsfPathFinder.hpp"
#include "WsfPlatform.hpp"
#include "WsfPlatformAvailability.hpp"
class WsfScenarioExtension;
class WsfScriptContext;
#include "WsfSignatureList.hpp"
#include "script/WsfScriptManager.hpp"
class WsfSimulation;
#include "WsfSimulationInput.hpp"
#include "WsfStringTable.hpp"
class WsfSystemLog;
 
// Types classes
class WsfAdvancedBehaviorTreeNodeTypes;
class WsfAeroTypes;
class WsfAntennaPatternTypes;
class WsfBehaviorTreeNodeTypes;
class WsfCallbackTypes;
class WsfCorrelationStrategyTypes;
class WsfEM_AttenuationTypes;
class WsfEM_AttenuationTypes;
class WsfEM_ClutterTypes;
class WsfEM_PropagationTypes;
class WsfFilterTypes;
class WsfFuelTypes;
class WsfFusionStrategyTypes;
class WsfIntersectMeshTypes;
class WsfGroupTypes;
class WsfMaskingPatternTypes;
class WsfMoverTypes;
class WsfNoiseCloudTypes;
class WsfObjectTypeListBase;
class WsfObjectTypeListBaseI;
class WsfPathFinderTypes;
class WsfPlatformTypes;
class WsfProcessorTypes;
class WsfRadarSignatureTypes;
class WsfRouteNetworkTypes;
class WsfRouteTypes;
class WsfSensorErrorModelTypes;
class WsfSensorTypes;
#include "WsfTerrain.hpp"
class WsfThermalSystemTypes;
class WsfThermalSystemComponentTypes;
class WsfTrackReportingStrategyTypes;
class WsfVisualPartTypes;
class WsfZoneTypes;
 
namespace wsf
{
 
class TrackExtrapolationStrategyTypes;
 
namespace comm
{
class Types;
class NetworkTypes;
class ProtocolTypes;
 
namespace router
{
class Types;
class ProtocolTypes;
} // namespace router
 
namespace medium
{
class Types;
}
} // namespace comm
} // namespace wsf

class WSF_EXPORT WsfScenario
{
public:
   using ScenarioExtensionMap = std::map<std::string, WsfScenarioExtension*>;
   using ComponentFactoryList = std::vector<std::unique_ptr<WsfComponentFactoryBase>>;
   using InputFunction        = std::function<bool(UtInput&)>;
 
   static WsfScenario& FromInput(UtInput& aInput);
 
   WsfScenario(WsfApplication& aApplication);
   WsfScenario(const WsfScenario& aSrc) = delete;
   WsfScenario& operator=(const WsfScenario&) = delete;
   virtual ~WsfScenario()                     = default;
 
   void SetSimulationInput(WsfSimulationInput* aSimulationInput);

   WsfApplication& GetApplication() const { return *mApplicationPtr; }
 
   void LoadFromFile(const std::string& aFileName);
   void LoadFromStream(UtInput& aInput);
   bool ProcessInput(UtInput& aInput);
 
   void CompleteLoad();
 
   void ConfigureInput(UtInput& aInput);
   bool LoadIsComplete() const { return mLoadIsComplete; }

   void ScenarioChange();
 
   bool LoadPlatformInstance(UtInput& aInput);
 
   void SimulationCreated(WsfSimulation& aSimulation) const;


   WsfDeferredInput& GetDeferredInput();
 
   WsfSystemLog&  GetSystemLog() const;
   UtScriptTypes* GetScriptTypes() const { return mScriptTypesPtr; }
 
   WsfScriptManager* GetScriptManager() const { return mScriptManagerPtr.get(); }
 
   WsfScriptContext* GetScriptContext() const;
 
   WsfEnvironment& GetEnvironment() const { return *mEnvironmentPtr; }
 
   // Should not be modified by the simulation
   const WsfMessageTable* GetMessageTable() const { return mMessageTablePtr.get(); }
 
   UtAtmosphere& GetAtmosphere() const { return *mAtmospherePtr; }
 
   WsfPathFinderList& GetPathFinderList() const { return *mPathFinderListPtr; }
 
   WsfSimulationInput& GetSimulationInput() const { return *mSimulationInputPtr; }

   wsf::TerrainInterface* GetTerrainInterface() const { return mTerrainInterfacePtr.get(); }

   WsfIFF_Manager* GetIFF_Manager() const { return mIFF_ManagerPtr.get(); }
 
   const WsfStringTable& Strings() const { return mStringTable; }

   const std::vector<std::string>& GetInputFiles() const { return mInputFiles; }
 
   void AddInputProcessor(const InputFunction& aFunction);
 
   UtScriptEnvironment& GetScriptEnvironment() const { return *mScriptEnvironmentPtr; }

   UtInput& GetInput() const { return *mInputPtr; }


   WsfScenarioExtension* FindExtension(const std::string& aName) const;
   WsfScenarioExtension& GetExtension(const std::string& aName) const;
 
   void RegisterExtension(const std::string& aName, std::unique_ptr<WsfScenarioExtension> aExtensionPtr);
   void ExtensionDepends(const std::string& aExtensionName, const std::string& aDependsOnExtensionName, bool aRequired);
 
   const WsfExtensionList& GetExtensions() const { return *mExtensionListPtr; }


   void                        RegisterComponentFactory(std::unique_ptr<WsfComponentFactoryBase> aFactoryPtr);
   const ComponentFactoryList& GetComponentFactoryList() const { return mComponentFactoryList; }


   WsfObject* FindType(const std::string& aTypeKind, WsfStringId aTypeName) const;

   template<typename T>
   T* FindTypeT(const std::string& aTypeName)
   {
      WsfObject* objectPtr = FindType(T::cTYPE_KIND, aTypeName);
      return dynamic_cast<T*>(objectPtr);
   }
 
   WsfObject* CloneType(const std::string& aTypeKind, WsfStringId aTypeName) const;

   template<typename T>
   T* CloneTypeT(WsfStringId aTypeName) const
   {
      WsfObject* objectPtr = CloneType(T::cTYPE_KIND, aTypeName);
      return dynamic_cast<T*>(objectPtr);
   }

 
   void AddTypeList(std::unique_ptr<WsfObjectTypeListBaseI> aTypeListPtr);
 
   WsfObjectTypeListBaseI*              GetTypes(const std::string& aTypesKind) const;
   std::vector<WsfObjectTypeListBaseI*> GetTypeLists() const
   {
      std::vector<WsfObjectTypeListBaseI*> result;
      for (auto& typeListPtr : mAllTypeLists)
      {
         result.push_back(typeListPtr.get());
      }
      return result;
   }


   WsfAdvancedBehaviorTreeNodeTypes& GetAdvancedBehaviorTreeNodeTypes() const
   {
      return *mAdvancedBehaviorTreeNodeTypesPtr;
   }
   WsfAeroTypes&                     GetAeroTypes() const { return *mAeroTypesPtr; }
   WsfAntennaPatternTypes&           GetAntennaPatternTypes() const { return *mAntennaPatternTypesPtr; }
   WsfBehaviorTreeNodeTypes&         GetBehaviorTreeNodeTypes() const { return *mBehaviorTreeNodeTypesPtr; }
   WsfCallbackTypes&                 GetCallbackTypes() const { return *mCallbackTypesPtr; }
   wsf::comm::Types&                 GetCommTypes() const { return *mCommTypesPtr; }
   WsfCorrelationStrategyTypes&      GetCorrelationTypes() const { return *mCorrelationTypesPtr; }
   WsfEM_AttenuationTypes&           GetEM_AttenuationTypes() const { return *mEM_AttenuationTypesPtr; }
   WsfEM_ClutterTypes&               GetEM_ClutterTypes() const { return *mEM_ClutterTypesPtr; }
   WsfEM_PropagationTypes&           GetEM_PropagationTypes() const { return *mEM_PropagationTypesPtr; }
   WsfFilterTypes&                   GetFilterTypes() const { return *mFilterTypesPtr; }
   WsfFuelTypes&                     GetFuelTypes() const { return *mFuelTypesPtr; }
   WsfFusionStrategyTypes&           GetFusionTypes() const { return *mFusionTypesPtr; }
   WsfGroupTypes&                    GetGroupTypes() const { return *mGroupTypesPtr; }
   WsfIntersectMeshTypes&            GetIntersectMeshTypes() const { return *mIntersectMeshTypesPtr; }
   WsfMaskingPatternTypes&           GetMaskingPatternTypes() const { return *mMaskingPatternTypesPtr; }
   wsf::comm::medium::Types&         GetMediumTypes() const { return *mMediumTypesPtr; }
   WsfMoverTypes&                    GetMoverTypes() const { return *mMoverTypesPtr; }
   wsf::comm::NetworkTypes&          GetNetworkTypes() const { return *mNetworkTypesPtr; }
   WsfNoiseCloudTypes&               GetNoiseCloudTypes() const { return *mNoiseCloudTypesPtr; }
   WsfPathFinderTypes&               GetPathFinderTypes() const { return *mPathFinderTypesPtr; }
   WsfPlatformTypes&                 GetPlatformTypes() const { return *mPlatformTypesPtr; }
   WsfProcessorTypes&                GetProcessorTypes() const { return *mProcessorTypesPtr; }
   wsf::comm::ProtocolTypes&         GetProtocolTypes() const { return *mCommProtocolTypesPtr; }
   WsfRadarSignatureTypes&           GetRadarSignatureTypes() const { return *mRadarSignatureTypesPtr; }
   WsfRouteTypes&                    GetRouteTypes() const { return *mRouteTypesPtr; }
   WsfRouteNetworkTypes&             GetRouteNetworkTypes() const { return *mRouteNetworkTypesPtr; }
   wsf::comm::router::Types&         GetRouterTypes() const { return *mRouterTypesPtr; }
   wsf::comm::router::ProtocolTypes& GetRouterProtocolTypes() const { return *mRouterProtocolTypesPtr; }
   WsfSensorErrorModelTypes&         GetSensorErrorModelTypes() const { return *mSensorErrorModelTypesPtr; }
   WsfSensorTypes&                   GetSensorTypes() const { return *mSensorTypesPtr; }
   WsfThermalSystemTypes&            GetThermalSystemTypes() const { return *mThermalSystemTypesPtr; }
   WsfThermalSystemComponentTypes&   GetThermalSystemComponentTypes() const { return *mThermalSystemComponentTypesPtr; }
   wsf::TrackExtrapolationStrategyTypes& GetTrackExtrapolationStrategyTypes() const
   {
      return *mTrackExtrapolationStrategyTypesPtr;
   }
   WsfTrackReportingStrategyTypes& GetTrackReportingStrategyTypes() const { return *mTrackReportingStrategyTypesPtr; }
   WsfVisualPartTypes&             GetVisualPartTypes() const { return *mVisualPartTypesPtr; }
   WsfZoneTypes&                   GetZoneTypes() const { return *mZoneTypesPtr; }



   unsigned int GetInitalRunNumber() const { return mInitialRunNumber; }

   unsigned int GetFinalRunNumber() const { return mFinalRunNumber; }

   unsigned int GetRunNumberIncrement() const { return mRunNumberIncrement; }
 
   void SetInitialRunNumber(unsigned int aInitialRunNumber);
   void SetFinalRunNumber(unsigned int aFinalRunNumber);
   void SetRunNumberIncrement(unsigned int aRunNumberIncrement);

   long int GetRandomSeed(unsigned int aRunNumber) const;
   long int GetInitialSeed() const { return mInitialSeed; }
   void     SetInitialSeed(long int aInitialSeed) { mInitialSeed = aInitialSeed; }
 
   const std::string& GetClassificationString() const { return mClassification.first; }
   const UtColor&     GetClassificationColor() const { return mClassification.second; }


   bool AddInputPlatform(std::unique_ptr<WsfPlatform> aPlatformPtr);
 
   WsfPlatform*       GetInputPlatformByName(WsfStringId aNameId);
   const WsfPlatform* GetInputPlatformByName(WsfStringId aNameId) const;
 
   unsigned int GetInputPlatformCount() const;

   WsfPlatform* GetInputPlatformEntry(unsigned int aEntry) const;
 
   bool PlatformIsAvailable(WsfPlatform* aPlatformPtr, WsfSimulation& aSimulation) const;
 

   bool UseQuantitativeTrackQuality() const { return mUseQuantitativeTrackQuality; }


   const WsfSignatureList& GetSignatureListPrototype() const { return *mSignatureListPrototypePtr; }
   WsfSignatureList&       GetSignatureListPrototype() { return *mSignatureListPrototypePtr; }



   bool HadUnexpectedError() const { return mHadUnexpectedError; }
   bool ExpectInputError() const { return mExpectInputError; }

   const std::string& GetSimulationName() const { return mSimulationName; }
 
private:
   void CreateTypeLists(WsfScenario& aScenario);
   template<class T>
   T* CreateTypeList(WsfScenario& aScenario);
 
   bool ProcessEnumerateCommand(UtInput& aInput);
 
protected:
   virtual bool ProcessInputP(UtInput& aInput);
   bool         TypesProcessInput(UtInput& aInput);
 
   bool ExpectError() const { return mExpectInputError; }
   void ExpectError(bool aExpectError);
   void CheckErrorFailure();
 
   void LoadFromStreamP(UtInput& aInput);
   void FileOpenCallback(const std::string& aFileName);
   bool ProcessExtensionInput(UtInput& aInput);
   void SortExtensions();
 
   void   BuildClassificationString();
   size_t FindClassificationLevel(const std::string& aLevel) const;
 
   friend class ErrorTracker;
 
   WsfApplication* mApplicationPtr;
   bool            mHadUnexpectedError;
   bool            mTestingForInputError;
   bool            mGotError;
   bool            mExpectInputError;
   bool            mExtensionsInOrder;
   bool                                   mLoadIsComplete;
   std::unique_ptr<UtInput>               mInputPtr;
   std::unique_ptr<WsfDeferredInput>      mDeferredInputPtr;
   int                                    mOpenConditionalBlocks;
   WsfStringTable                         mStringTable;
   std::unique_ptr<WsfSimulationInput>    mSimulationInputPtr;
   UtScriptTypes*                         mScriptTypesPtr;
   std::unique_ptr<UtScriptEnvironment>   mScriptEnvironmentPtr;
   std::unique_ptr<WsfScriptManager>      mScriptManagerPtr;
   std::unique_ptr<WsfEnvironment>        mEnvironmentPtr;
   std::unique_ptr<UtAtmosphere>          mAtmospherePtr;
   std::unique_ptr<WsfMessageTable>       mMessageTablePtr;
   std::unique_ptr<WsfPathFinderList>     mPathFinderListPtr;
   std::unique_ptr<wsf::TerrainInterface> mTerrainInterfacePtr;
   std::unique_ptr<WsfIFF_Manager>        mIFF_ManagerPtr;
 
   std::vector<std::string> mInputFiles;
 
   std::vector<InputFunction> mInputFunctions;
 
   bool mUseQuantitativeTrackQuality;
 
   using ClassificationLevel = std::pair<std::string, UtColor>;
   // This is a vector of pairs (do not map, as the input order of levels needs to be maintained)
   std::vector<ClassificationLevel> mClassificationsList;
   ClassificationLevel              mClassification;
   std::set<std::string>            mTrigraphsSet;
   std::set<std::string>            mCaveatsSet;
   size_t                           mLevelIndex{ut::npos};
 
   std::string mSimulationName;



   unsigned int mInitialRunNumber;

   unsigned int mFinalRunNumber;

   unsigned int mRunNumberIncrement;

   long int mInitialRandomSeed;
 
   long int mInitialSeed;

   std::vector<long int> mRandomSeeds;

   std::vector<std::unique_ptr<WsfPlatform>> mInputPlatforms;

   std::unique_ptr<WsfPlatformAvailability> mPlatformAvailabilityPtr;


   WsfAdvancedBehaviorTreeNodeTypes*     mAdvancedBehaviorTreeNodeTypesPtr;
   WsfAeroTypes*                         mAeroTypesPtr;
   WsfAntennaPatternTypes*               mAntennaPatternTypesPtr;
   WsfBehaviorTreeNodeTypes*             mBehaviorTreeNodeTypesPtr;
   WsfCallbackTypes*                     mCallbackTypesPtr;
   wsf::comm::Types*                     mCommTypesPtr;
   WsfCorrelationStrategyTypes*          mCorrelationTypesPtr;
   WsfEM_ClutterTypes*                   mEM_ClutterTypesPtr;
   WsfEM_AttenuationTypes*               mEM_AttenuationTypesPtr;
   WsfEM_PropagationTypes*               mEM_PropagationTypesPtr;
   WsfFilterTypes*                       mFilterTypesPtr;
   WsfFuelTypes*                         mFuelTypesPtr;
   WsfFusionStrategyTypes*               mFusionTypesPtr;
   WsfGroupTypes*                        mGroupTypesPtr;
   WsfIntersectMeshTypes*                mIntersectMeshTypesPtr;
   WsfMaskingPatternTypes*               mMaskingPatternTypesPtr;
   wsf::comm::medium::Types*             mMediumTypesPtr;
   WsfMoverTypes*                        mMoverTypesPtr;
   wsf::comm::NetworkTypes*              mNetworkTypesPtr;
   WsfNoiseCloudTypes*                   mNoiseCloudTypesPtr;
   WsfPathFinderTypes*                   mPathFinderTypesPtr;
   WsfPlatformTypes*                     mPlatformTypesPtr;
   WsfProcessorTypes*                    mProcessorTypesPtr;
   wsf::comm::ProtocolTypes*             mCommProtocolTypesPtr;
   WsfRouteTypes*                        mRouteTypesPtr;
   wsf::comm::router::Types*             mRouterTypesPtr;
   wsf::comm::router::ProtocolTypes*     mRouterProtocolTypesPtr;
   WsfSensorErrorModelTypes*             mSensorErrorModelTypesPtr;
   WsfSensorTypes*                       mSensorTypesPtr;
   WsfRadarSignatureTypes*               mRadarSignatureTypesPtr;
   WsfRouteNetworkTypes*                 mRouteNetworkTypesPtr;
   wsf::TrackExtrapolationStrategyTypes* mTrackExtrapolationStrategyTypesPtr;
   WsfTrackReportingStrategyTypes*       mTrackReportingStrategyTypesPtr;
   WsfThermalSystemTypes*                mThermalSystemTypesPtr;
   WsfThermalSystemComponentTypes*       mThermalSystemComponentTypesPtr;
   WsfVisualPartTypes*                   mVisualPartTypesPtr;
   WsfZoneTypes*                         mZoneTypesPtr;

   std::vector<std::unique_ptr<WsfObjectTypeListBaseI>> mAllTypeLists;
   std::map<std::string, WsfObjectTypeListBaseI*> mTypesListByKind;

   std::unique_ptr<WsfSignatureList> mSignatureListPrototypePtr;

   std::unique_ptr<WsfExtensionList> mExtensionListPtr;

   ComponentFactoryList mComponentFactoryList;
};
 
#endif