msdlScenarioDescriptionImporterExporter.h

Go to the documentation of this file.

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


#pragma once

#include <vrfutil/scenarioDescriptionImporterExporter.h>
#include <vrfutil/msdlHierarchyPropertyMappings.h>
#include <vrfutil/bufferSerialize.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <matrix/vlVector.h>
#include <vlpi/entityType.h>
#include <geometry/tdbextent.h>

#include <iostream>
#include <fstream>


class DtVrfObject;

#define DtImportDataSetCountryForForce "DtImportDataSetCountryForForce" 





typedef std::string MSDL_UUID;

class DT_DLL_vrfutil DtMSDLScenarioContentsItem
{
public:
   std::string myName;
   std::string myValue;
   
   std::map<std::string, DtMSDLScenarioContentsItem> myChildren;
};

class DT_DLL_vrfutil DtMSDLSimulatedElement
{
public:
   MSDL_UUID myObjectHandle;
   std::string myName;
   MSDL_UUID myForceHandle;
   std::string myEnumeration;
   std::string mySymbolIdentifier;
   std::string myMilitaryEnumeration;
   std::string myOneSAFName;
   std::string myFormation;

   DtVector myLocation;

   double myHeading;
   double mySpeed;

   bool myAggregated;

   std::string mySuperiorHandle;

   DtVrfObject* myObject;

   std::map<std::string, DtMSDLScenarioContentsItem> myContents;
   std::map<MSDL_UUID, DtMSDLSimulatedElement*> mySubordinates;
};

class DT_DLL_vrfutil DtMSDLSimulatedTacticalGraphic
{
public:
   std::string myObjectHandle;
   std::string mySymbolIdentifier;
   std::string myAffiliation;
   std::string myOverlayHandle;
   std::string mySymbolClassChoice;
   std::string myName;
   std::string myEnumeration;
   std::string myForceHandle;
   std::map<std::string, DtMSDLScenarioContentsItem> myContents;

   DtVrfObject* myObject;

   std::vector<DtVector> myLocations;
};

class DT_DLL_vrfutil DtMSDLOverlayLayer
{
public:
   MSDL_UUID myObjectHandle;
   std::string myName;
   bool myVisible;
   std::string myType;

   std::string mySuperiorHandle;

   std::map<std::string, DtMSDLScenarioContentsItem> myContents;
   std::map<MSDL_UUID, DtMSDLSimulatedTacticalGraphic> myTacticalGraphics;
};

typedef std::map<MSDL_UUID, std::string> Associations;

class DT_DLL_vrfutil DtForceSide
{
public:
   int myForceType;              

   std::string myType;           
   std::string myName;
   std::string myCountryCode;
   MSDL_UUID myAllegianceHandle;
   Associations myAssociations;
};

class DT_DLL_vrfutil DtMSDLScenarioDescriptionImporterExporter : public DtScenarioDescriptionImporterExporter
{
public:
   typedef std::map<MSDL_UUID, DtForceSide> ForceSides;
   typedef std::map<MSDL_UUID, DtMSDLSimulatedElement*> OrganizationPtr;
   typedef std::map<MSDL_UUID, DtMSDLSimulatedElement*> EquipmentPtr;
   typedef std::map<MSDL_UUID, DtMSDLOverlayLayer> OverlayLayer;

public:
   DtMSDLScenarioDescriptionImporterExporter();

   virtual ~DtMSDLScenarioDescriptionImporterExporter();

   virtual bool loadScenarioDescription(const DtFilename& file, const std::map<std::string, std::string>& importData,
      const DtMSDLHierarchyPropertyMappings&);

   virtual bool saveScenarioDescription(const DtFilename& file, const DtScenario&) const;

   virtual DtScenarioDescriptionImporterExporter* clone();

   virtual bool importIntoSimulation(DtSimManager*);

   virtual bool importFromSimulation(DtSimManager*, const std::map<std::string, std::string>& exportData,
      const DtMSDLHierarchyPropertyMappings&);

   virtual const EquipmentPtr& equipment() const;

   virtual const OrganizationPtr& organizedOrganization() const;

   virtual const OrganizationPtr& flatOrganization() const;

   virtual const OverlayLayer& overlayLayers() const;

   virtual const ForceSides& forces() const;

   virtual std::string findValue(const std::map<std::string, DtMSDLScenarioContentsItem>&, const std::string& path) const;
   virtual bool hasValue(const std::map<std::string, DtMSDLScenarioContentsItem>&, const std::string& path) const;

   virtual bool organizationUsesForce(MSDL_UUID) const;

   virtual std::string supportedExtensions();

   virtual bool canImportFile(const DtFilename&);

protected:
   virtual std::string pad(int) const;

   virtual bool parseMilitaryScenario(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseScenarioID(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseOptions(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseEnvironment(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseForces(xmlNodePtr,const std::map<std::string, std::string>& importData);

   virtual bool parseForce(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parsePOC(xmlNodePtr);

   virtual std::string content(xmlNodePtr) const;

   virtual bool parseAssociations(xmlNodePtr, Associations&);

   virtual bool parseAssociation(xmlNodePtr, Associations&);

   virtual bool parseOrganizations(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseUnits(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseUnit(xmlNodePtr, const std::map<std::string, std::string>& importData, DtMSDLSimulatedElement& unit);

   virtual bool parseEquipmentItem(xmlNodePtr, const std::map<std::string, std::string>& importData, DtMSDLSimulatedElement& unit);

   virtual void addUnitToFlatOrganization(const DtMSDLSimulatedElement&);

   virtual void addEquipmentToOrganization(const DtMSDLSimulatedElement&);

   virtual bool parseEquipment(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseContents(xmlNodePtr, DtMSDLScenarioContentsItem&);

   virtual bool parseDisposition(xmlNodePtr, DtMSDLSimulatedElement&);

   virtual bool parseOverlays(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseOverlay(xmlNodePtr, const std::map<std::string, std::string>& importData, DtMSDLOverlayLayer&);

   virtual bool parseTacticalGraphics(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual bool parseTacticalGraphic(xmlNodePtr, const std::map<std::string, std::string>& importData, DtMSDLSimulatedTacticalGraphic&);

   virtual std::vector<DtVector> parseAnchorPoints(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual DtVector parseAnchorPoint(xmlNodePtr, const std::map<std::string, std::string>& importData);

   virtual DtVector parseLocation(xmlNodePtr);

   virtual DtVector parseLocationGCC(xmlNodePtr);

   virtual DtVector parseLocationMGRS(xmlNodePtr);

   virtual DtVector parseLocationUTM(xmlNodePtr);

   virtual DtVector parseLocationGDC(xmlNodePtr);

   virtual void convertFlatOrganizationToOrganizationHierarchy();

   virtual std::string enumerationForUnit(const std::string& symbolIdentifier, const DtMSDLSimulatedElement&);

   virtual int forceTypeFromName(const std::string&, int curForce, const std::map<std::string, std::string>&) const;

   virtual std::string countryCodeForForce(MSDL_UUID forceHandle) const;

   virtual void saveScenarioId(std::ostream&, const DtScenario&) const;

   virtual void saveOptions(std::ostream&) const;

   virtual void saveEnvironment(std::ostream&) const;

   virtual void saveForceSides(std::ostream&) const;

   virtual void saveForceSide(std::ostream&, const MSDL_UUID&, const DtForceSide&) const;

   virtual void saveOverlayLayers(std::ostream&) const;
   virtual void saveOverlayLayer(std::ostream&, const DtMSDLOverlayLayer&) const;

   virtual void saveTacticalGraphics(std::ostream&) const;
   virtual void saveTacticalGraphic(std::ostream&, const DtMSDLSimulatedTacticalGraphic&) const;

   virtual void saveAnchorPoints(std::ostream&, const DtMSDLSimulatedTacticalGraphic&, int indent) const;
   virtual void saveAnchorPoint(std::ostream&, const DtVector&, int indent) const;

   virtual void saveOrganizations(std::ostream&) const;

   virtual void saveUnits(std::ostream&) const;
   virtual void saveUnit(std::ostream&, DtMSDLSimulatedElement*) const;

   virtual void saveDisposition(std::ostream&, DtMSDLSimulatedElement*, int indent) const;

   virtual void saveLocation(std::ostream&, DtMSDLSimulatedElement*, int indent) const;
   virtual void saveLocation(std::ostream&, const DtVector&, int indent) const;

   virtual void saveUnitRelations(std::ostream&, DtMSDLSimulatedElement*) const;

   virtual void saveEquipmentRelations(std::ostream&, DtMSDLSimulatedElement*) const;

   virtual void saveUnitModel(std::ostream&, DtMSDLSimulatedElement*) const;

   virtual void saveEquipmentModel(std::ostream&, DtMSDLSimulatedElement*) const;

   virtual void saveOneSAFIdentifiers(std::ostream&, const std::string& type, DtMSDLSimulatedElement*,
      int indent) const;

   virtual void saveUnitSymbolModifiers(std::ostream&, DtMSDLSimulatedElement*) const;
   virtual void saveFormationPosition(std::ostream&, DtMSDLSimulatedElement*, int indent) const;
   virtual void saveOwnFormation(std::ostream&, DtMSDLSimulatedElement*, int indent) const;

   virtual void saveEquipmentSymbolModifiers(std::ostream&, DtMSDLSimulatedElement*) const;
   virtual void saveOneSAFBasicLoadInformation(std::ostream&, DtMSDLSimulatedElement*) const;

   virtual void saveSymbolClassData(std::ostream&, const DtMSDLSimulatedTacticalGraphic&) const;

   virtual void saveEquipment(std::ostream&) const;
   virtual void saveEquipmentItem(std::ostream&, DtMSDLSimulatedElement*) const;

   virtual void finalize();

protected:
   xmlDocPtr myDoc;
   ForceSides myForces;

   OrganizationPtr myOrganizedOrganization;
   OrganizationPtr myFlatOrganization;
   EquipmentPtr myEquipment;
   OverlayLayer myOverlayLayers;

   OrganizationPtr myPendingMatches;

   DtMSDLHierarchyPropertyMappings myHierarchyPropertyMappings;

   DtExtent myAreaOfInterest;
};

namespace DtBufferSerialize
{
   template <typename _Key, typename _Value>
   std::string encodeForImportData(const std::map<_Key, _Value>& v)
   {
      int size = DtBufferSerialize::getSize(v);
      char* buf = new char[size];

      DtBufferSerialize::encode(v, buf);
      std::string encoded;

      int i;

      for (i = 0; i < size; i++)
      {
         encoded += (buf[i] + 1);
      }

      delete[] buf;

      return encoded;
   }

   template <typename _Key, typename _Value>
   void decodeFromImportData(std::map<_Key, _Value>& map,const std::string& s)
   {
      int iLimit = s.size(), i;
      char* buf = new char[iLimit];
   
      for (i = 0; i < iLimit; i++)
      {
         buf[i] = s[i] - 1;
      }

      DtBufferSerialize::decode(map, buf);

      delete[] buf;
   }
}