File indexing completed on 2024-05-12 03:50:41

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2010 Dennis Nienhüser <nienhueser@kde.org>
 //
 
 #ifndef MARBLE_ROUTINGINSTRUCTION_H
 #define MARBLE_ROUTINGINSTRUCTION_H
 
 #include "RoutingWaypoint.h"
 #include "RoutingPoint.h"
 #include "marble_export.h"
 
 #include <QVector>
 #include <QMetaType>
 
 class QTextStream;
 
 namespace Marble
 {
 
 /**
   * Stores data related to one instruction: Road name, angle to predecessor,
   * associated waypoints etc. Can be streamed directly to a QTextStream.
   */
 class MARBLE_EXPORT RoutingInstruction
 {
 public:
     enum TurnType {
         Unknown = 0,
         Continue = 13 /** Continue on the next street */,
         Merge = 14,
         Straight = 1,
         SlightRight = 2,
         Right = 3,
         SharpRight = 4,
         TurnAround = 5 /** Perform a u-turn */,
         SharpLeft = 6,
         Left = 7,
         SlightLeft = 8,
         RoundaboutFirstExit = 9 /** Enter the roundabout and leave at the first exit */,
         RoundaboutSecondExit = 10 /** Enter the roundabout and leave at the second exit */,
         RoundaboutThirdExit = 11 /** Enter the roundabout and leave at the third exit */,
         RoundaboutExit = 12 /** At the point where the roundabout should be exited */,
         ExitLeft = 15,
         ExitRight = 16
     };
 
     /** Constructor */
     explicit RoutingInstruction( const RoutingWaypoint &item = RoutingWaypoint() );
 
     /**
       * Append data of the given item, returns true if item's street
       * name matches instructions street name
       */
     bool append( const RoutingWaypoint &item, int angle );
 
     /** Name of the road to turn into */
     QString roadName() const;
 
     /** OSM type of the road to turn into */
     QString roadType() const;
 
     /** Estimated number of seconds to the route destination */
     int secondsLeft() const;
 
     /** Waypoints from the last instruction to this instruction */
     QVector<RoutingWaypoint> points() const;
 
     /**
       * Contains the intersection point and points near it on the previous and current road.
       * Near is taken as that waypoint with the largest different to the intersection point
       * that does not exceed 50 meter.
       */
     QVector<RoutingPoint> intersectionPoints() const;
 
     /** The angle between the two turn roads, in radians */
     qreal angleToPredecssor() const;
 
     /** Previous turn road. Will be 0 for the first one (route start) */
     RoutingInstruction* predecessor();
 
     /** Const overload for #predecessor */
     const RoutingInstruction* predecessor() const;
 
     /** Change the predecessor */
     void setPredecessor( RoutingInstruction* predecessor );
 
     /** Next turn road. Will be 0 for the last one (destination) */
     RoutingInstruction* successor();
 
     /** Const overload for #successor */
     const RoutingInstruction* successor() const;
 
     /** Change the successor */
     void setSuccessor( RoutingInstruction* successor );
 
     /** The accumulated distance of all waypoints belonging to this instruction */
     qreal distance() const;
 
     /** The distance from the route start */
     qreal distanceFromStart() const;
 
     /** The distance to the route end. Includes the own distance */
     qreal distanceToEnd() const;
 
     TurnType turnType() const;
 
     /** Formats the instruction (road name) for a human reader */
     QString nextRoadInstruction() const;
 
     /** Formats the instruction (distance to next instruction) for a human reader */
     QString nextDistanceInstruction() const;
 
     /** Formats the instruction (duration to destination) for a human reader */
     QString totalDurationRemaining() const;
 
     /** Formats the instruction for a human reader */
     QString instructionText() const;
 
     static QString generateRoadInstruction( TurnType turnType, const QString &roadName );
 
 protected:
     int roundaboutExitNumber() const;
 
 private:
     void calculateAngle();
 
     void calculateTurnType();
 
     QVector<RoutingWaypoint> m_points;
 
     QVector<RoutingPoint> m_intersectionPoints;
 
     QString m_roadName;
 
     QString m_roadType;
 
     int m_secondsLeft;
 
     qreal m_angleToPredecessor;
 
     TurnType m_turnType;
 
     int m_roundaboutExit;
 
     RoutingInstruction* m_predecessor;
 
     RoutingInstruction* m_successor;
 };
 
 QTextStream& operator<<( QTextStream& stream, const RoutingInstruction &i );
 
 using RoutingInstructions = QVector<RoutingInstruction>;
 
 } // namespace Marble
 
 Q_DECLARE_METATYPE( Marble::RoutingInstruction::TurnType )
 
 #endif // MARBLE_ROUTINGINSTRUCTION_H