scriptedTaskTask.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2012 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include "vrftasks/vrftasksDefines.h"
#include "vrftasks/simTask.h"
#include "vrftasks/setDataRequest.h"
#include <readerWriter/rwVariableBindings.h>
#include <readerWriter/rwString.h>
#include "vrfutil/scriptedTaskVariable.h"
#include "vrfutil/vrfScriptedTasksConstants.h"
#include <readerWriter/propertyUtils.h>

#include <vrftasks/stringRepHelper.h>

class DtUUID;
class DtRwOffsetVectorList;
class DtRwVectorList;

class DT_DLL_vrftasks DtScriptedTask
{
public:
   class ScriptedTaskFormatter
   {
   public:
      virtual DtString stringRep(const DtScriptedTask&) const = 0;
      virtual DtString stringRep(const DtString& scriptId, const DtRwVariableBindings& variables, const DtRwVariableBindings& variableDataTypes) const = 0;
   };

   DtScriptedTask() {};
   virtual ~DtScriptedTask() {};

   virtual bool init() = 0;

   virtual const DtString& scriptId() const = 0;
   virtual void setScriptId(const DtString&) = 0;

   virtual DtRwVariableBindings& variables() = 0;
   virtual const DtRwVariableBindings& variables() const = 0;

   virtual DtRwVariableBindings& variableDataTypes() = 0;
   virtual const DtRwVariableBindings& variableDataTypes() const = 0;


   virtual int netRepSize() const = 0;

   virtual bool setFromNet(const char* contentBuffer, 
      unsigned contentSize) = 0;

   virtual char* setToNet(char*) = 0;

   static void setScriptedTaskFormatter(ScriptedTaskFormatter*);
   static ScriptedTaskFormatter* scriptedTaskFormatter();

   virtual DtString allVariablesStringRep(const DtString& scriptName = "") const = 0;

public:
   virtual void setValue(const DtString& variableName, bool, const char* type = DtScriptedTaskCheckBoxVariable);
   virtual void setValue(const DtString& variableName, int, const char* type = DtScriptedTaskIntegerVariable);
   virtual void setValue(const DtString& variableName, double, const char* type = DtScriptedTaskDoubleVariable);
   virtual void setValue(const DtString& variableName, const std::string&, const char* type = DtScriptedTaskStringVariable);
   virtual void setValue(const DtString& variableName, const DtString&, const char* type = DtScriptedTaskStringVariable);
   virtual void setValue(const DtString& variableName, const char*, const char* type = DtScriptedTaskStringVariable);
   virtual void setValue(const DtString& variableName, const DtUUID&, const char* type = DtScriptedTaskSimulationObjectVariable);
   virtual void setValue(const DtString& variableName, const DtVector&, const char* type = DtScriptedTaskLocationVariable);
   virtual void setValue(const DtString& variableName, const DtEntityType&, const char* type = DtScriptedTaskEntityTypeVariable);
   virtual void setValue(const DtString& variableName, const DtTaitBryan&, const char* type = DtScriptedTaskOrientationVariable);   
   virtual void setValue(const DtString& variableName, const DtRwOffsetVectorList&);
   virtual void setValue(const DtString& variableName, const DtRwVectorList&);
   virtual void setValue(const DtString& variableName, const std::vector<DtUUID>&);
   virtual void setValue(const DtString& variableName, const std::vector<DtVector>&);
   virtual void setValue(const DtString& variableName, const std::map<DtString, int>&);
   virtual void setValue(const DtString& variableName, const std::map<DtString, double>&);
   virtual void setValue(const DtString& variableName, const std::map<DtString, DtString>&);

   virtual void setLocation(const DtString& variableName, const DtVector&);
   virtual void setLocationWithoutAltitude(const DtString& variableName, const DtVector&);
   virtual void setOffset(const DtString& variableName, const DtRwOffsetVector&);
   virtual void setTime(const DtString& variableName, double);
   virtual void setDateTime(const DtString& variableName, double);
   virtual void setRange(const DtString& variableName, double);
   virtual void setAltitude(const DtString& variableName, double);
   virtual void setHeading(const DtString& variableName, double);
   virtual void setPitch(const DtString& variableName, double);

   virtual void setValue(const DtString& variableName, const DtReaderWriter&, const char* scriptedTaskType);

   template<typename T>
   struct identity { typedef T type; };

   template <typename RWValue, typename AssignType>
   void setValue(const DtString& variableName, AssignType value, const char* type)
   {
      setValue(variableName, value, type, identity<RWValue>(), identity<AssignType>());
   }

private:
   template <typename RWValue, typename AssignType>
   void setValue(const DtString& variableName, AssignType value, const char* type, identity<RWValue>, identity<AssignType>)
   {
      RWValue* var = new RWValue(variableName);

      *var = value;
      this->variables().addVariable(var);
      this->variableDataTypes().addVariable(new DtRwString(variableName, type));
   }

   void setValue(
      const DtString& variableName, std::map<DtString, DtString> value, const char* type, 
      identity<DtRwStringAttributeList>, identity<std::map<DtString, DtString> >)
   {
      DtRwStringAttributeList* var = new DtRwStringAttributeList(variableName);

      var->setFromMap(value);
      this->variables().addVariable(var);
      this->variableDataTypes().addVariable(new DtRwString(variableName, type));
   }

public:

   template <typename T>
   boost::optional<T> getValue(const DtString& variableName) const
   {
      return findVariableBindingValue<T>(variables(), variableName);
   }

   virtual const DtReaderWriter* getValueRW(const DtString& name) const;
   virtual DtReaderWriter* getValueRW(const DtString& name);


protected:
   static ScriptedTaskFormatter* theScriptedTaskFormatter;
};

template<class T> class DtScriptedTaskTemplate : public T, public DtScriptedTask
{

public:

   DtScriptedTaskTemplate();

   DtScriptedTaskTemplate(const DtString & writeName, 
      DtReaderWriterRegistry * parentRegistry = 0);

   DtScriptedTaskTemplate(const DtString & writeName, const DtScriptedTaskTemplate & orig, 
      DtReaderWriterRegistry * parentRegistry = 0);

   DtScriptedTaskTemplate(const DtScriptedTaskTemplate & orig );

   const DtScriptedTaskTemplate & operator=(const DtScriptedTaskTemplate & orig);

   virtual ~DtScriptedTaskTemplate() override;

   virtual DtString stringRep() const;

   virtual DtString allVariablesStringRep(const DtString& scriptName = "") const override;

   virtual int netRepSize() const override;

   virtual bool setFromNet(const char* contentBuffer, unsigned contentSize) override;

   virtual bool init() override;

   virtual bool setToNet();
   virtual char* setToNet(char*) override;

   virtual DtRwVariableBindings& variables() override;
   virtual const DtRwVariableBindings& variables() const override;

   virtual void setVariables(const DtRwVariableBindings&);

   virtual DtRwVariableBindings& variableDataTypes() override;
   virtual const DtRwVariableBindings& variableDataTypes() const override;

   virtual void setScriptId(const DtString&) override;
   virtual const DtString& scriptId() const override;

   virtual void getSelf(DtlObjPtr args, 
      const DtReaderWriter::SearchPaths& searchPaths = DtReaderWriter::SearchPaths(), 
      const DtVariableBindingsList& variableBindings = DtReaderWriter::nullVariableReference());
   virtual void getSelf(const DtEnvironmentSP, const DtEnvValueSP root,
      const DtReaderWriter::SearchPaths& searchPaths = DtReaderWriter::SearchPaths(), 
      const DtVariableBindingsList& bindings = DtVariableBindingsList());

protected:
   virtual void upgradeVariables();

   virtual void postGetSelf() override;

protected:
   DtRwString myScriptId;
   DtRwVariableBindings myVariables;
   DtRwVariableBindings myVariableDataTypes;
};

class DT_DLL_vrftasks DtScriptedTaskStringRepHelper : public DtStringRepHelper
{
public:
   DtScriptedTaskStringRepHelper() {};
   DtScriptedTaskStringRepHelper(const std::vector<DtScriptedTaskVariable>&);

   virtual ~DtScriptedTaskStringRepHelper() override {};

   virtual bool isDisplayableSymbol(
      const DtString& s, const DtReaderWriter* value, const DtReaderWriter* type) const override;
   virtual bool isDisplayableScriptSymbol(const DtString& scriptId, const DtString& scriptVariableName) const override;

protected:
   std::map<std::string, DtScriptedTaskVariable> myVariables;
};

class DT_DLL_vrftasks DtScriptedTaskTask : public DtScriptedTaskTemplate<DtSimTask>
{
public:
   DtScriptedTaskTask();

   DtScriptedTaskTask(const DtString & writeName, 
      DtReaderWriterRegistry * parentRegistry = 0);

   DtScriptedTaskTask(const DtString & writeName, const DtScriptedTaskTask & orig, 
      DtReaderWriterRegistry * parentRegistry = 0);

   DtScriptedTaskTask(const DtScriptedTaskTask & orig );

   const DtScriptedTaskTask & operator=(const DtScriptedTaskTask & orig);

   virtual ~DtScriptedTaskTask() override;

   virtual const DtSimTaskMessageType& type() const override;

   virtual int scriptPriority() const;

   virtual void setScriptPriority(int);

   virtual bool scriptEnabled() const;

   virtual void setScriptEnabled(bool);

   virtual bool scriptActive() const;

   virtual void setScriptActive(bool);

   virtual DtSimTask* clone(const DtString& name, DtReaderWriterRegistry* parentRegistry = 0) const override;

   static DtSimTask * creator();

protected:
   mutable DtSimTaskMessageType myType;
};

namespace DtBufferSerialize
{
   DT_DLL_vrftasks int getSize(const DtScriptedTask& list);
   DT_DLL_vrftasks char* encode(const DtScriptedTask& list, char* buffer);
   DT_DLL_vrftasks const char* decode(DtScriptedTask& list, const char* buffer);
}