scriptInterface.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2012 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once

#include <vrfobjcore/vrfobjcoreDefines.h>

#include <vrfmsgs/setDataRequestMessage.h>
#include <vrfobjcore/scriptTaskControllerInterface.h>
#include <readerWriter/rwVariableBindings.h>
#include <vrftasks/vrfObjectMessageTypeTemplate.h>
#include "vlutil/vlString.h"
#include "vrfobjcore/scriptVrfObject.h"
#include "vrfobjcore/scriptAerodromeObject.h"

#include "vrfutil/asyncJob.h"
#include <deque>

class DtLocalObject;
class DtTranslatableStream;
class DtSimulationServices;
class DtScriptMultiTaskController;


class DT_DLL_vrfobjcore DtScriptInterface
{
public:

   class DtScriptFunctionReference
   {
   public:
      DtScriptFunctionReference() {};
      virtual ~DtScriptFunctionReference() {};

      virtual bool operator<(const DtScriptFunctionReference& other) const = 0;
   };

   typedef std::shared_ptr<DtScriptFunctionReference> DtScriptFunctionReferencePtr;

   typedef std::pair<DtGenericMessageType, DtScriptFunctionReferencePtr> DtPostCallbackEntry;

   struct PostSetDataCallbackLessThan
   {
      bool operator()(DtPostCallbackEntry lhs, DtPostCallbackEntry rhs) const
      {
         if (lhs.first < rhs.first) return true;
         else if (lhs.first > rhs.first) return false;
         else if (*lhs.second.get() < *rhs.second.get()) return true;
         else return false;
      }
   };

   typedef std::set<DtPostCallbackEntry, PostSetDataCallbackLessThan> DtPostSetDataCallbackSet;
   typedef std::vector<DtSimMessage*> DtSetDataMessageVector;
   typedef std::map<DtPostCallbackEntry, bool> DtPostCallbackEntryPendingChanges;

protected:
   DtScriptInterface(DtSimulationServices*);
   DtScriptInterface(const DtScriptInterface& other);
   DtScriptInterface& operator=(const DtScriptInterface& other);

public:
   virtual ~DtScriptInterface();

   virtual bool invokeInit() = 0;
   virtual void invokeSuspend() = 0;
   virtual bool invokeResume() = 0;

   virtual void invokeTick() = 0;

   virtual bool loadScript(bool reload = false) = 0;


   virtual void invokeCheckInit() = 0;
   virtual bool invokeCheck() = 0;

   virtual void invokeShutdown() = 0;

   virtual void invokeUpdateDisplayGraph() = 0;
   
   virtual void invokeDisable() = 0;

   virtual DtString type() const = 0;

   virtual void setTaskId(int taskId) { myTaskId = taskId; }
   virtual int taskId() const { return myTaskId; }

   virtual void setScriptId(const DtString& scriptId) { myScriptId = scriptId; }
   virtual const DtGenericMessageType& scriptId() const { return myScriptId; }

   virtual void setSystemName(const DtString& system) { mySystemName = system; }
   virtual const DtString& systemName() const { return mySystemName; }

   virtual void setScriptPath(const DtFilename& scriptPath) { myScriptPath = scriptPath; }
   virtual const DtFilename& scriptPath() const { return myScriptPath; }

   virtual void setEntity(DtLocalObject* entity) { myEntity = entity; }
   virtual DtLocalObject* entity() const { return myEntity; }

   virtual void init() { }


   virtual void setTaskVariables(const DtRwVariableBindings& variables) { myTaskVariables = variables; }
   virtual const DtRwVariableBindings& taskVariables() const { return myTaskVariables; }
   virtual bool updateTaskVariables();

   virtual DtReaderWriter* saveState() = 0;

   virtual bool loadState(const DtReaderWriter* savedState) = 0;

   virtual void processClearForReuse();

   virtual void setTaskStarting(bool v);
   virtual bool taskStarting() const;


   virtual void setTaskResuming(bool v);
   virtual bool taskResuming() const;


   virtual void setIsBackgroundProces(bool isBgProc);
   virtual bool isBackgroundProcess() const;


   virtual void setIsSet(bool isSet);
   virtual bool isSet() const;

   virtual bool isGraphCapable() const;

   virtual void setIsGraphCapable(bool isCapable = true);

   virtual bool shouldGenerateGraphOutput() const;
   virtual void setShouldGenerateGraphOutput(const bool doGenerate, const DtUUID& sender);
   

   virtual void processGraphCommands(const std::string& dotFileName);

   virtual void setController(DtScriptTaskControllerInterface* controller) { myControllerInterface = controller; }
   virtual DtScriptTaskControllerInterface* controller() { return myControllerInterface; }

   virtual void processEntityDestroyed() {}


   double scriptGetExerciseTime();

   double scriptGetWallClockTime();


   double scriptGetSimulationTime();

   double scriptGetTimeMultiplier();

   double scriptGetTimeOfDay();

   double scriptGetDateAndTimeOfDay();

   double scriptGetWindSpeed();

   double scriptGetWindDirection();

   double scriptGetMagneticDeclination(const DtLocation3D &location);

   DtScriptAerodromeObject scriptGetAerodrome(const std::string name);
   std::list<DtScriptAerodromeObject> scriptGetAerodromesWithinRange(DtLocation3D center, double range);
   DtScriptVrfObject scriptGetVrfObjectByName(const std::string name);
   DtScriptVrfObject scriptGetVrfObjectByUUID(const std::string name);
   void printError(const std::string message);
   void printErrorToChannel(const std::string channel, const std::string message);
   void printErrorTranslatableStream(const DtTranslatableStream& message);
   void printWarn(const std::string message);
   void printWarnToChannel(const std::string channel, const std::string message);
   void printWarnTranslatableStream(const DtTranslatableStream& message);
   void printInfo(const std::string message);
   void printInfoToChannel(const std::string channel, const std::string message);
   void printInfoTranslatableStream(const DtTranslatableStream& message);
   void printVerbose(const std::string message);
   void printVerboseToChannel(const std::string channel, const std::string message);
   void printVerboseTranslatableStream(const DtTranslatableStream& message);
   void printDebug(const std::string message);
   void printDebugToChannel(const std::string channel, const std::string message);
   void printDebugTranslatableStream(const DtTranslatableStream& message);
   bool entityTypeMatches(const std::string&, const std::string&);
   std::string getEntityTypeDescription(const std::string& entityType);

   void setTickPeriod(double);

   void setTickWhilePaused(bool);

   void setRespondToNewSensorContacts(bool);

   virtual void addPostSetDataCallback(const DtSetMessageType& setDataType, 
      DtScriptFunctionReferencePtr functionReference);

   virtual void removePostSetDataCallback(const DtSetMessageType& setDataType,
      DtScriptFunctionReferencePtr functionReference);

   virtual void clearPostSetDataCallbacks();

   static void postSetDataCallback(DtSimMessage* msg, void* usr);
   virtual void processPostSetData(DtSimMessage* msg);

   static void postTickCallback(void* usr);
   virtual void processPostTick();

   virtual void invokePostSetDataCallback(
      DtScriptFunctionReferencePtr functionReference, 
      DtSetDataRequestMessage* setDatRequest) = 0;

   virtual double getTerrainAltitude(const double lat, const double lon,
      bool& dataAvailable, std::string &surface) const;

   virtual double getTerrainAltitudeBelow(const DtLocation3D& point,
      bool& available, std::string &surfaceString) 
      const;

   virtual double getGroundAltitude(const double lat, const double lon,
      bool&isWater, bool& dataAvailable);
   
   virtual void chordIntersectionDebug(const DtLocation3D& startLoc,
      const DtLocation3D& endLoc);

   virtual bool doesChordHitTerrain(const DtLocation3D &pt1, 
      const DtLocation3D & pt2, 
      bool& dataAvailable) const;

   bool chordIntersectsTerrain(const DtLocation3D &pt1,
      const DtLocation3D & pt2,
      bool& dataAvailable,
      DtLocation3D &intersection) const;

   bool chordIntersectsTerrainWithOptions(const DtLocation3D& pt1,
      const DtLocation3D& pt2,
      const DtU32 options,
      bool& dataAvailable,
      DtLocation3D& intersection) const;
     
   virtual std::string getResourceTypeFromResourceName(std::string resourceName);

   virtual DtLocation3D findClosestPointInNavigationArea(const DtLocation3D& point,
      bool& error) const;
   virtual DtLocation3D findClosestPointInNavigationAreaInRadius(
      const DtLocation3D& point, const double radius,
      bool& error) const;
   virtual DtLocation3D findClosestPointInNavigationAreaInRadiusAndVertLimit(
      const DtLocation3D& point, const double radius, const double verticalLimit,
      bool& error) const;

   virtual bool matchPattern(std::string, std::string) const;

   bool findFarthestPositionAlongHeading(
      const DtLocation3D& point,
      const double heading, const double maxDistance,
      DtLocation3D& stopPoint, double& distanceReached) const;
      
  virtual DtLocation3D findClosestPointToRoad(const DtLocation3D& point,
      double searchRadius, bool& dataAvailable, bool& success, 
      DtLocation3D& endA, DtLocation3D& endB, double& offsetToOutsideLane) const;

   virtual std::list<std::string> getDynamicTerrainFeatureChangeTypes(
      const DtLocation3D& location, double radius, bool& dataVailable);

   virtual std::list<DtLocation3D> getDynamicTerrainFeatureLocationsForChangeType(
      const std::string& changeType, const DtLocation3D& location, double radius, bool& dataVailable);

   virtual std::list<std::string> getDynamicTerrainFeatureValuesForChangeType(
      const std::string& changeType, const DtLocation3D& location, double radius, bool& dataVailable);

   virtual void changeDynamicTerrain(const std::string& changeType, const std::string& changeValue, 
      const DtLocation3D& location, double radius);

   bool forcesHostile(std::string force1, std::string force2);

   std::list<std::string> entityTypesForEquipment(const std::string& equipmentType);

   virtual double gaussian();

   virtual void setGraphCapable();


protected:
   virtual void scriptTaskComplete(bool success);

   virtual void scriptTaskError();

   virtual bool scriptText(DtString& text);

   virtual bool scriptPath(DtString& path);
   
   virtual const DtReaderWriter* getTaskParam(const DtString& paramName);

   virtual bool getParamMetaDataType(const DtString& paramName, DtString& typeName);

   int myTaskId;
   DtGenericMessageType myScriptId;
   DtString mySystemName;
   DtFilename myScriptPath;
   DtScriptTaskControllerInterface* myControllerInterface;
   DtLocalObject* myEntity;
   DtSimulationServices* mySimulationServices;
   DtRwVariableBindings myTaskVariables;
   bool myTaskStarting;
   bool myTaskResuming;
   bool myIsBackgroundProcess;
   bool myIsSet;

   DtPostSetDataCallbackSet mySetDataCallbacks;

   DtSetDataMessageVector mySetDataMessages;
   
   DtPostCallbackEntryPendingChanges myPendingSetDataCallbackEntries;

   DtSetDataMessageVector myPendingSetDataMessages;

   bool myExecutingSetDataCallbacks;

   bool myIsGraphCapable;

   bool myShouldGenerateGraphOutput;

   DtUUID myGraphRecipient;

   bool myCantFindDotMsg;
};



typedef DtScriptInterface* (*DtScriptInterfaceCreatorFunc)(DtSimulationServices*);

class DT_DLL_vrfobjcore DtScriptInterfaceFactory
{
protected:
   DtScriptInterfaceFactory();
   DtScriptInterfaceFactory(const DtScriptInterfaceFactory& other);
   DtScriptInterfaceFactory& operator=(const DtScriptInterfaceFactory& other);

public:
   virtual ~DtScriptInterfaceFactory();

   static DtScriptInterfaceFactory* instance();

   virtual DtScriptInterface* createInstance(const DtString& type, DtSimulationServices*);

   virtual void registerCreator(const DtString& type, DtScriptInterfaceCreatorFunc func);

   static void setFactory(DtScriptInterfaceFactory* factory);
   static DtScriptInterfaceFactory* create();

protected:
   std::map<DtString, DtScriptInterfaceCreatorFunc> myCreators;
   static DtScriptInterfaceFactory* theFactoryInstance;
};