atcstation.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_ATCSTATION_H
#define SWIFT_MISC_AVIATION_ATCSTATION_H
 
#include <array>
#include <tuple>
 
#include <QDateTime>
#include <QMetaType>
#include <QString>
#include <QVector3D>
 
#include "misc/aviation/callsign.h"
#include "misc/aviation/comsystem.h"
#include "misc/aviation/informationmessage.h"
#include "misc/geo/coordinategeodetic.h"
#include "misc/geo/latitude.h"
#include "misc/geo/longitude.h"
#include "misc/metaclass.h"
#include "misc/network/user.h"
#include "misc/pq/frequency.h"
#include "misc/pq/length.h"
#include "misc/pq/time.h"
#include "misc/propertyindexref.h"
#include "misc/swiftmiscexport.h"
#include "misc/valueobject.h"
 
SWIFT_DECLARE_VALUEOBJECT_MIXINS(swift::misc::aviation, CAtcStation)
 
namespace swift::misc::aviation
{
    class SWIFT_MISC_EXPORT CAtcStation : public CValueObject<CAtcStation>, public geo::ICoordinateWithRelativePosition
    {
    public:
        enum ColumnIndex
        {
            IndexCallsign = CPropertyIndexRef::GlobalIndexCAtcStation,
            IndexCallsignString,
            IndexCallsignStringCrossCopuled,
            IndexController,
            IndexFrequency,
            IndexPosition,
            IndexRange,
            IndexIsInRange,
            IndexIsOnline,
            IndexIsAfvCrossCoupled,
            IndexLogoffTime,
            IndexLatitude,
            IndexLongitude,
            IndexAtis,
            IndexMetar
        };
 
        CAtcStation();
 
        CAtcStation(const QString &callsign);
 
        CAtcStation(const CCallsign &callsign, const network::CUser &controller,
                    const physical_quantities::CFrequency &frequency, const geo::CCoordinateGeodetic &pos,
                    const physical_quantities::CLength &range, bool isOnline = false,
                    const QDateTime &logoffTimeUtc = QDateTime(),
                    const CInformationMessage &atis = CInformationMessage(CInformationMessage::ATIS),
                    const CInformationMessage &metar = CInformationMessage(CInformationMessage::METAR));
 
        bool hasLogoffTimeUtc() const;
 
        bool hasAtis() const { return m_atis.hasMessage(); }
 
        bool hasMetar() const;
 
        const CCallsign &getCallsign() const { return m_callsign; }
 
        bool hasCallsign() const { return !m_callsign.isEmpty(); }
 
        QString getCallsignAsString() const { return m_callsign.asString(); }
 
        QString getCallsignAsStringCrossCoupled() const;
 
        QString getCallsignSuffix() const;
 
        int getSuffixSortOrder() const;
 
        void setCallsign(const CCallsign &callsign);
 
        const swift::misc::network::CUser &getController() const { return m_controller; }
 
        QString getControllerRealName() const { return m_controller.getRealName(); }
 
        QString getCallsignAndControllerRealName() const;
 
        QString getControllerId() const { return m_controller.getId(); }
 
        void setController(const network::CUser &controller);
 
        void setControllerRealName(const QString &controllerName) { m_controller.setRealName(controllerName); }
 
        void setControllerId(const QString &controllerId) { m_controller.setId(controllerId); }
 
        bool hasRealName() const { return m_controller.hasRealName(); }
 
        bool hasId() const { return m_controller.hasId(); }
 
        bool hasValidFrequency() const { return CComSystem::isValidCivilAviationFrequency(this->getFrequency()); }
 
        const physical_quantities::CFrequency &getFrequency() const { return m_frequency; }
 
        void setFrequency(const swift::misc::physical_quantities::CFrequency &frequency);
 
        const geo::CCoordinateGeodetic &getPosition() const { return m_position; }
 
        void setPosition(const swift::misc::geo::CCoordinateGeodetic &position) { m_position = position; }
 
        const physical_quantities::CLength &getRange() const { return m_range; }
 
        void setRange(const physical_quantities::CLength &range) { m_range = range; }
 
        bool isInRange() const;
 
        bool isOnline() const { return m_isOnline; }
 
        bool setOnline(bool online);
 
        bool isAfvCrossCoupled() const { return m_isAfvCrossCoupled; }
 
        void setAfvCrossCoupled(bool coupled) { m_isAfvCrossCoupled = coupled; }
 
        const QDateTime &getLogoffTimeUtc() const { return m_logoffTimeUtc; }
 
        bool isComUnitTunedToFrequency(const aviation::CComSystem &comUnit) const;
 
        bool isAtcStationFrequency(const physical_quantities::CFrequency &frequency) const;
 
        const CInformationMessage &getAtis() const { return m_atis; }
 
        void setAtis(const CInformationMessage &atis) { m_atis = atis; }
 
        void setAtisMessage(const QString &atis) { m_atis.setMessage(atis); }
 
        const CInformationMessage &getMetar() const { return m_metar; }
 
        const CInformationMessage &getInformationMessage(CInformationMessage::InformationType type) const;
 
        void setMetar(const CInformationMessage &metar) { m_metar = metar; }
 
        void setMetarMessage(const QString &metar) { m_metar.setMessage(metar); }
 
        bool setMessage(const CInformationMessage &message);
 
        void setLogoffTimeUtc(const QDateTime &logoffTimeUtc) { m_logoffTimeUtc = logoffTimeUtc; }
 
        virtual geo::CLatitude latitude() const override;
 
        virtual geo::CLongitude longitude() const override;
 
        const aviation::CAltitude &geodeticHeight() const override;
 
        virtual QVector3D normalVector() const override;
 
        virtual std::array<double, 3> normalVectorDouble() const override;
 
        QVariant propertyByIndex(CPropertyIndexRef index) const;
 
        void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
        int comparePropertyByIndex(CPropertyIndexRef index, const CAtcStation &compareValue) const;
 
        QString convertToQString(bool i18n = false) const;
 
        swift::misc::CIcons::IconIndex toIcon() const { return m_callsign.toIcon(); }
 
    private:
        CCallsign m_callsign;
        network::CUser m_controller;
        physical_quantities::CFrequency m_frequency;
        geo::CCoordinateGeodetic m_position;
        physical_quantities::CLength m_range;
        bool m_isOnline = false;
        bool m_isAfvCrossCoupled = false;
        QDateTime m_logoffTimeUtc;
        CInformationMessage m_atis { CInformationMessage::ATIS };
        CInformationMessage m_metar { CInformationMessage::METAR };
 
        SWIFT_METACLASS(
            CAtcStation,
            SWIFT_METAMEMBER(callsign),
            SWIFT_METAMEMBER(controller),
            SWIFT_METAMEMBER(frequency),
            SWIFT_METAMEMBER(position),
            SWIFT_METAMEMBER(range),
            SWIFT_METAMEMBER(isOnline),
            SWIFT_METAMEMBER(isAfvCrossCoupled),
            SWIFT_METAMEMBER(logoffTimeUtc),
            SWIFT_METAMEMBER(atis),
            SWIFT_METAMEMBER(metar),
            SWIFT_METAMEMBER(relativeDistance),
            SWIFT_METAMEMBER(relativeBearing));
    };
} // namespace swift::misc::aviation
 
Q_DECLARE_METATYPE(swift::misc::aviation::CAtcStation)
 
#endif // SWIFT_MISC_AVIATION_ATCSTATION_H