WsfScenarioExtension.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 WSFSCENARIOEXTENSION_HPP
#define WSFSCENARIOEXTENSION_HPP
 
#include "wsf_export.h"
 
#include <mutex>
 
class UtInput;
class WsfApplication;
class WsfApplicationExtension;
#include "WsfExtension.hpp"
class WsfScenario;
class WsfSimulation;
class WsfSimulationExtension;

class WSF_EXPORT WsfScenarioExtension : public WsfExtension
{
public:
   friend class WsfScenario;
 
   WsfScenarioExtension();
   ~WsfScenarioExtension() override;

   WsfScenario& GetScenario() const { return *mScenarioPtr; }
 
   WsfApplication& GetApplication() const;


   virtual void AddedToScenario();
   virtual bool ProcessInput(UtInput& aInput);
   virtual void FileLoaded(const std::string& aFileName);
   virtual bool Complete();
   virtual bool Complete2();
   virtual void SimulationCreated(WsfSimulation& aSimulation);
   virtual bool AlwaysCreate();
 
private:
   void AddedToScenarioP(const std::string& aName, WsfScenario& aScenario);

   WsfScenario* mScenarioPtr;
};
 
class WsfCloneableSimulationExtension;

class WSF_EXPORT WsfCloneableScenarioExtension : public WsfScenarioExtension
{
public:
   WsfCloneableScenarioExtension(WsfCloneableSimulationExtension* aPrototypePtr)
      : mPrototypePtr(aPrototypePtr)
   {
   }
   ~WsfCloneableScenarioExtension() override;
   bool ProcessInput(UtInput& aInput) override;
   void SimulationCreated(WsfSimulation& aSimulation) override;
 
protected:
   WsfCloneableSimulationExtension* mPrototypePtr;
};
 
// Eliminate need for WsfSimulation.hpp include here
namespace WsfPrivate
{
WSF_EXPORT void RegisterSimulationExtension(WsfSimulation&          aSimulation,
                                            const std::string&      aName,
                                            WsfSimulationExtension* aExtensionPtr);
}
 
template<typename SIMULATION_EXTENSION>
class WsfDefaultScenarioExtension : public WsfScenarioExtension
{
public:
   void SimulationCreated(WsfSimulation& aSimulation) override
   {
      WsfPrivate::RegisterSimulationExtension(aSimulation, GetExtensionName(), new SIMULATION_EXTENSION);
   }
};

template<typename CLASS>
class WsfLegacyScenarioExtension : public WsfScenarioExtension
{
public:
   WsfLegacyScenarioExtension(CLASS* aClassPtr)
      : mClassPtr(aClassPtr)
   {
   }
 
   ~WsfLegacyScenarioExtension() override { delete mClassPtr; }
 
   bool ProcessInput(UtInput& aInput) override
   {
      if (mClassPtr != nullptr)
      {
         return mClassPtr->ProcessInput(aInput);
      }
      return false;
   }

   void SimulationCreated(WsfSimulation& aSimulation) override
   {
      std::lock_guard<std::recursive_mutex> lock(mMutex);
      WsfSimulationExtension*               extensionPtr = mClassPtr;
      mClassPtr                                          = nullptr;
      if (extensionPtr != nullptr)
      {
         WsfPrivate::RegisterSimulationExtension(aSimulation, GetExtensionName(), extensionPtr);
      }
   }
 
protected:
   std::recursive_mutex mMutex;
   CLASS*               mClassPtr;
};
 
#endif