altitude.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_AVIATION_ALTITUDE_H
#define SWIFT_MISC_AVIATION_ALTITUDE_H
 
#include <tuple>
 
#include <QMetaType>
#include <QPair>
#include <QRegularExpression>
#include <QString>
#include <QVector>
 
#include "misc/metaclass.h"
#include "misc/mixin/mixincompare.h"
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixindbus.h"
#include "misc/mixin/mixinhash.h"
#include "misc/mixin/mixinicon.h"
#include "misc/mixin/mixinindex.h"
#include "misc/mixin/mixinmetatype.h"
#include "misc/mixin/mixinstring.h"
#include "misc/pq/length.h"
#include "misc/pq/pqstring.h"
#include "misc/pq/pressure.h"
#include "misc/pq/units.h"
#include "misc/statusmessagelist.h"
#include "misc/swiftmiscexport.h"
 
namespace swift::misc::aviation
{
    class SWIFT_MISC_EXPORT CAltitude :
        public physical_quantities::CLength,
        public mixin::MetaType<CAltitude>,
        public mixin::EqualsByMetaClass<CAltitude>,
        // public mixin::CompareByMetaClass<CAltitude>,
        public mixin::HashByMetaClass<CAltitude>,
        public mixin::DBusByMetaClass<CAltitude>,
        public mixin::DBusByMetaClass<CAltitude, LosslessTag>,
        public mixin::DataStreamByMetaClass<CAltitude>,
        public mixin::JsonByMetaClass<CAltitude>,
        public mixin::String<CAltitude>,
        public mixin::Icon<CAltitude>,
        public mixin::Index<CAltitude>
    {
    public:
        using base_type = physical_quantities::CLength;
 
        using MetricTuple = std::tuple<int, int>;
 
        SWIFT_MISC_DECLARE_USING_MIXIN_METATYPE(CAltitude)
        SWIFT_MISC_DECLARE_USING_MIXIN_STRING(CAltitude)
        SWIFT_MISC_DECLARE_USING_MIXIN_DBUS(CAltitude)
        SWIFT_MISC_DECLARE_USING_MIXIN_DBUS(CAltitude, LosslessTag)
        SWIFT_MISC_DECLARE_USING_MIXIN_DATASTREAM(CAltitude)
        SWIFT_MISC_DECLARE_USING_MIXIN_JSON(CAltitude)
        SWIFT_MISC_DECLARE_USING_MIXIN_ICON(CAltitude)
        SWIFT_MISC_DECLARE_USING_MIXIN_INDEX(CAltitude)
 
        
        enum ReferenceDatum
        {
            MeanSeaLevel = 0, 
            AboveGround, 
            FlightLevel 
        };
 
        enum AltitudeType
        {
            PressureAltitude, 
            TrueAltitude 
        };
 
        CAltitude() : CLength(0, physical_quantities::CLengthUnit::m()), m_datum(MeanSeaLevel) {}
 
        CAltitude(double value, ReferenceDatum datum, const physical_quantities::CLengthUnit &unit)
            : CLength(value, unit), m_datum(datum)
        {}
 
        CAltitude(double value, ReferenceDatum datum, AltitudeType type, const physical_quantities::CLengthUnit &unit)
            : CLength(value, unit), m_datum(datum), m_altitudeType(type)
        {}
 
        CAltitude(double value, const physical_quantities::CLengthUnit &unit)
            : CLength(value, unit), m_datum(MeanSeaLevel)
        {}
 
        CAltitude(double value, const physical_quantities::CLengthUnit &unit,
                  const physical_quantities::CLengthUnit &switchUnit)
            : CLength(value, unit), m_datum(MeanSeaLevel)
        {
            this->switchUnit(switchUnit);
        }
 
        CAltitude(const QString &altitudeAsString, physical_quantities::CPqString::SeparatorMode mode =
                                                       physical_quantities::CPqString::SeparatorBestGuess);
 
        CAltitude(const physical_quantities::CLength &altitude, ReferenceDatum datum)
            : CLength(altitude), m_datum(datum)
        {}
 
        CAltitude withOffset(const CLength &offset) const;
 
        void addOffset(const CLength &offset);
 
        CAltitude &switchUnit(const physical_quantities::CLengthUnit &newUnit);
 
        CAltitude switchedUnit(const physical_quantities::CLengthUnit &newUnit) const;
 
        bool isAboveGroundLevel() const { return AboveGround == m_datum; }
 
        bool isMeanSeaLevel() const { return MeanSeaLevel == m_datum; }
 
        bool isFlightLevel() const { return FlightLevel == m_datum; }
 
        ReferenceDatum getReferenceDatum() const { return m_datum; }
 
        bool toFlightLevel();
 
        bool toMeanSeaLevel();
 
        bool hasMeanSeaLevelValue() const { return this->isMeanSeaLevel() && !this->isNull(); }
 
        AltitudeType getAltitudeType() const { return m_altitudeType; }
 
        void convertToPressureAltitude(const physical_quantities::CPressure &seaLevelPressure);
 
        CAltitude toPressureAltitude(const physical_quantities::CPressure &seaLevelPressure) const;
 
        void parseFromString(const QString &value);
 
        void parseFromString(const QString &value, physical_quantities::CPqString::SeparatorMode mode);
 
        bool parseFromFpAltitudeString(const QString &value, CStatusMessageList *msgs = nullptr);
 
        bool isValidFpAltitude(CStatusMessageList *msgs = nullptr) const;
 
        QString asFpICAOAltitudeString() const;
 
        QString asFpVatsimAltitudeString() const;
 
        static const QRegularExpression &fpAltitudeRegExp();
 
        static QString fpAltitudeInfo(const QString &separator = ", ");
 
        static QString fpAltitudeExamples();
 
        swift::misc::CIcons::IconIndex toIcon() const;
 
        int compare(const CAltitude &otherAltitude) const;
 
        QString convertToQString(bool i18n = false) const;
 
        int comparePropertyByIndex(CPropertyIndexRef index, const CAltitude &compareValue) const;
 
        CAltitude roundedToNearest100ft(bool roundDown) const;
 
        static int findMetricAltitude(int feet);
        static int findAltitudeForMetricAltitude(int metric);
 
        static const CAltitude &null();
 
        static physical_quantities::CLengthUnit defaultUnit();
 
        static const physical_quantities::CPressure &standardISASeaLevelPressure();
 
        static void registerMetadata();
 
    private:
        ReferenceDatum m_datum; 
        AltitudeType m_altitudeType = TrueAltitude; 
 
        static const QVector<MetricTuple> &metricTuples();
 
        SWIFT_METACLASS(
            CAltitude,
            SWIFT_METAMEMBER(datum),
            SWIFT_METAMEMBER(altitudeType));
    };
 
    using CAltitudePair = QPair<CAltitude, CAltitude>; 
} // namespace swift::misc::aviation
 
Q_DECLARE_METATYPE(swift::misc::aviation::CAltitude)
Q_DECLARE_METATYPE(swift::misc::aviation::CAltitude::ReferenceDatum)
Q_DECLARE_METATYPE(swift::misc::aviation::CAltitude::AltitudeType)
Q_DECLARE_METATYPE(swift::misc::aviation::CAltitudePair)
 
#endif // SWIFT_MISC_AVIATION_ALTITUDE_H