scriptedTaskMetaData.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2014 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include "vrfutil/vrfutilDefines.h"
#include "vrfutil/scriptedTaskVariable.h"

#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/set.hpp>

#include <vlutil/vlFilename.h>
#include <vlpi/entityType.h>

#include <set>
#include <map>

#include <tbb/spin_rw_mutex.h>

typedef bool (*DtEncryptDecryptFcn)(const std::string& scriptId, char* input, int inputLen, char** output, int& outputLen, bool encrypt,
   void* usr);

const int DtScriptedTaskScriptedTask = 1;
const int DtScriptedTaskReactiveTask = 2;
const int DtScriptedTaskBackgroundProcess = 3;
const int DtScriptedTaskScriptedSet = 4;
const int DtScriptedTaskScriptedBehavior = 5; 

const int DtScriptedTask_AvailableToAllDoctrines = 0x00000001;
const int DtScriptedTask_ShowOnTopLevelRightClickMenu = 0x00000002;
const int DtScriptedTask_UseUiFile = 0x00000004;
const int DtScriptedTask_MagicCommand = 0x00000010;


class DT_DLL_vrfutil DtScriptedTaskMetaData
{
public:

   DtScriptedTaskMetaData();

   virtual ~DtScriptedTaskMetaData();

   DtScriptedTaskMetaData(const DtScriptedTaskMetaData& orig);

   DtScriptedTaskMetaData& operator=(const DtScriptedTaskMetaData& orig);

   virtual bool load(const DtFilename&);

   virtual bool load(const std::string&);

   virtual bool load(std::istream&);

   virtual bool hasUserEntryVariables() const;

   virtual bool save(const DtFilename&) const;

   virtual bool save(std::string&) const;

   virtual bool save(std::ostream&) const;

   virtual bool save() const;

   virtual void setFilename(const DtFilename&);

   virtual const DtFilename& filename() const;

   virtual const std::string& scriptId() const;

   virtual void setScriptId(const std::string&, bool makeAliasIfSystemScript = true);

   virtual void setScriptType(int);

   virtual int scriptType() const;

   virtual bool usesBehaviorEngine() const;
   virtual void setUsesBehaviorEngine(const bool uses);

   virtual int commandLevel() const;
   virtual void setCommandLevel(int);

   virtual void setMenuText(const std::string&);
   virtual const std::string& menuText() const;

   virtual void setExtendedMenuText(const std::string&);
   virtual const std::string& extendedMenuText() const;

   virtual void setToolTip(const std::string&);
   virtual const std::string& toolTip() const;

   virtual void setMenuIcon(const std::string&);
   virtual const std::string& menuIcon() const;

   virtual void setUseUiFile(bool);
   virtual bool useUiFile() const;

   virtual void setUiLayout(const std::string&);
   virtual const std::string& uiLayout() const;

   virtual void setMagicCommand(bool);
   virtual bool magicCommand() const;

   virtual void setVersion(double);
   virtual double version() const;

   virtual void setPriority(int);
   virtual int priority() const;

   virtual void setEnabled(bool);
   virtual bool enabled() const;

   virtual void setShortDescription(const std::string&);
   virtual const std::string& shortDescription() const;

   virtual  bool variable(const std::string& s, DtScriptedTaskVariable& var) const;

   virtual void setScriptEngine(const std::string&);
   virtual const std::string& scriptEngine() const;

   virtual bool isInterpretedScript() const;

   static void addInterpretedScriptEngine(const std::string&);
   static bool isInterpretedScriptEngine(const std::string&);

   virtual void setComments(const std::string&);
   virtual const std::string& comments() const;

   virtual void setDescription(const std::string&);
   virtual const std::string& description() const;

   virtual void setShowDescriptionInDialog(bool);
   virtual bool showDescriptionInDialog() const;

   virtual void setRespectScriptLocation(bool);
   virtual bool respectScriptLocation() const;

   virtual void setScriptLocation(const std::string&);
   virtual const std::string& scriptLocation() const;

   virtual std::string uiLayoutLocation() const;

   virtual void setMenuLocations(const std::vector<std::string>&);
   virtual void addMenuLocation(const std::string&);
   virtual void removeMenuLocation(const std::string&);
   virtual void removeMenuLocation(int);
   virtual const std::vector<std::string>& menuLocations() const;
   virtual void setShowInMenu(bool);
   virtual bool showInMenu() const;

   virtual void setToolbarLocation(const std::string&);
   virtual const std::string& toolbarLocation() const;
   virtual void setShowInToolbar(bool);
   virtual bool showInToolbar() const;

   virtual void setEntityTypes(const std::vector<DtEntityType>&);
   virtual void addEntityType(const DtEntityType&);
   virtual void removeEntityType(const DtEntityType&);
   virtual void removeEntityType(int);
   virtual std::vector<DtEntityType> entityTypes() const;
   virtual bool supportsEntityType(const DtEntityType&) const;

   virtual bool hasEntityType(const DtEntityType&) const;

   virtual void setVariables(const std::vector<DtScriptedTaskVariable>&);
   virtual void addVariable(const DtScriptedTaskVariable&);
   virtual void insertVariableBefore(const DtScriptedTaskVariable&, const std::string& variable);
   virtual void insertVariableBefore(const DtScriptedTaskVariable&, int i);
   virtual void removeVariable(const std::string&);
   virtual void removeVariable(int);

   virtual std::vector<DtScriptedTaskVariable> variables() const;

   virtual std::vector<DtScriptedTaskVariable> scriptedTaskVariables() const;

   virtual DtRwVariableBindings* defaultVariableBindings() const;

   virtual void setupDefaultsFromBindings(const DtRwVariableBindings&);


   virtual void setScript(const std::string&);
   virtual const std::string& script() const;

   virtual bool loadScript();

   virtual bool loadScript(const std::string&);

   virtual bool loadUiLayout();

   virtual bool loadUiLayout(const std::string&);

   virtual void setIsSystemScript(bool);
   virtual bool isSystemScript() const;

   virtual void setActionCategories(const std::set<std::string>&);
   virtual void addActionCategory(const std::string&);
   virtual void removeActionCategory(const std::string&);
   virtual bool hasActionCategory(const std::string&) const;
   virtual const std::set<std::string>& actionCategories() const;

   virtual void setCanBeExecutedConcurrently(bool);
   virtual bool canBeExecutedConcurrently() const;

   virtual void setDoctrines(const std::set<std::string>&);
   virtual bool addDoctrine(const std::string&);
   virtual bool removeDoctrine(const std::string&);
   virtual bool supportsDoctrine(const std::string&) const;
   virtual const std::set<std::string>& doctrines() const;
   virtual bool renameDoctrine(const std::string& from, const std::string& to);
   virtual void setAvailableToAllDoctrines(bool);
   virtual bool availableToAllDoctrines() const;

   virtual void setShowOnTopLevelRightClickMenu(bool);
   virtual bool showOnTopLevelRightClickMenu() const;

   virtual void setDirectoryPath(const std::string&);
   virtual const std::string& directoryPath() const;

   virtual const std::set<std::string>& aliases() const;
   virtual void addAlias(const std::string&);
   virtual void removeAlias(const std::string&);
   virtual void clearAliases();
   virtual void setAliases(const std::set<std::string>&);
   virtual bool isAliased(const std::string&) const;

   virtual void assignNewScriptId();

   virtual bool supports(const DtEntityType&) const;

   bool operator==(const DtScriptedTaskMetaData&) const;
   bool operator!=(const DtScriptedTaskMetaData& rhs) const { return !(*this == rhs); };

   static void setEncryptDecryptFunction(DtEncryptDecryptFcn, void* usr);
   static void getEncryptDecryptFunction(DtEncryptDecryptFcn&, void*& usr);

   virtual bool encrypt(const std::string& source, std::string& dest) const;

   virtual bool encryptScript();

   virtual bool encryptSize(const std::string& source, int& size) const;

   virtual bool decrypt(const std::string& source, std::string& dest) const;

   virtual bool decryptScript();

   virtual std::auto_ptr<DtRwVariableBindings> upgradeVariables(const DtRwVariableBindings&) const;

   virtual void setEncrypted(bool);
   virtual bool encrypted() const;

   virtual void setFlag(int, bool);
   virtual bool flagSet(int) const;

   virtual void loadTranslationFile(const std::string& lang);
   virtual void translationData(char*& data, unsigned int& len) const;
   virtual std::string translationLanguage() const;
   virtual void clearTranslationData();

   virtual std::string removeTrailingLinefeeds(const std::string&);

   virtual void makeAllIdsLowercase();

protected:
   virtual std::string readFile(const std::string&) const;

protected:

   friend class boost::serialization::access;

   template<class Archive>
      void serialize(Archive & ar, const unsigned int version)
   {
      ar & BOOST_SERIALIZATION_NVP(myScriptId);
      ar & BOOST_SERIALIZATION_NVP(myMenuText);
      ar & BOOST_SERIALIZATION_NVP(myToolTip);
      ar & BOOST_SERIALIZATION_NVP(myMenuIcon);
      ar & BOOST_SERIALIZATION_NVP(myVersion);
      ar & BOOST_SERIALIZATION_NVP(myScriptEngine);
      ar & BOOST_SERIALIZATION_NVP(myComments);
      ar & BOOST_SERIALIZATION_NVP(myMenuLocations);
      ar & BOOST_SERIALIZATION_NVP(myIsSystemScript);
      ar & BOOST_SERIALIZATION_NVP(myDescription);
      ar & BOOST_SERIALIZATION_NVP(myScriptLocation);
      ar & BOOST_SERIALIZATION_NVP(myDirectoryPath);
      ar & BOOST_SERIALIZATION_NVP(myEntityTypes);
      ar & BOOST_SERIALIZATION_NVP(myVariables);
      ar & BOOST_SERIALIZATION_NVP(myScript);

      if (version >= 2)
      {
         ar & BOOST_SERIALIZATION_NVP(myActionCategories);

         if (version >= 3)
         {
            ar & BOOST_SERIALIZATION_NVP(myShowInMenu);
         }

         if (version >= 4)
         {
            ar & BOOST_SERIALIZATION_NVP(myEncrypted);
         }

         if (version >= 5)
         {
            ar & BOOST_SERIALIZATION_NVP(myScriptType);
         }
         else
         {
            myScriptType = DtScriptedTaskScriptedTask;
         }

         if (version >= 6)
         {
            ar & BOOST_SERIALIZATION_NVP(myDoctrines);
            ar & BOOST_SERIALIZATION_NVP(myFlags);
         }
         else
         {
            myFlags = DtScriptedTask_AvailableToAllDoctrines;
         }

         if (version >= 7)
         {
            ar & BOOST_SERIALIZATION_NVP(myShowInToolbar);
            ar & BOOST_SERIALIZATION_NVP(myToolbarLocation);
         }

         if (version >= 8)
         {
            ar & BOOST_SERIALIZATION_NVP(myExtendedMenuText);
         }

         if (version >= 9)
         {
            ar & BOOST_SERIALIZATION_NVP(myShortDescription);
         }

         if (version >= 10)
         {
            ar & BOOST_SERIALIZATION_NVP(myUiLayout);
         }

         if (version >= 11)
         {
            ar & BOOST_SERIALIZATION_NVP(myAliases);
         }

         if (version >= 13)
         {
            ar & BOOST_SERIALIZATION_NVP(myCanBeExecutedConcurrently);
         }

         if (version >= 14)
         {
            ar & BOOST_SERIALIZATION_NVP(myRespectScriptLocation);
         }

         if (version >= 15)
         {
            ar & BOOST_SERIALIZATION_NVP(myShowDescriptionInDialog);
         }

         if (version >= 16)
         {
            ar & BOOST_SERIALIZATION_NVP(myUsesBehaviorEngine);
         }

         if (version >= 17)
         {
            ar & BOOST_SERIALIZATION_NVP(myCommandLevel);
         }

         if (Archive::is_loading::value && (version <= 11))
         {
            makeAllIdsLowercase();
         }
      }
   }

public:
   std::string myScriptId;
   std::string myMenuText;
   std::string myExtendedMenuText;
   std::string myToolTip;
   std::string myMenuIcon;
   std::string myScriptEngine;
   std::string myComments;
   std::string myDescription;
   mutable std::string myScriptLocation;
   std::string myShortDescription;
   std::string myUiLayout;

   mutable std::string myScript;
   std::string myDirectoryPath;
   std::vector<std::string> myMenuLocations;
   std::vector<std::string> myEntityTypes;
   std::vector<std::string> myVariables;
   mutable std::map<std::string, DtScriptedTaskVariable> myCachedVariables;
   std::string myActionCategories;
   std::string myDoctrines;
   bool myShowInMenu;

   std::string myToolbarLocation;
   bool myShowInToolbar;

   mutable std::set<std::string> myActionCategoriesSet;
   mutable std::set<std::string> myDoctrinesSet;

   bool myCanBeExecutedConcurrently;
   bool myRespectScriptLocation;
   bool myShowDescriptionInDialog;

   double myVersion;
   mutable DtFilename myFile;
   bool myIsSystemScript;
   mutable bool myEncrypted;

   static DtEncryptDecryptFcn theEncryptDecryptFunction;
   static void* theEncryptDecryptUserData;

   int myScriptType;
   bool myUsesBehaviorEngine;
   int myFlags;

   char* myTranslationData;
   DtU64 myTranslationDataLen;
   std::string myTranslationLanguage;
   int myCommandLevel;

   std::set<std::string> myAliases;

   static std::vector<std::string> theInterpretedScriptEngines;

   mutable tbb::spin_rw_mutex myVariableMutex;
   mutable tbb::spin_rw_mutex myActionCategoriesMutex;
};

namespace DtBufferSerialize
{
   DT_DLL_vrfutil int getSize(const DtScriptedTaskMetaData& v);
   DT_DLL_vrfutil char *encode(const DtScriptedTaskMetaData& val, char *buffer);
   DT_DLL_vrfutil const char *decode(DtScriptedTaskMetaData& val, const char *buffer);
}

BOOST_CLASS_VERSION(DtScriptedTaskMetaData, 17)