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/env.h"
#include "mtl/envXMLWriter.h"
#include "vrfobjparam/vrfObjParams.h"
#include "vrfobjparam/vrfParamDb.h"
#include "vrfobjparam/mtlParamDbEntry.h"
#include "vrfobjparam/dfltParamFact.h"
#include "vrfutil/rwRegData.h"
#include "extMtl/extFileInputStream.h"
#include "extMtl/extDtcRead.h"
#include "vrfExtProtocol/objType.h"
#include "vrfExtProtocol/rangedObjType.h"
#include "vrfobjparam/vrfXmlTypes.h"
#include "vrfutil/nLenIntVec.h"
#include "vrfutil/rwNLengthStringVector.h"
#include "vrfobjparam/embarkationSlotEntry.h"
#include "vrfutil/subObjList.h"
#include "vrfutil/subObjEntry.h"
#include "vrfutil/formTbl.h"
#include "vrfutil/formTblEntry.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 "vrfutil/rdrWritr.h"
#include "vrfutil/readerWriterFactory.h"

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


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

   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);

   static DtString getPlatform(DtEnvironmentSP env, DtEnvValueSP root)
   {
      return getAttribute(env, vrfXml::Platform, 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, vrfXml::Bool, 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, vrfXml::Real, 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, vrfXml::String, 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(MtlBindingCharToXml(value));
         return attr;
      }
      
      return attr = env->addAttribute(name, MtlBindingCharToXml(value), root);
   }

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

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

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

   static DtObjectType StringToObjectType(const std::string& str)
   {
      if (str.length() == 0)
      {
         return DtObjectType::nullType();
      }

      char* p = (char*)str.c_str();
      DtObjectType objectType;

      objectType[7] = ((int)strtol(p, &p, 0));
      if (*p) p++;
      objectType[0] = ((int)strtol(p, &p, 0));
      if (*p) p++;
      objectType[1] = ((int)strtol(p, &p, 0));
      if (*p) p++;
      objectType[2] = ((int)strtol(p, &p, 0));
      if (*p) p++;
      objectType[3] = ((int)strtol(p, &p, 0));
      if (*p) p++;
      objectType[4] = ((int)strtol(p, &p, 0));
      if (*p) p++;
      objectType[5] = ((int)strtol(p, &p, 0));
      if (*p) p++;
      objectType[6] = ((int)strtol(p, &p, 0));

      return objectType;
   }

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

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

      return objectType;
   }

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

      return matchType;
   }

   static DtRangedObjectType getRangedObjectType(DtEnvironmentSP env, 
      const DtString& attributeName, DtEnvValueSP root);

   static double getDoubleAttribute(DtEnvironmentSP env, DtString attributeName, DtEnvValueSP root)
   {
      return boost::lexical_cast<double>(getAttribute(env, attributeName, root));
   }

   static int getIntegerFromHex(DtEnvironmentSP env, const DtString& attributeName, DtEnvValueSP root)
   {
      char* p = 0;
      return strtoul(getAttribute(env, attributeName, root), &p, 0);
   }

   static int getInt(DtEnvironmentSP env, const DtString& attributeName, DtEnvValueSP root)
   {
      std::string attr = getAttribute(env, attributeName, root).c_str();
      std::stringstream stringStream(attr);
      int asInt;
      stringStream >> asInt;
      return asInt;
   }

   //Convert a string to a bool, allowing 0/1 and "True"/"False" case insensitive
   static bool ToBool(const DtString& str) 
   {
      std::string stdStr = str.c_str();
      std::transform(stdStr.begin(), stdStr.end(), stdStr.begin(), ::tolower);
      std::istringstream is(stdStr);
      bool b;
      is >> std::boolalpha >> b;
      return b;
   }

   static bool getBoolAttribute(DtEnvironmentSP env, const DtString& attributeName, DtEnvValueSP root)
   {
      return ToBool(getAttribute(env, attributeName, root));
   }

   static void ExtractBindings(DtVariableBindingsList& list, 
      const DtFilename& searchPath, 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, vrfXml::Yaw, parentNode));
      orientation.setTheta(getDoubleAttribute(env, vrfXml::Pitch, parentNode));
      orientation.setPhi(getDoubleAttribute(env, vrfXml::Roll, parentNode));
   }

   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, vrfXml::BodyForward, root))
      {
         x = getDoubleAttribute(env, vrfXml::BodyForward, root);
         y = getDoubleAttribute(env, vrfXml::BodyRight, root);
         z = getDoubleAttribute(env, vrfXml::BodyDown, root);
      }
      else
      {
         x = getDoubleAttribute(env, vrfXml::VectorX, root);
         y = getDoubleAttribute(env, vrfXml::VectorY, root);
         z = getDoubleAttribute(env, vrfXml::VectorZ, root);
      }
   }

   //Finds children by types in DtBindingTypes.  Creates and initializes the rwObjects.
   //bindingType will be used to specify which type of entries are in the list.  If unspecified,
   //all binding types will be checked.
   static void PopulateList(
      boost::function<void (DtReaderWriter*)> addFunction, 
      DtEnvironmentSP env, DtEnvValueSP root, const DtFilename& searchPath,
      const DtVariableBindingsList& bindings,
      const vrfXml::TypeList& bindingTypes = vrfXml::theBindingTypes.types);

   static void CreateVariableBinding(const DtString& bindingType,
      const DtFilename& searchPath, const DtVariableBindingsList& systemBindings,
      DtRwVariableBindings& newBindings, 
      DtEnvironmentSP env, DtEnvValueSP binding);

   static void AddSystems(DtComponentSystemDescriptorList& list, 
      const DtVariableBindingsList& variableBindings, DtEnvironmentSP env,
      DtEnvValueSP* root, const DtFilename& searchPath);

   static void AddSystem(DtComponentSystemDescriptorList& list, 
      DtEnvironmentSP env, const DtVariableBindingsList& variableBindings, 
      DtEnvValueSP root, const DtFilename& searchPath, 
      DtEnvironmentSP parentEnt = DtEnvironmentSP(), DtString systemName = "");

   static DtEnvironmentSP CreateVrfXmlEnvironment();

   static DtEnvironmentSP CreateVrfXmlEnvironment(
      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 DtReplaceAllSubstrings(str, vrfXml::XmlVariableChar, 
         vrfXml::MtlVariableChar);
   }

   static DtString MtlBindingCharToXml(const DtString& str)
   {
      return DtReplaceAllSubstrings(str, vrfXml::MtlVariableChar, 
         vrfXml::XmlVariableChar);
   }

   static DtString NLengthIntListToString(const DtNLengthIntegerVector& list);

   static DtString NLengthStringListToString(const DtRwNLengthStringVector& list);

   static void StringToNLengthIntList(const DtString& string, DtNLengthIntegerVector& list);

   static void StringToNLengthStringList(const DtString& string, DtRwNLengthStringVector& list);

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

   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 DtXmlUtils::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 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 void WriteXML(DtEnvironmentSP env, DtString filename)
   {
      DtEnvXMLWriter writer(vrfXml::SimObject);
      writer.writeFile(*env, filename);
   }

   static DtString removeQuotes(const DtString& str)
   {
      const char quote('"');
      DtString output(str);
      if (output[0] == quote && output[output.size() - 1] == quote)
      {
         output.snipFront(quote);
         output.snipBack(quote);
      }
      return output;
   }

   typedef std::list<DtString> NameList;

   static void WriteVector(DtEnvironmentSP env, DtEnvValueSP root,
      const DtRwVector* vec, bool writeAsBodyPosition)
   {
      if (writeAsBodyPosition)
      {
         env->addAttribute(vrfXml::BodyRight, (*vec)[1], root);
         env->addAttribute(vrfXml::BodyForward, (*vec)[0], root);
         env->addAttribute(vrfXml::BodyDown, (*vec)[2], root);
      }
      else
      {
         env->addAttribute(vrfXml::VectorX, (*vec)[0], root);
         env->addAttribute(vrfXml::VectorY, (*vec)[1], root);
         env->addAttribute(vrfXml::VectorZ, (*vec)[2], root);
      }
   }

   static bool WriteAsBodyPosition(const DtReaderWriter* rwObject)
   {
      return vrfXml::RwTypeToXmlType(rwObject) == vrfXml::BodyPosition;
   }

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