WsfScriptContext.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 WSFSCRIPTCONTEXT_HPP
#define WSFSCRIPTCONTEXT_HPP
 
#include "wsf_export.h"
 
#include <memory>
#include <string>
#include <vector>
 
class UtInput;
class UtScript;
class UtScriptClass;
class UtScriptContext;
class UtScriptEnvironment;
class UtScriptExecutor;
class UtScriptTypes;
#include "WsfEvent.hpp"
class WsfEventPipeInterface;
class WsfMessage;
class WsfPlatform;
class WsfPlatformPart;
class WsfProcessor;
class WsfSimulation;
class WsfScenario;
#include "WsfStringId.hpp"
class WsfTrack;
 
namespace ut
{
namespace script
{
class Data;
using DataList = std::vector<Data>;
} // namespace script
} // namespace ut
using UtScriptData     = ut::script::Data;
using UtScriptDataList = ut::script::DataList;
 
class WSF_EXPORT WsfScriptContext
{
public:
   WsfScriptContext(UtScriptEnvironment* aTypesPtr);
   WsfScriptContext(WsfScriptContext& aParentContext, WsfStringId aPartClassName, const std::string& aPartVarName);
   WsfScriptContext(WsfScriptContext& aParentContext, WsfStringId aObjectClassName);
 
   WsfScriptContext(const WsfScriptContext& aSrc);
   WsfScriptContext& operator=(const WsfScriptContext& aRhs);
 
   virtual ~WsfScriptContext();
 
   virtual bool Initialize(double aSimTime, WsfPlatform* aPlatformPtr, WsfPlatformPart* aPartPtr);
 
   virtual bool Initialize(WsfSimulation& aSimulation, void* aObjectPtr);
   virtual bool Initialize(double aSimTime, WsfScriptContext& aParentContext, void* aObjectPtr);
 
   virtual bool Initialize2(double aSimTime);
 
   virtual bool InitializeGlobalContext(WsfSimulation& aSimulation);
 
   virtual bool ProcessInput(UtInput& aInput);
 
   virtual void Update(double aSimTime);
 
   UtScript* Compile(UtInput& aInput, const std::string& aEndBlockToken = "end_script", const std::string& aNamespace = "");
 
   UtScript* Compile(const std::string& aScriptName,
                     WsfStringId        aScriptReturnType,
                     UtInput&           aInput,
                     const std::string& aEndBlockToken   = "end_script",
                     const std::string& aNamespace       = "",
                     bool               aIsVariableBlock = false);
 
   UtScript* CompileImplicitScript(UtInput& aInput, const std::string& aName, WsfStringId aReturnType);
 
   void CompileVariables(UtInput& aInput);
 
   void DeclareVariable(WsfStringId aType, const std::string& aName);
 
   bool ExecuteScript(double aSimTime, WsfStringId aScriptName);
 
   void ExecuteScript(double aSimTime, UtScript* aScriptPtr);
 
   bool ExecuteScript(double aSimTime, WsfStringId aScriptName, UtScriptData& aScriptRetVal, const UtScriptDataList& aScriptArgs);
 
   void ExecuteScript(double aSimTime, UtScript* aScriptPtr, UtScriptData& aScriptRetVal, const UtScriptDataList& aScriptArgs);
 
   void ExecuteScript(UtScript* aScriptPtr, UtScriptData& aScriptRetVal, const UtScriptDataList& aScriptArgs);
 
   bool ExecuteScript(double                  aSimTime,
                      UtScriptData&           aScriptRetVal,
                      const UtScriptDataList& aScriptArgs,
                      const std::string&      aScriptSource);
 
   virtual UtScript* FindScript(WsfStringId aScriptName) const;

   UtScriptContext&     GetContext() const { return *mContextPtr; }
   WsfScriptContext&    GetGlobalContext();
   UtScriptTypes*       GetTypes() const;
   UtScriptEnvironment* GetEnvironment() const;
   UtScriptClass*       GetClass(const std::string& aClassName) const;
   UtScriptClass*       GetClass(WsfStringId aClassName) const;
   UtScriptClass*       GetClass(const char* aClassName) const;

   bool HasUpdateHandler() const { return (mOnUpdateScriptPtr != nullptr); }
 
   void SetParent(WsfScriptContext* aParentPtr);
   void SetParent(UtScriptContext* aParentPtr);
 
   bool ValidateScript(UtScript* aScriptPtr, WsfStringId aReturnType, const std::string& aArgumentTypes) const;
 
   WsfPlatformPart* GetPart() { return mPlatformPartPtr; }
 
   static double                 GetTIME_NOW(const UtScriptContext& aContext);
   static WsfPlatform*           GetPLATFORM(const UtScriptContext& aContext);
   static WsfProcessor*          GetPROCESSOR(const UtScriptContext& aContext);
   static WsfMessage*            GetMESSAGE(const UtScriptContext& aContext);
   static WsfTrack*              GetTRACK(const UtScriptContext& aContext);
   static WsfSimulation*         GetSIMULATION(const UtScriptContext& aContext);
   static WsfScenario*           GetSCENARIO(const UtScriptContext& aContext);
   static WsfEventPipeInterface* GetEVENTPIPE(const UtScriptContext& aContext);

   class ExecuteTimedEventScript : public WsfEvent
   {
   public:
      ExecuteTimedEventScript()
         : mTimeInterval(0.0)
         , mPlatformIndex(0)
         , mContextPtr(nullptr)
         , mScriptName()
      {
      }
      ExecuteTimedEventScript(double            aSimTime,
                              double            aTimeInterval,
                              WsfPlatform*      aPlatformPtr,
                              WsfScriptContext* aContextPtr,
                              WsfStringId       aScriptName);
 
      EventDisposition Execute() override;
 
   private:
      double            mTimeInterval;
      size_t            mPlatformIndex;
      WsfScriptContext* mContextPtr;
      WsfStringId       mScriptName;
   };
 
   WsfSimulation*     GetSimulation() const;
   const WsfScenario* GetScenario() const;
   UtScriptExecutor*  GetExecutor() const;
 
protected:
   UtScriptData GetSimTimeP();
 
   bool AddTimedEvents(double aSimTime);
 
   void CallScript(UtScript* aScriptPtr, UtScriptData& aScriptRetVal, const UtScriptDataList& aScriptArgs);
 
   void PostCompile(UtInput& aInput, UtScript* aRawScriptPtr);
 
   void WriteErrorHeader(UtScript* aScriptPtr) const;

   WsfScriptContext* mParentPtr{nullptr};

   std::unique_ptr<UtScriptContext> mContextPtr;

   struct TimedEvent;
   std::vector<TimedEvent> mTimedEvents;
 
   WsfSimulation* mSimulationPtr{nullptr};

   WsfPlatform* mPlatformPtr{nullptr};

   WsfPlatformPart* mPlatformPartPtr{nullptr};

   WsfStringId mPartClassName{};

   WsfStringId mPartVarName{};

   WsfStringId mObjectClassName{};
 
   class ReadTIME_NOW;
   std::unique_ptr<ReadTIME_NOW> mTimeNowFunctionPtr;

   UtScript* mOnUpdateScriptPtr{nullptr};

   bool mScriptCallTrace{false};

   bool mUserDefinedScriptCallTrace{false};

   bool mScriptPrintCode{false};

   bool mScriptCheckError{false};

   bool mScriptExpectError{false};
};
 
#endif