WsfEvent.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 WSFEVENT_HPP
#define WSFEVENT_HPP
 
#include "wsf_export.h"
 
#include <functional>
 
class WsfSimulation;

 
class WSF_EXPORT WsfEvent
{
public:
   enum EventDisposition
   {
      cDELETE,    
      cRESCHEDULE 
   };

   WsfEvent() = default;

   WsfEvent(double aSimTime, int aPriority = 0)
      : mSimTime(aSimTime)
      , mPriority(aPriority)
   {
   }

   WsfEvent(const WsfEvent& aSrc) = delete;
   WsfEvent& operator=(const WsfEvent& aRhs) = delete;
 
   virtual ~WsfEvent() = default;

   virtual EventDisposition Execute() = 0;

   double GetTime() const { return mSimTime; }

   int GetPriority() const { return mPriority; }

   bool ShouldExecute() const { return mExecute; }

   void SetTime(double aSimTime) { mSimTime = aSimTime; }

   void SetPriority(int aPriority) { mPriority = aPriority; }

   void SetShouldExecute(bool aExecute) { mExecute = aExecute; }

   WsfSimulation* GetSimulation() const { return mSimulationPtr; }

   void AddedToEventQueue(WsfSimulation& aSimulation) { mSimulationPtr = &aSimulation; }
 
private:
   double         mSimTime{0.0}; 
   WsfSimulation* mSimulationPtr{nullptr};
   int            mPriority{0};   
   bool           mExecute{true}; 
};

template<typename RT, typename... Args>
class WsfEventAdapterT : public WsfEvent
{
protected:
   using ExecuteFn = std::function<RT(Args...)>;
 
   WsfEventAdapterT(double aSimTime, const ExecuteFn& aExecuteFn)
      : WsfEvent(aSimTime)
      , mExecuteFn(aExecuteFn)
   {
   }
 
   ~WsfEventAdapterT() override = default;
 
   ExecuteFn mExecuteFn;
};

class WSF_EXPORT WsfOneShotEvent : public WsfEventAdapterT<void>
{
public:
   WsfOneShotEvent(double aSimTime, const ExecuteFn& aExecuteFn)
      : WsfEventAdapterT<void>(aSimTime, aExecuteFn)
   {
   }
 
   EventDisposition Execute() override
   {
      mExecuteFn();
      return cDELETE;
   }
};

class WSF_EXPORT WsfRecurringEvent : public WsfEventAdapterT<WsfEvent::EventDisposition, WsfEvent&>
{
public:
   WsfRecurringEvent(double aSimTime, const ExecuteFn& aExecuteFn)
      : WsfEventAdapterT<WsfEvent::EventDisposition, WsfEvent&>(aSimTime, aExecuteFn)
   {
   }
 
   EventDisposition Execute() override { return mExecuteFn(*this); }
};
 
#endif