WsfPM_Zone.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company.
// ****************************************************************************
 
#ifndef WSFPM_ZONE_HPP
#define WSFPM_ZONE_HPP
 
#include "wsf_parser_export.h"
 
#include <map>
#include <set>
#include <string>
#include <type_traits>
 
#include "UtColor.hpp"
#include "UtOptional.hpp"
#include "UtVec2.hpp"
#include "WsfPM_ObjectList.hpp"
#include "WsfPM_ObjectMap.hpp"
#include "WsfPProxyNode.hpp"
 
class WSF_PARSER_EXPORT WsfPM_ZonePoint : public WsfPProxyNode
{
public:
   WsfPM_ZonePoint(const WsfPProxyNode& aNode)
      : WsfPProxyNode(aNode)
   {
   }
   WsfPM_ZonePoint() {}
 
   WsfProxy::Latitude  Latitude() const;
   WsfProxy::Longitude Longitude() const;
   WsfProxy::Length2   GetPoint() const;
   WsfProxy::String    MGRS() const;
   WsfProxy::Length    Range() const;
   WsfProxy::Angle     Bearing() const;
 
   double GetX() const;
   double GetY() const;
};
 
using WsfPM_ZonePointList = WsfPM_ObjectList<WsfPM_ZonePoint>;
class WsfPM_Platform;
class WsfPM_ZoneSet;
 
class WSF_PARSER_EXPORT WsfPM_Zone : public WsfPProxyNode
{
public:
   using Point = UtVec2d;
   enum ZoneType
   {
      cZONE_SET,
      cZONE_DEFINITION
   };
   WsfPM_Zone() {}
   WsfPM_Zone(const WsfPProxyNode& aNode)
      : WsfPProxyNode(aNode)
   {
   }
 
   bool IsDefinition() const
   {
      const WsfPProxyType* typePtr = GetValue().GetType();
      return (typePtr && typePtr->mTypeName == "ZoneDefinition");
   }
   bool IsZoneSet() const
   {
      const WsfPProxyType* typePtr = GetValue().GetType();
      return (typePtr && typePtr->mTypeName == "ZoneSet");
   }
   bool       Rename(std::string aNewName);
   WsfPM_Zone GetSourceZone() const;

   std::string ParentPlatform() const;

   WsfPM_Platform ParentPlatformNode() const;

   std::vector<WsfPM_Zone> GetReferencingZones() const;

   std::vector<WsfPM_ZoneSet> GetUsingZoneSets() const;
 
   virtual ut::optional<UtColor> GetFillColor() const;
   virtual ut::optional<UtColor> GetLineColor() const;
};
class WSF_PARSER_EXPORT WsfPM_ZoneDefinition : public WsfPM_Zone
{
public:
   WsfPM_ZoneDefinition() {}
   WsfPM_ZoneDefinition(const WsfPProxyNode& aNode)
      : WsfPM_Zone(aNode)
   {
   }
 
   enum DefinitionType
   {
      cTYPE_NOT_SET = 0,
      cCIRCULAR     = 1,
      cELLIPTICAL,
      cPOLYGONAL,
      cSPHERICAL
   };

   DefinitionType GetDefinitionType() const;
 
   void SetDefinitionType(DefinitionType aType)
   {
      GetValue().GetAttr("type").SetIntegerValue(static_cast<int>(aType));
      NotifyAttributeChanged("type");
   }

   WsfProxy::Length MinimumAltitude() const;

   WsfProxy::Length MaximumAltitude() const;

   WsfProxy::Length MinimumRadius() const;

   WsfProxy::Length MaximumRadius() const;

   WsfProxy::Length LongitudinalAxis() const;

   WsfProxy::Length LateralAxis() const;

   WsfProxy::Angle StartAngle() const;

   WsfProxy::Angle StopAngle() const;
 

   bool UseLatLon() const;

   bool UseMGRS() const;

   bool UsePolar() const;

   bool UseOffset() const;

   bool IsAbsolute() const;

   WsfProxy::Angle Heading() const noexcept;

   WsfPProxyNode HeadingNode() const noexcept;

   WsfProxy::Position Position() const noexcept;

   WsfPProxyNode PositionNode() const noexcept;
 

   std::string ReferencePlatform() const;

   std::string ReferenceZone() const;

   bool Negative() const;
 
   using AuxDataMap = std::map<std::string, std::string>;
   AuxDataMap AuxData() const;

   std::vector<WsfPM_Zone::Point> Points() const;

   WsfPM_Zone::Point GetPoint(size_t aIndex) const;

   WsfPM_ZonePoint GetPointNode(size_t aIndex) const;

   size_t PointCount() const;
 

   WsfPM_ZonePointList PointList() const;

   bool ReferencePoint(double& aX, double& aY, bool& aIsLatLon) const;

   bool ReferencePoint(double& aX, double& aY) const
   {
      bool _;
      return ReferencePoint(aX, aY, _);
   }

   ut::optional<WsfPM_Zone::Point> ReferencePoint() const;

   WsfPM_ZoneDefinition ReferenceZoneNode() const;

   WsfPM_Platform AnchorPlatformNode() const;

   WsfPM_Platform ReferencePlatformNode() const;

   WsfProxy::Length AnchorPlatformAltitude() const;
 
   bool IsReferencePlatformValid() const;
 
   ut::optional<UtColor> GetFillColor() const override;
 
   ut::optional<UtColor> GetLineColor() const override;
 
private:
   template<typename BASIC_VALUE>
   BASIC_VALUE GetZoneAttr(const std::string& aAttrName, std::set<std::string>& aRefStack) const;
 
   ut::optional<UtColor> GetColorAttr(const std::string& aAttrName, std::set<std::string>& aRefStack) const;
 
   WsfPM_ZoneDefinition PointsDefNode(std::set<std::string>& aRefStack) const;
};
 
template class WSF_PARSER_EXPORT WsfPM_ObjectList<WsfPM_ZoneDefinition>;
using WsfPM_ZoneDefinitionList = WsfPM_ObjectList<WsfPM_ZoneDefinition>;
 
class WSF_PARSER_EXPORT WsfPM_ZoneSet : public WsfPM_Zone
{
public:
   WsfPM_ZoneSet()
      : WsfPM_Zone()
   {
   }
   WsfPM_ZoneSet(const WsfPProxyNode& aNode)
      : WsfPM_Zone(aNode)
   {
   }
 
   // list of zone names...
   WsfPM_List               InclusionZones() const { return *this + "inclusionZones"; }
   WsfPM_List               ExclusionZones() const { return *this + "exclusionZones"; }
   WsfPM_ZoneDefinitionList EmbeddedInclusionZones() const { return *this + "embeddedInclusionZones"; }
   WsfPM_ZoneDefinitionList EmbeddedExclusionZones() const { return *this + "embeddedExclusionZones"; }
};
 
using WsfPM_ZoneMap = WsfPM_ObjectMapT<WsfPM_Zone>;
 
#endif