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/vrfBufferSerialize.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <matrix/vlVector.h>
#include <vlpi/entityType.h>
#include <geometry/extent.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 DtMSDLVector : public DtVector
{
public:
   DtMSDLVector() : locationAGL(false) {};
   DtMSDLVector(const DtVector& orig) : DtVector(orig), locationAGL(false) {};
   DtMSDLVector(const DtMSDLVector& orig) : DtVector(orig), locationAGL(orig.locationAGL) {};

   DtMSDLVector& operator=(const DtMSDLVector& orig) { DtVector::operator=(orig); locationAGL = orig.locationAGL; return *this; };
   DtMSDLVector& operator=(const DtVector& orig) { DtVector::operator=(orig); return *this; };

   bool locationAGL;
};

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;

   DtMSDLVector myLocation;

   double myHeading;
   double mySpeed;

   bool myAggregated;

   std::string mySuperiorHandle;

   DtVrfObject* myObject;

   std::map<std::string, DtMsdlScenarioContentsItem> myContents;
   std::map<Msdl_UUID, DtMsdlSimulatedElement*> mySubordinates;
   std::map<std::string, std::string> myExtendedData;
};

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::string myEnvironmentalFormattingData;
   std::map<std::string, DtMsdlScenarioContentsItem> myContents;
   int myColor;
   int myAppearance;

   DtVrfObject* myObject;

   std::vector<DtMSDLVector> myLocations;

   double myPhysicalLineWidth;
   double myPhysicalLineHeight;
   std::map<std::string, std::string> myExtendedData;
};

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

   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 std::map<std::string, std::string>
      findStdMapValue(const std::map<std::string, DtMsdlScenarioContentsItem>&, const std::string& path,
      const std::set<std::string>& ignore = std::set<std::string>()) const;
   virtual bool hasValue(const std::map<std::string, DtMsdlScenarioContentsItem>&, const std::string& path) const;

   virtual std::string convertMapToString(const std::map<std::string, std::string>&) const;

   virtual bool organizationUsesForce(Msdl_UUID) const;

   virtual std::string supportedExtensions();

   virtual bool canImportFile(const DtFilename&);

   virtual void clear();

   virtual DtObjectParser * parser();

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<DtMSDLVector> parseAnchorPoints(xmlNodePtr, const std::map<std::string, std::string>& importData);

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

   virtual DtMSDLVector parseLocation(xmlNodePtr);

   virtual DtMSDLVector parseLocationGCC(xmlNodePtr);

   virtual DtMSDLVector parseLocationMGRS(xmlNodePtr);

   virtual DtMSDLVector parseLocationUTM(xmlNodePtr);

   virtual DtMSDLVector 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 saveAdditionalScenarioInformation(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 DtMSDLVector&, 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();

   virtual int nextForceType() const;

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