WsfApplication.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 WSFAPPLICATION_HPP
#define WSFAPPLICATION_HPP
 
#include "wsf_export.h"
 
#include <list>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
 
#include "UtException.hpp"
class UtScriptTypes;
class WsfApplicationExtension;
class WsfExtensionList;
class WsfPluginManager;
class WsfScenario;
class WsfSimulation;
class WsfSystemLog;

class WSF_EXPORT WsfApplication
{
   friend class WsfScenario;
 
public:
   class Exception : public UtException
   {
   public:
      Exception(const std::string& aWhat)
         : UtException(aWhat)
         , mReturnCode(0)
      {
      }
 
      int GetReturnCode() const { return mReturnCode; }
 
   protected:
      int mReturnCode;
   };

   class FeatureNotPresent : public Exception
   {
   public:
      FeatureNotPresent(bool aTestingEnabled);
      ~FeatureNotPresent() override = default;
   };
 
   using PluginPaths = std::list<std::string>;
 
   WsfApplication(const std::string& aApplicationName,
                  int                aArgc,
                  char*              aArgv[],
                  const PluginPaths& aPluginPaths = PluginPaths());
   virtual ~WsfApplication();

   const std::string& GetApplicationName() const { return mApplicationName; }


   void GetCommandLineArguments(int& aArgc, char**& aArgv);
 
   void RemoveCommandLineOptions(int aArgc, int aArgCount);


   void RegisterExtension(const std::string& aName, std::unique_ptr<WsfApplicationExtension> aExtensionPtr);
 
   void ExtensionDepends(const std::string& aExtensionName, const std::string& aDependsOnExtensionName, bool aRequired);
 
   bool                     ExtensionIsRegistered(const std::string& aName) const;
   WsfApplicationExtension* FindExtension(const std::string& aName) const;
   WsfApplicationExtension& GetExtension(const std::string& aName) const;

   const WsfExtensionList& GetExtensions() const { return *mExtensionListPtr; }



   struct Feature
   {
      std::string mName;
      std::string mProject;
   };
 
   void RegisterFeature(const std::string& aFeature, const std::string& aProjectName = std::string());

   const std::vector<Feature>& GetRegisteredFeatures() { return mRegisteredFeatures; }



   UtScriptTypes* GetScriptTypes() const { return mScriptTypesPtr; }

   WsfSystemLog& GetSystemLog() { return *mSystemLogPtr; }



   bool IsTestingEnabled() const { return mIsTestingEnabled; }
 
private:
   WsfApplication(const WsfApplication& aSrc);
 
   void RegisterDefaultFeatures();
 
   void ScenarioCreated(WsfScenario& aScenario);
   void SimulationCreated(WsfSimulation& aSimulation);
 
   bool InitializeTestEnvironment();

   static WsfApplication* mInstancePtr;

   std::string mApplicationName;

   std::vector<char*> mArgv;

   WsfExtensionList* mExtensionListPtr;

   std::vector<Feature> mRegisteredFeatures;

   WsfSystemLog* mSystemLogPtr;

   UtScriptTypes* mScriptTypesPtr;

   WsfPluginManager* mPluginManagerPtr;

   std::recursive_mutex mMutex;

   bool mIsTestingEnabled;
};
 
// Define a macro that, if used in a standard way, provides a way to register an extension without
// the need to bring a header file for the extension. This can potentially eliminate a the need
// to define a lot of include paths to build the application. The extension should define a static
// method of the form:
//
//     void Register_<ExtensionName>(WsfApplication& aApplication);
//
// 'WSF_REGISTER_APPLICATION(app, <ExtensionName>)' generates the code:
//
//     void Register_<ExtensionName>(WsfApplication& aApplication);
//     Register_<ExtensionName>(app);
//
// For instance:
//
//   WsfApplication app;
//   WSF_REGISTER_EXTENSION(app, WsfEventOutput);
//   WSF_REGISTER_EXTENSION(app, WsfDisInterface);
//
// will register the standard event output and DIS interface extensions...
 
#define WSF_REGISTER_EXTENSION(APP, NAME)                     \
   extern void Register_##NAME(WsfApplication& aApplication); \
   Register_##NAME(APP);
 
#endif