WsfWaypoint.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 WSFWAYPOINT_HPP
#define WSFWAYPOINT_HPP
 
#include "wsf_export.h"
 
#include <iosfwd>
#include <memory>
#include <string>
 
#include "UtCloneablePtr.hpp"
class UtInput;
#include "UtLog.hpp"
class UtScriptClass;
class UtScriptTypes;
#include "WsfAuxDataEnabled.hpp"
class WsfGeoPoint;
#include "WsfObject.hpp"
#include "WsfPath.hpp"
#include "WsfStringId.hpp"

class WSF_EXPORT WsfWaypoint : public WsfAuxDataEnabled
{
public:
   enum
   {
      cLATITUDE_AND_LONGITUDE = 0x0001, 
      cRELATIVE_OFFSET        = 0x0002, 
      cLOCATION_MASK          = 0x000F, 
 
      cABSOLUTE_HEADING = 0x0010, 
      cRELATIVE_HEADING = 0x0020, 
      cHEADING_MASK     = 0x0030, 
 
      cDISTANCE      = 0x0100, 
      cTIME          = 0x0200, 
      cTIME_TO_POINT = 0x0400, 
      cDURATION_MASK = 0x0F00  
   };
 
   WsfWaypoint() = default;
   WsfWaypoint(double aLat, double aLon, double aAlt, double aSpeed = WsfPath::cUSE_PREVIOUS);
   WsfWaypoint(const WsfGeoPoint& aPoint, double aSpeed = WsfPath::cUSE_PREVIOUS);
   WsfWaypoint(const WsfWaypoint&) = default;
   WsfWaypoint(WsfWaypoint&&)      = default;
   WsfWaypoint& operator=(const WsfWaypoint&) = default;
   WsfWaypoint& operator=(WsfWaypoint&&) = default;
   ~WsfWaypoint() override               = default;
 
   WsfWaypoint* Clone() const;
   bool         ProcessInput(UtInput& aInput);
   bool         ProcessAllInput(UtInput& aInput);

   bool operator==(const WsfWaypoint& aRhs) const
   {
      return ((mLat == aRhs.mLat) && (mLon == aRhs.mLon) && (mAlt == aRhs.mAlt));
   }

   bool operator!=(const WsfWaypoint& aRhs) const { return !(operator==(aRhs)); }
 
   void ExtrapolateAlongHeading(double aHeading);
 
   static std::unique_ptr<UtScriptClass> CreateScriptClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);
 
   void GreatCircleHeadingAndDistance(const WsfWaypoint& aWaypoint, double& aHeading, double& aDistance) const;
 
   void Print(ut::log::MessageStream& aStream) const;
 
   void       SetCallback(WsfObject* aCallbackPtr);
   WsfObject* GetCallback() const;
 
   double GetPauseTime() const { return mPauseTime; }
   void   SetPauseTime(double aPauseTime) { mPauseTime = aPauseTime; }
 
   WsfStringId GetLabelId() const { return mLabelId; }
   void        SetLabelId(WsfStringId aLabelId) { mLabelId = aLabelId; }
 
   WsfStringId GetScriptId() const { return mScriptId; }
   void        SetScriptId(WsfStringId aScriptId) { mScriptId = aScriptId; }
 
   WsfStringId GetGotoId() const { return mGotoId; }
   void        SetGotoId(WsfStringId aGotoId) { mGotoId = aGotoId; }
 
   WsfStringId GetNewModeId() const { return mNewModeId; }
   void        SetNewModeId(WsfStringId aNewModeId) { mNewModeId = aNewModeId; }
 
   int  GetPointType() const { return mPointType; }
   void SetPointType(int aPointType) { mPointType = aPointType; }
 
   double GetLat() const { return mLat; }
   void   SetLat(double aLat) { mLat = aLat; }
 
   double GetLon() const { return mLon; }
   void   SetLon(double aLon) { mLon = aLon; }
 
   double GetAlt() const { return mAlt; }
   void   SetAlt(double aAlt) { mAlt = aAlt; }
 
   void GetLocationLLA(double& aLat, double& aLon, double& aAlt) const;
   void SetLocationLLA(double aLat, double aLon, double aAlt);
 
   double GetHeading() const { return mHeading; }
   void   SetHeading(double aHeading) { mHeading = aHeading; }
 
   double GetLinearAccel() const { return mLinearAccel; }
   void   SetLinearAccel(double aLinearAccel) { mLinearAccel = aLinearAccel; }
 
   double GetRadialAccel() const { return mRadialAccel; }
   void   SetRadialAccel(double aRadialAccel) { mRadialAccel = aRadialAccel; }
 
   double GetClimbRate() const { return mClimbRate; }
   void   SetClimbRate(double aClimbRate) { mClimbRate = aClimbRate; }
 
   double GetMaximumFlightPathAngle() const { return mMaximumFlightPathAngle; }
   void SetMaximumFlightPathAngle(double aMaximumFlightPathAngle) { mMaximumFlightPathAngle = aMaximumFlightPathAngle; }
 
   void   SetSpeed(double aSpeed) { mSpeed = aSpeed; }
   double GetSpeed() const { return mSpeed; }
 
   double GetDistanceAlongRoute() const { return mDistanceAlongRoute; }
   void   SetDistanceAlongRoute(double aDistanceAlongRoute) { mDistanceAlongRoute = aDistanceAlongRoute; }
 
   double GetDistanceOrTime() const { return mDistanceOrTime; }
   void   SetDistanceOrTime(double aDistanceOrTime) { mDistanceOrTime = aDistanceOrTime; }
 
   WsfPath::AltRef GetAltRef() const { return mAltRef; }
   void            SetAltRef(WsfPath::AltRef aAltRef) { mAltRef = aAltRef; }
 
   WsfPath::EndPath GetEndOfPathOption() const { return mEndOfPathOption; }
   void             SetEndOfPathOption(WsfPath::EndPath aEndOfPathOption) { mEndOfPathOption = aEndOfPathOption; }
 
   WsfPath::TurnDirection GetTurnDirection() const { return mTurnDirection; }
   void                   SetTurnDirection(WsfPath::TurnDirection aTurnDirection) { mTurnDirection = aTurnDirection; }
 
   WsfPath::Switch GetSwitch() const { return mSwitch; }
   void            SetSwitch(WsfPath::Switch aSwitch) { mSwitch = aSwitch; }
 
   unsigned int GetRouteId() const { return mRouteId; }
   void         SetRouteId(unsigned int aRouteId) { mRouteId = aRouteId; }
 
   WsfStringId GetNodeId() const { return mNodeId; }
   void        SetNodeId(WsfStringId aNodeId) { mNodeId = aNodeId; }
 
   unsigned int GetNodeIdNumber() const { return mNodeIdNumber; }
   void         SetNodeIdNumber(unsigned int aNodeIdNumber) { mNodeIdNumber = aNodeIdNumber; }
 
   unsigned int GetPositionInRoute() const { return mPositionInRoute; }
   void         SetPositionInRoute(unsigned int aPositionInRoute) { mPositionInRoute = aPositionInRoute; }
 
   // ================================= WARNING: New member variables ===========================
   //
   //   This class is transmitted over the network.  If you add a new member variable, it is
   //   YOUR RESPONSIBILITY to verify that the member is serialized correctly.
   //   Please see the implementation of WsfWaypoint::SerializeP in xio/WsfXIO_SerializeTypes.cpp
   //
   // ===========================================================================================

   template<typename T>
   void SerializeP(T& aBuff);
 
private:
   ut::CloneablePtr<WsfObject> mCallbackPtr;

   int mPointType = cLATITUDE_AND_LONGITUDE;

   double mLat = 0.0;

   double mLon = 0.0;

   double mAlt = WsfPath::cUSE_PREVIOUS;

   double mDistanceOrTime = 0.0;

   double mDistanceAlongRoute = 0.0;

   double mHeading = WsfPath::cUSE_PREVIOUS;

   double mSpeed = WsfPath::cUSE_PREVIOUS;

   double mLinearAccel = WsfPath::cUSE_PREVIOUS;

   double mRadialAccel = WsfPath::cUSE_PREVIOUS;

   double mClimbRate = WsfPath::cUSE_PREVIOUS;

   double mMaximumFlightPathAngle = WsfPath::cUSE_PREVIOUS;

   double mPauseTime = 0.0;

   WsfStringId mLabelId = nullptr;

   WsfStringId mScriptId = nullptr;

   WsfStringId mGotoId = nullptr;

   WsfStringId mNewModeId = nullptr;

   WsfPath::AltRef mAltRef = WsfPath::cALT_REF_MOVER_DEFAULT;

   WsfPath::EndPath mEndOfPathOption = WsfPath::cEP_MOVER_DEFAULT;

   WsfPath::TurnDirection mTurnDirection = WsfPath::cTURN_DIR_SHORTEST;

   WsfPath::Switch mSwitch = WsfPath::cSWITCH_MOVER_DEFAULT;



   unsigned int mRouteId = 0;

   WsfStringId mNodeId = nullptr;
 
   unsigned int mNodeIdNumber = 0;

   unsigned int mPositionInRoute = 0;
};
 
#endif