vrfXmlUtils.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjparam/vrfobjparamDefines.h"
#include "vrfobjparam/vrfXmlTypes.h"
#include "mtl/environment.h"
#include "mtl/envXmlWriter.h"
#include "vrfobjparam/vrfObjectParameters.h"
#include "vrfobjparam/vrfParameterDb.h"
#include "vrfobjparam/mtlParameterDbEntry.h"
#include "vrfobjparam/defaultParameterFactory.h"
#include <readerWriter/readerWriterRegistryData.h>
#include "extMtl/extFileInputStream.h"
#include "extMtl/extDtcRead.h"
#include "vrfExtProtocol/objectType.h"
#include "vrfExtProtocol/rangedObjectType.h"
#include "vrfutil/nLengthIntegerVector.h"
#include "vrfutil/rwNLengthStringVector.h"
#include "vrfobjparam/embarkationSlotEntry.h"
#include "vrfutil/vrfSubObjectParameterList.h"
#include "vrfutil/vrfSubObjectParameterEntry.h"
#include "vrfutil/formationTable.h"
#include "vrfutil/formationTableEntry.h"
#include "vrfutil/soilList.h"
#include "vrfutil/soilFactors.h"

#include "vlutil/vlStringUtil.h"
#include "vlutil/vlFilename.h"

#include <boost/function.hpp>
#include <boost/lexical_cast.hpp>

#include <iostream>
#include <readerWriter/readerWriter.h>
#include "vrfutil/vrfutilReaderWriterFactory.h"

class DT_DLL_vrfobjparam DtVrfXmlUtils
{
public:
   typedef std::list<DtEnvValueSP> DtEnvValueSPList;


   static void getObjectElements(DtEnvironmentSP env, DtEnvValueSPList& objectNodes);

   static DtEnvValueSP addObjectElement(DtEnvironmentSP env, DtObjectType objType, DtObjectType matchType,
      DtString platform, DtString parentFile = "");

   static DtEnvValueSP findObjectElementByMatchType(DtEnvironmentSP env, const DtObjectType& objType);
   static DtEnvValueSP findObjectElementByObjectType(DtEnvironmentSP env, const DtObjectType& objType);

   static DtString getAttribute(DtEnvironmentSP env, const DtString& name, 
      DtEnvValueSP root);

   static bool hasAttribute(DtEnvironmentSP env, const DtString& name,
      DtEnvValueSP root);

   static bool FindAndRemove(DtEnvironmentSP env, const DtString& nodeType, const DtString& paramName, DtEnvValueSP root);

   static void remove(DtEnvironmentSP, DtEnvValueSP);


   //get a specific element in the hierarchy based on its first param name, e.g. "articulated-parts". Argument is a pointer to the simObject tag
   static DtEnvValueSP getTagByAttribute(DtEnvironmentSP env, DtEnvValueSP simObjectNode, DtString attr);

   //get a specific system element in the hierarchy based on its systemName, e.g. "other-10". Argument is a pointer to the simObject tag
   static DtEnvValueSP getSystemByAttribute(DtEnvironmentSP env, DtEnvValueSP simObjectNode, DtString sysName);

   static DtString getPlatform(DtEnvironmentSP env, DtEnvValueSP root)
   {
      return DtReaderWriter::getAttribute(env, vrfXml::Platform, root);
   }

   static DtString getParentFile(DtEnvironmentSP env, DtEnvValueSP root)
   {
      return DtReaderWriter::getAttribute(env, vrfXml::ParentFile, root);
   }

   static DtString GetObjectValue(DtEnvValueSP root)
   {
      return XmlBindingCharToMtl(root->value());
   }

   static DtEnvValueSP AddElement(DtEnvironmentSP env, const DtString& type, 
      DtEnvValueSP root, const DtString& paramName = DtString::nullString())
   {
      FindAndRemove(env, type, paramName, root);
      DtEnvValueSP newElement = env->addObject(type, type, root);
      if (paramName != DtString::nullString())
      {
         env->addAttribute(vrfXml::ParamName, paramName, newElement);
      }
      return newElement;
   }

   static DtEnvValueSP addbooleanElement(DtEnvironmentSP env, DtEnvValueSP root, const DtString& name, bool value)
   {
      DtEnvValueSP newElement = AddElement(env, DtXMLBooleanType, root, name);
      newElement->setValue(value ? "True" : "False");
      return newElement;
   }

   static DtEnvValueSP addRealElement(DtEnvironmentSP env, DtEnvValueSP root, const DtString& name, double value)
   {
      DtEnvValueSP newElement = AddElement(env, DtXMLRealType, root, name);
      newElement->setValue(DtString(value));
      return newElement;
   }

   static DtEnvValueSP addIntegerElement(DtEnvironmentSP env, DtEnvValueSP root, const DtString& name, double value)
   {
      DtEnvValueSP newElement = AddElement(env, DtXMLIntType, root, name);
      newElement->setValue(DtString(value));
      return newElement;
   }

   static DtEnvValueSP addBooleanAttribute(DtEnvironmentSP env, DtEnvValueSP root, const DtString& name, bool value)
   {
      return env->addAttribute(name, value ? "True" : "False", root);
   }


   static DtEnvValueSP addStringElement(DtEnvironmentSP env, DtEnvValueSP root, const DtString& name, const DtString& value)
   {
      DtEnvValueSP newElement = AddElement(env, DtXMLStringType, root, name);
      newElement->setValue(MtlBindingCharToXml(value));
      return newElement;
   }

   static DtEnvValueSP addStringAttribute(DtEnvironmentSP env, DtEnvValueSP root, const DtString& name, const DtString& value)
   {
      DtEnvValueSP attr = env->getAttribute(name, root);
      if (attr.get())
      {
         attr->setValue(DtMtlBindingCharToXml(value));
         return attr;
      }
      
      return attr = env->addAttribute(name, DtMtlBindingCharToXml(value), root);
   }

   static void setObjectType(DtEnvironmentSP env, DtEnvValueSP root, const DtObjectType& t)
   {
      addStringAttribute(env, root, DtXMLObjectTypeType, t.string());
   }

   static void setMatchType(DtEnvironmentSP env, DtEnvValueSP root, const DtObjectType& t)
   {
      addStringAttribute(env, root, vrfXml::MatchType, t.string());
   }

   static std::list<DtObjectType> additionalMatchTypes(DtEnvironmentSP env, DtEnvValueSP root);
   static void setAdditionalMatchTypes(DtEnvironmentSP env, DtEnvValueSP root, const std::list<DtObjectType>& types);

   static void setPlatform(DtEnvironmentSP env, DtEnvValueSP root, const DtString& t)
   {
      addStringAttribute(env, root, vrfXml::Platform, t);
   }

   static double getDoubleAttribute(DtEnvironmentSP env, DtString attributeName, DtEnvValueSP root)
   {
      return DtRwReal::getDouble(env, attributeName, root);
   }

   static void ExtractBindings(DtVariableBindingsList& list, 
      const DtReaderWriter::SearchPaths& searchPaths, DtEnvironmentSP env, DtEnvValueSP node);

   static DtReaderWriter* CreateRwObject(const DtString& rwType)
   {
      return DtReaderWriter::factory()->createItem(rwType, DtString::nullString(), NULL);
   }

   static void getOrientation(DtEnvironmentSP env, 
      const DtEnvValueSP parentNode, DtTaitBryan& orientation)
   {
      orientation.setPsi(getDoubleAttribute(env, DtXMLYaw, parentNode));
      orientation.setTheta(getDoubleAttribute(env, DtXMLPitch, parentNode));
      orientation.setPhi(getDoubleAttribute(env, DtXMLRoll, parentNode));
   }


   static void CreateVariableBinding(const DtString& bindingType,
      const DtReaderWriter::SearchPaths& searchPaths, const DtVariableBindingsList& systemBindings,
      DtRwVariableBindings& newBindings, 
      DtEnvironmentSP env, DtEnvValueSP binding);

   static void AddSystems(DtComponentSystemDescriptorList& list, 
      const DtVariableBindingsList& variableBindings, DtEnvironmentSP env,
      DtEnvValueSP* root, const DtReaderWriter::SearchPaths& searchPaths);

   static void AddSystem(DtComponentSystemDescriptorList& list, 
      DtEnvironmentSP env, const DtVariableBindingsList& variableBindings, 
      DtEnvValueSP root, const DtReaderWriter::SearchPaths& searchPaths, 
      DtEnvironmentSP parentEnt = DtEnvironmentSP(), DtString systemName = "");

   static DtEnvironmentSP CreateVrfXmlEnvironment();

   static DtEnvironmentSP CreateDtXMLEnvironment(
      const DtString& dataSourceFilename, bool showConsoleOutput = true);

   static DtEnvValueSP GetElementByType(DtEnvironmentSP env,
      const DtString& type, DtEnvValueSP root);

   static DtEnvValueSPList GetElementsByType(DtEnvironmentSP env, const DtString& type,
      DtEnvValueSP root);


   static DtString XmlBindingCharToMtl(const DtString& str)
   {
      return DtXmlBindingCharToMtl(str);
   }

   static DtString MtlBindingCharToXml(const DtString& str)
   {
      return DtMtlBindingCharToXml(str);
   }


   static std::set<DtString> getVariableTypesFromEnvironment(DtEnvValueSP);


   static DtEnvValueSP FindElementByParamName(DtEnvironmentSP env, 
      const DtString& nodeType, const DtString& attributeValue, 
      DtEnvValueSP envValue, bool traverseElements = true)
   {
      return FindElementByAttrValue(env, nodeType, DtXMLParamName,
         attributeValue, envValue, traverseElements);
   }

   static DtEnvValueSP FindElementBySystemName(DtEnvironmentSP env,
      const DtString& nodeType, const DtString& attributeValue,
      DtEnvValueSP envValue, bool traverseElements = true)
   {
      return FindElementByAttrValue(env, nodeType, vrfXml::SystemName,
         attributeValue, envValue, traverseElements);

   }

   static DtEnvValueSP FindElementByAttrValue(DtEnvironmentSP env, 
      const DtString& nodeType, const DtString& attributeName, 
      const DtString& attributeValue, DtEnvValueSP envValue, 
      bool traverseElements = true);

   typedef std::list<DtString> StringVector;
   typedef std::vector<DtReaderWriterRegistryData*> RegDataVector;
   
   typedef std::map<DtString, DtString> GroupMappings;

   static DtReaderWriterRegistryData* DeepFindRw(const DtString& keyword, 
      DtReaderWriterRegistry& registry, StringVector& path);

   static bool IsGroupedElement(const DtString& rwName, 
      const DtVrfXmlUtils::GroupMappings& groupedElements, DtString& groupName);

   static DtEnvValueSP FindGroupElement(DtEnvironmentSP env, 
      DtEnvValueSP parentNode, const DtString& groupName, 
      bool createIfMissing = true);

   static void FindAndRemoveGroupElement(DtEnvironmentSP env,
      DtEnvValueSP parentNode, const DtString& groupName);

   static void IterateOverChildren(DtReaderWriterRegistry& oldRegistry, 
      DtReaderWriterRegistry& newRegistry, DtEnvironmentSP env, 
      DtEnvValueSP root, const GroupMappings& groupedElements, StringVector& path);

   static DtEnvironmentSP sortEnvironment(DtEnvironmentSP);

   static DtEnvValueSP CreateEnvNode(DtEnvironmentSP env, const DtString& name, 
      DtEnvValueSP parent, DtString bindingName = "")
   {
      //pass in name twice to prevent a "name" attribute from being added
      DtEnvValueSP newObject = env->addObject(name, name, parent);
      if (bindingName != "")
      {
         env->addAttribute(DtXMLParamName, bindingName, newObject);
      }
      return newObject;
   }

   static void ExtractVariableBindings(DtRwVariableBindings* variableBindings,
      DtEnvironmentSP env, DtEnvValueSP parentNode);

   static void ExtractSystem(DtReaderWriter* systemObject, DtEnvironmentSP env,
      DtEnvValueSP simObjectNode);

   static void ExtractSystems(DtReaderWriterRegistry& oldRegistry, 
      DtEnvironmentSP env, DtEnvValueSP simObjectNode);

   static DtEnvironmentSP CreateVrfXmlEnvironment(
      const DtString& dataSourceFilename, bool showConsoleOutput = true);
   
   static void addParentToXmlEnvironment(DtEnvironmentSP env, const DtString& dataSourceFilename,
      const DtReaderWriter::SearchPaths, bool showConsoleOutput = true);

   //called internally to track the state across recursive calls. Use this version to ignore an explicit list of tags
   static void addParentToXmlEnvironment(DtEnvironmentSP env, const DtString& dataSourceFilename,
      const DtReaderWriter::SearchPaths, std::vector<DtString>& tagsAlreadySeen, bool showConsoleOutput = true);

   static void WriteXML(DtEnvironmentSP env, DtString filename)
   {
      DtEnvXMLWriter writer(vrfXml::SimObject);

      writer.setIndentation("   ");
      writer.writeFile(*env, filename);
   }

   static DtString removeQuotes(const DtString& str)
   {
      return DtRemoveQuotes(str);
   }

   static DtObjectType getObjectTypeAttr(DtEnvironmentSP env, const DtString& attributeName, DtEnvValueSP root)
   {
      DtString objType = getAttribute(env, attributeName, root);
      DtObjectType ot;
      
      ot = objType.c_str();

      return ot;
   }

   static DtObjectType getMatchType(DtEnvironmentSP env, DtEnvValueSP root, 
      bool fallbackOnObjectType = true)
   {
      DtObjectType matchType = getObjectTypeAttr(env, vrfXml::MatchType, root);
      if (matchType == DtObjectType::nullType() && fallbackOnObjectType)
      {
         return DtRwObjectType::getObjectType(env, root);
      }

      return matchType;
   }

   static std::list<DtObjectType> getMatchTypes(DtEnvironmentSP env, DtEnvValueSP root,
      bool fallbackOnObjectType = true);

   static DtObjectType getObjectType(DtEnvironmentSP env, DtEnvValueSP root, 
      bool fallbackOnMatchType = true)
   {
      DtObjectType objectType = getObjectTypeAttr(env, DtXMLObjectType, root);
      if (objectType == DtObjectType::nullType() && fallbackOnMatchType)
      {
         return getMatchType(env, root, false);
      }

      return objectType;
   }

   static void getXYZAttrs(DtEnvironmentSP env, const DtEnvValueSP root, 
      double& x, double& y, double& z)
   {
      //attributes will either be named "x", "y", "z" or "right", "forward", "up"
      if (hasAttribute(env, DtXMLBodyForward, root))
      {
         x = getDoubleAttribute(env, DtXMLBodyForward, root);
         y = getDoubleAttribute(env, DtXMLBodyRight, root);
         z = getDoubleAttribute(env, DtXMLBodyDown, root);
      }
      else
      {
         x = getDoubleAttribute(env, DtXMLVectorX, root);
         y = getDoubleAttribute(env, DtXMLVectorY, root);
         z = getDoubleAttribute(env, DtXMLVectorZ, root);
      }
   }

   typedef std::list<DtString> NameList;

   static void WriteVector(DtEnvironmentSP env, DtEnvValueSP root,
      const DtRwVector* vec, bool writeAsBodyPosition)
   {
      if (writeAsBodyPosition)
      {
         env->addAttribute(DtXMLBodyForward, (*vec)[1], root);
         env->addAttribute(DtXMLBodyRight, (*vec)[0], root);
         env->addAttribute(DtXMLBodyDown, (*vec)[2], root);
      }
      else
      {
         env->addAttribute(DtXMLVectorX, (*vec)[0], root);
         env->addAttribute(DtXMLVectorY, (*vec)[1], root);
         env->addAttribute(DtXMLVectorZ, (*vec)[2], root);
      }
   }

   static DtString IntToHexString(const int& number)
   {
      char buff[8];
      sprintf(buff, "%X", number);
      DtString app("0X");
      app += buff;
      return app;
   }
};