xmlToRw.h

Go to the documentation of this file.

#pragma once

#include "vrfobjparam/vrfXmlUtils.h"
#include "vrfutil/rwInt.h"
#include "vrfutil/rwReal.h"
#include "vrfutil/rwString.h"
#include "vrfutil/rwVector.h"
#include "vrfutil/rwBoolean.h"
#include "vrfutil/rsrcMgr.h"
#include "vrfutil/rwVariableBindings.h"
#include "vrfutil/readerWriterFactory.h"
#include "vrfutil/rwTypes.h"
#include "vrfutil/rwEntType.h"
#include "vrfobjparam/compSystemDescriptorList.h"
#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>

class DT_DLL_vrfobjparam DtXmlToRw
{
public:


   typedef boost::function<void (DtReaderWriter* rwObject)> AddFunction;

   struct RwObjectAdder
   {
      RwObjectAdder(DtRwList* list) : myList(list) {}
      void operator()(DtReaderWriter* rwObject)
      {
         myList->add(rwObject);
      }
      DtRwList* myList;
   };

   struct SubordinateAdder
   {
      SubordinateAdder(DtVrfSubObjectParameterList* list) : myList(list) {}
      void operator()(DtReaderWriter* rwObject)
      {
         myList->addSubObjectEntry(*static_cast<DtVrfSubObjectParameterEntry*>(rwObject));
      }
      DtVrfSubObjectParameterList* myList;
   };

   struct FormationAdder
   {
      FormationAdder(DtFormationTable* formations, 
         const DtFilename& searchPath, const DtVariableBindingsList& bindings) 
         : myFormations(formations) 
         , mySearchPath(searchPath)
         , myBindings(bindings) 
      {

      }

      void operator()(DtReaderWriter* rwObject)
      {
         DtFormationTableEntry* entry = static_cast<DtFormationTableEntry*>(rwObject);
         entry->formationFile().loadFile(mySearchPath, myBindings);
         myFormations->addFormationEntry(entry);
      }
      DtFormationTable* myFormations;
      const DtFilename& mySearchPath;
      const DtVariableBindingsList& myBindings;
   };

   struct SoilFactorsAdder
   {
      SoilFactorsAdder(DtRwList* list) : myList() 
      {
         myList = static_cast<DtSoilList*>(list);
      }

      void operator()(DtReaderWriter* rwObject)
      {
         DtSoilFactors* factors = static_cast<DtSoilFactors*>(rwObject);
         myList->addSoilFactors(*factors);
      }
      DtSoilList* myList;
   };


   template <class RwType, class basicType>
   static void DtEnvValueToBasicType(DtEnvironmentSP, 
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtString bindingValue = envObject->value();
      RwType* rwTypeObject = static_cast<RwType*>(rwObject);
      (*rwTypeObject) = boost::lexical_cast<basicType>(bindingValue.c_str());
   }

   static void DtEnvValueToRwBool(DtEnvironmentSP, 
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtRwBoolean* rwBool = static_cast<DtRwBoolean*>(rwObject);
      DtString bindingValue = envObject->value();      
      (*rwBool) = DtXmlUtils::ToBool(bindingValue);
   }

   static void DtEnvValueToRwString(DtEnvironmentSP, 
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtRwString* rwString = static_cast<DtRwString*>(rwObject);
      DtString bindingValue = DtXmlUtils::XmlBindingCharToMtl(envObject->value());      
      (*rwString) = bindingValue;
   }


   static void DtEnvValueToRwVector(DtEnvironmentSP env, 
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtRwVector* rwVector = static_cast<DtRwVector*>(rwObject);
      DtXmlUtils::getXYZAttrs(env, envObject, (*rwVector)[0], (*rwVector)[1], (*rwVector)[2]);
   }

   static void DtEnvValueToRwOffsetVector(DtEnvironmentSP env, 
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtRwOffsetVector* rwVector = static_cast<DtRwOffsetVector*>(rwObject);
      DtXmlUtils::getXYZAttrs(env, envObject, (*rwVector)[0], (*rwVector)[1], (*rwVector)[2]);
   }

   static void DtEnvValueToRwList(DtEnvironmentSP env, 
      const DtEnvValueSP envObject, DtReaderWriter* rwObject, 
      const DtFilename& searchPath, const DtVariableBindingsList& bindings,
      const vrfXml::TypeList& bindingTypes)
   {
      DtRwList* rwList = static_cast<DtRwList*>(rwObject);
      RwObjectAdder adder(rwList);
      DtXmlUtils::PopulateList(boost::ref(adder), env, envObject, searchPath, bindings, bindingTypes);
   }

   static void DtEnvValueToRwBoundingVolume(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtRwBoundingVolume* rwBVolume = static_cast<DtRwBoundingVolume*>(rwObject);
      DtEnvValueSP dimensions = env->getObject(vrfXml::Dimensions, vrfXml::Dimensions, envObject);
      
      double length = DtXmlUtils::getDoubleAttribute(env, vrfXml::Length, dimensions);
      double width = DtXmlUtils::getDoubleAttribute(env, vrfXml::Width, dimensions);
      double height = DtXmlUtils::getDoubleAttribute(env, vrfXml::Height, dimensions);
      rwBVolume->setHalfLengthWidthHeight(length/2, width/2, height/2);

      DtString offsetType = DtXmlUtils::getAttribute(env, vrfXml::OffsetType, envObject);
      if (offsetType == vrfXml::OffsetTypeCenter)
      {
         rwBVolume->setLatticeOffset(0.0, 0.0, 0.0);
      }
      else if (offsetType == vrfXml::OffsetTypeGroundCenter)
      {
         rwBVolume->setLatticeOffset(0.0, 0.0, -height/2);
      }
      else if (offsetType == vrfXml::OffsetTypeCustom)
      {
         DtEnvValueSP offset = env->getObject(vrfXml::Offset, vrfXml::Offset, envObject);
         double forward = DtXmlUtils::getDoubleAttribute(env, vrfXml::BodyForward, offset);
         double right = DtXmlUtils::getDoubleAttribute(env, vrfXml::BodyRight, offset);
         double up = DtXmlUtils::getDoubleAttribute(env, vrfXml::BodyDown, offset);         
         rwBVolume->setLatticeOffset(forward, right, up);
      }
   }

   static void DtEnvValueToRwLoadPoints(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      vrfXml::TypeList types;
      types.push_back(vrfXml::LoadPoint);
      DtRwList* rwList = static_cast<DtRwList*>(rwObject);
      RwObjectAdder adder(rwList);
      DtXmlUtils::PopulateList(boost::ref(adder), env, envObject, searchPath, bindings, types);
   }

   static void DtEnvValueToRwLoadPoint(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      DtLoadPoint* loadPoint = static_cast<DtLoadPoint*>(rwObject);
      DtString supportedSlots = DtXmlUtils::getAttribute(env, vrfXml::SupportedSlots, envObject);
      
      DtXmlUtils::StringToNLengthIntList(supportedSlots, loadPoint->supportedSlots());      

      vrfXml::TypeList types;
      types.push_back(vrfXml::Vector);
      RwObjectAdder adder(&loadPoint->points());
      DtXmlUtils::PopulateList(boost::ref(adder), env, envObject, searchPath, bindings, types);
   }

   static void DtEnvValueToEmbarkationSlots(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      vrfXml::TypeList types;
      types.push_back(vrfXml::EmbarkationSlot);
      RwObjectAdder adder(static_cast<DtRwList*>(rwObject));
      DtXmlUtils::PopulateList(boost::ref(adder), env, envObject, searchPath, bindings, types);
   }   
   
   static void DtEnvValueToEmbarkationSlot(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtEmbarkationSlotEntry* embSlot = static_cast<DtEmbarkationSlotEntry*>(rwObject);
      embSlot->setObject(DtXmlUtils::getRangedObjectType(env, vrfXml::EmbarkableObject, envObject));
      embSlot->setAppearance(DtXmlUtils::getIntegerFromHex(env, vrfXml::EmbarkedAppearance, envObject));
      embSlot->setNumberOfEntities(DtXmlUtils::getInt(env, vrfXml::Capacity, envObject));
      embSlot->setJumpToLocation(DtXmlUtils::getBoolAttribute(env, vrfXml::JumpToLocation, envObject));
      embSlot->setTurnToHeading(DtXmlUtils::getBoolAttribute(env, vrfXml::TurnToHeading, envObject));

      DtEnvValueSP embarkedPosition = env->getObject(vrfXml::EmbarkedPosition, vrfXml::EmbarkedPosition, envObject);
      double x, y, z;
      DtXmlUtils::getXYZAttrs(env, embarkedPosition, x, y, z);
      embSlot->setPosition(DtVector(x, y, z));

      DtTaitBryan orientation;

      DtEnvValueSP embarkedHeading = env->getObject(vrfXml::EmbarkedHeading, vrfXml::EmbarkedHeading, envObject);
      if (embarkedHeading.get())
      {
         orientation.setPsi(DtDeg2Rad(boost::lexical_cast<double>(embarkedHeading->value().c_str())));
      }
      else
      {
         DtEnvValueSP embarkedOrientation = env->getObject(vrfXml::EmbarkedOrientation, vrfXml::EmbarkedOrientation, envObject);
         DtXmlUtils::getOrientation(env, embarkedOrientation, orientation);
      }
      
      embSlot->setOrientation(orientation);
   }

   static void DtEnvValueToSubObjectList(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      vrfXml::TypeList types;
      types.push_back(vrfXml::Subordinate);
      SubordinateAdder adder(static_cast<DtVrfSubObjectParameterList*>(rwObject));
      DtXmlUtils::PopulateList(boost::ref(adder), env, envObject, searchPath, bindings, types);
   }

   static void DtEnvValueToSubObject(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtVrfSubObjectParameterEntry* rwSub = static_cast<DtVrfSubObjectParameterEntry*>(rwObject);
      rwSub->setObjectType(DtXmlUtils::getMatchType(env, envObject));
      rwSub->setHeadingOffset(DtXmlUtils::getDoubleAttribute(env, vrfXml::HeadingOffset, envObject));
      double x, y, z;
      DtXmlUtils::getXYZAttrs(env, envObject, x, y, z);
      rwSub->setPositionOffset(DtVector(x, y, z));
   }

   static void DtEnvValueToFormationList(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      vrfXml::TypeList types;
      types.push_back(vrfXml::Formation);
      DtFormationTable* rwFormations = static_cast<DtFormationTable*>(rwObject);
      FormationAdder adder(rwFormations, searchPath, bindings);
      DtXmlUtils::PopulateList(boost::ref(adder), env, envObject, searchPath, bindings, types);      

      rwFormations->setAutoLayoutForGui(DtXmlUtils::getBoolAttribute(env, vrfXml::AutoLayoutForGui, envObject));
   }

   static void DtEnvValueToFormationTableEntry(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtFormationTableEntry* formation = static_cast<DtFormationTableEntry*>(rwObject);
      formation->setFormationName(DtXmlUtils::getAttribute(env, vrfXml::FormationName, envObject).c_str());
      formation->formationFile() = DtXmlUtils::getAttribute(env, vrfXml::FormationFile, envObject).c_str();
   }

   static void DtEnvValueToNLengthStringVector(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtRwNLengthStringVector* vector = static_cast<DtRwNLengthStringVector*>(rwObject);
      DtString strings = envObject->value();
      DtXmlUtils::StringToNLengthStringList(strings, *vector);
   }

   static void DtEnvValueToRwSoilList(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      vrfXml::TypeList types;
      types.push_back(vrfXml::SoilFactors);
      DtRwList* rwList = static_cast<DtRwList*>(rwObject);
      SoilFactorsAdder adder(rwList);
      DtXmlUtils::PopulateList(boost::ref(adder), env, envObject, searchPath, bindings, types);
   }

   static void DtEnvValueToRwSoilFactors(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      DtSoilFactors* factors = static_cast<DtSoilFactors*>(rwObject);
      factors->setName(DtXmlUtils::getAttribute(env, vrfXml::SoilType, envObject).c_str());
      factors->setAccelerationFactor(DtXmlUtils::getDoubleAttribute(env, vrfXml::AccelerationFactor, envObject));
      factors->setStoppingFactor(DtXmlUtils::getDoubleAttribute(env, vrfXml::StoppingFactor, envObject));
      factors->setMaxSpeedFactor(DtXmlUtils::getDoubleAttribute(env, vrfXml::MaxSpeedFactor, envObject));
   }

   static void DtEnvValueToRwTaitBryan(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      DtRwTaitBryan* taitBryan = static_cast<DtRwTaitBryan*>(rwObject);
      taitBryan->setPhi(DtXmlUtils::getDoubleAttribute(env, vrfXml::Yaw, envObject));
      taitBryan->setTheta(DtXmlUtils::getDoubleAttribute(env, vrfXml::Pitch, envObject));
      taitBryan->setPsi(DtXmlUtils::getDoubleAttribute(env, vrfXml::Roll, envObject));
   }

   static void DtEnvValueToRwEntityType(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      DtRwEntityType* entityType = static_cast<DtRwEntityType*>(rwObject);
      (*entityType) = envObject->value().c_str();
   }

   static void DtEnvValueToRwBoundingGeometryType(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      DtRwBoundingGeometryType* bgType = static_cast<DtRwBoundingGeometryType*>(rwObject);
      DtString value = envObject->value();
      if (value == vrfXml::BoundingGeometryArea) 
         bgType->setValue(DtSimBoundingGeometry::BoundingTypeArea);
      else if (value == vrfXml::BoundingGeometryVolume) 
         bgType->setValue(DtSimBoundingGeometry::BoundingTypeVolume);
      else if (value == vrfXml::BoundingGeometryUndefined) 
         bgType->setValue(DtSimBoundingGeometry::BoundingTypeUndefined);
      else
         DtWarn << "Unknown bounding geometry type " << value << std::endl;
   }

   static void DtEnvValueToSlotExclusions(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename& searchPath, const DtVariableBindingsList& bindings)
   {
      vrfXml::TypeList types;
      types.push_back(vrfXml::SlotExclusion);
      DtRwList* rwList = static_cast<DtRwList*>(rwObject);
      RwObjectAdder adder(rwList);
      DtXmlUtils::PopulateList(boost::ref(adder), env, envObject, searchPath, bindings, types);
   }

   static void DtEnvValueToSlotExclusion(DtEnvironmentSP env,
      const DtEnvValueSP envObject, DtReaderWriter* rwObject,
      const DtFilename&, const DtVariableBindingsList&)
   {
      DtSlotExclusion* exclusion = static_cast<DtSlotExclusion*>(rwObject);
      
      DtString ifSlotsReserved = DtXmlUtils::getAttribute(env, vrfXml::IfSlotsReserved, envObject);      
      DtNLengthIntegerVector ifReservedList;
      DtXmlUtils::StringToNLengthIntList(ifSlotsReserved, ifReservedList);
      exclusion->setIfSlotsReserved(ifReservedList);

      DtString excludeTheseSlots = DtXmlUtils::getAttribute(env, vrfXml::ExcludeTheseSlots, envObject);      
      DtNLengthIntegerVector excludeList;
      DtXmlUtils::StringToNLengthIntList(excludeTheseSlots, excludeList);
      exclusion->setExcludeTheseSlots(excludeList);
   }


   //Handles assignment from DtEnvValueSP objects to DtReaderWriter objects
   class DT_DLL_vrfobjparam Converter
   {
   public:
      typedef boost::function<void (DtEnvironmentSP, DtEnvValueSP, DtReaderWriter*, 
          const DtFilename&, const DtVariableBindingsList&)> ConversionFunction;

      Converter()
         : myRwConverters()
      {
         registerConverter(vrfXml::Int, &DtEnvValueToBasicType<DtRwInt, int>);
         registerConverter(vrfXml::Real, &DtEnvValueToBasicType<DtRwReal, double>);
         registerConverter(vrfXml::String, &DtEnvValueToRwString);
         registerConverter(vrfXml::BodyPosition, &DtEnvValueToRwOffsetVector);
         registerConverter(vrfXml::Vector, &DtEnvValueToRwVector);
         registerConverter(vrfXml::Bool, &DtEnvValueToRwBool);
         registerConverter(vrfXml::BoundingVolume, &DtEnvValueToRwBoundingVolume);
         registerConverter(vrfXml::LoadPoints, &DtEnvValueToRwLoadPoints);
         registerConverter(vrfXml::LoadPoint, &DtEnvValueToRwLoadPoint);
         registerConverter(vrfXml::EmbarkationSlots, &DtEnvValueToEmbarkationSlots);
         registerConverter(vrfXml::EmbarkationSlot, &DtEnvValueToEmbarkationSlot);
         registerConverter(vrfXml::Subordinates, &DtEnvValueToSubObjectList);
         registerConverter(vrfXml::Subordinate, &DtEnvValueToSubObject);
         registerConverter(vrfXml::Formations, &DtEnvValueToFormationList);
         registerConverter(vrfXml::Formation, &DtEnvValueToFormationTableEntry);
         registerConverter(vrfXml::StringList, &DtEnvValueToNLengthStringVector);
         registerConverter(vrfXml::SoilList, &DtEnvValueToRwSoilList);
         registerConverter(vrfXml::SoilFactors, &DtEnvValueToRwSoilFactors);
         registerConverter(vrfXml::Orientation, &DtEnvValueToRwTaitBryan);
         registerConverter(vrfXml::EntityType, &DtEnvValueToRwEntityType);
         registerConverter(vrfXml::BoundingGeometryType, &DtEnvValueToRwBoundingGeometryType);
         registerConverter(vrfXml::SlotExclusions, &DtEnvValueToSlotExclusions);
         registerConverter(vrfXml::SlotExclusion, &DtEnvValueToSlotExclusion);
      }

      void convert(DtEnvironmentSP env, const DtFilename& searchPath, 
         const DtVariableBindingsList& bindings, DtEnvValueSP envValue, DtReaderWriter* rwObject)
      {
         if (!envValue.get())
         {
            DtWarn << "DtXmlRWFactory::convert null env value" << std::endl;
            return;
         }
         if (!rwObject)
         {
            DtWarn << "DtXmlRWFactory::convert null rw object" << std::endl;
            return;
         }

         DtString xmlType = vrfXml::RwTypeToXmlType(rwObject);
         if (myRwConverters.find(xmlType) != myRwConverters.end())
         {
            myRwConverters[xmlType](env, envValue, rwObject, searchPath, bindings);
         }
         else
         {
            DtWarn << "DtXmlRWFactory: No Converter for type " 
               << rwObject->readerWriterType() << std::endl;
         }
      }

      void registerConverter(DtString type, ConversionFunction conversionFunction)
      {
         myRwConverters[type] = conversionFunction;
      }

   protected:
      std::map<DtString, ConversionFunction> myRwConverters;
   };

   static Converter& getConverter();

   static void Convert(DtEnvironmentSP env, DtEnvValueSP envValue, DtReaderWriter* rwObject);
};