From e109d73ba2cc03012980e9fce75c518172cd20ca Mon Sep 17 00:00:00 2001 From: Klaus Basan Date: Fri, 15 Aug 2014 18:17:15 +0200 Subject: [PATCH] refs #314, new propertyBy methods (nested indexes) --- src/blackcore/airspace_monitor.cpp | 3 +- src/blackmisc/audiodevice.h | 8 +- src/blackmisc/avaircraft.cpp | 121 ++++++------------- src/blackmisc/avaircraft.h | 55 ++++----- src/blackmisc/avaircrafticao.cpp | 35 +++--- src/blackmisc/avaircrafticao.h | 11 +- src/blackmisc/avaircraftsituation.cpp | 65 +++++----- src/blackmisc/avaircraftsituation.h | 14 +-- src/blackmisc/avairport.cpp | 54 ++++----- src/blackmisc/avairport.h | 8 +- src/blackmisc/avatcstation.cpp | 105 ++++++---------- src/blackmisc/avatcstation.h | 24 ++-- src/blackmisc/avcallsign.cpp | 47 +++++++ src/blackmisc/avcallsign.h | 15 +++ src/blackmisc/aviomodulator.cpp | 59 +++++++++ src/blackmisc/aviomodulator.h | 18 +++ src/blackmisc/aviotransponder.cpp | 63 ++++++++++ src/blackmisc/aviotransponder.h | 15 +++ src/blackmisc/blackmiscfreefunctions.cpp | 2 + src/blackmisc/coordinategeodetic.cpp | 91 +++++++------- src/blackmisc/coordinategeodetic.h | 39 +++--- src/blackmisc/geolongitude.h | 5 +- src/blackmisc/hotkeyfunction.h | 11 +- src/blackmisc/hwkeyboardkey.cpp | 54 ++++----- src/blackmisc/hwkeyboardkey.h | 4 +- src/blackmisc/indexvariantmap.cpp | 11 +- src/blackmisc/indexvariantmap.h | 24 ++-- src/blackmisc/namevariantpair.cpp | 22 ++-- src/blackmisc/namevariantpair.h | 6 +- src/blackmisc/nwaircraftmapping.cpp | 27 +++-- src/blackmisc/nwaircraftmapping.h | 6 +- src/blackmisc/nwaircraftmodel.cpp | 26 ++-- src/blackmisc/nwaircraftmodel.h | 12 +- src/blackmisc/nwclient.cpp | 69 +++++------ src/blackmisc/nwclient.h | 30 ++--- src/blackmisc/nwserver.cpp | 36 +++--- src/blackmisc/nwuser.cpp | 31 ++--- src/blackmisc/nwuser.h | 30 ++--- src/blackmisc/nwvoicecapabilites.cpp | 4 +- src/blackmisc/nwvoicecapabilities.h | 6 +- src/blackmisc/setkeyboardhotkey.cpp | 25 ++-- src/blackmisc/setkeyboardhotkey.h | 17 ++- src/blackmisc/statusmessage.cpp | 47 +++---- src/blackmisc/statusmessage.h | 34 +++--- src/blackmisc/valueobject.cpp | 39 ++++-- src/blackmisc/valueobject.h | 40 +++--- src/blackmisc/voiceroom.cpp | 97 +++++++++++++-- src/blackmisc/voiceroom.h | 30 +++-- src/blacksim/fscommon/aircraftcfgentries.cpp | 55 +++++++-- src/blacksim/fscommon/aircraftcfgentries.h | 9 +- src/blacksim/fscommon/aircraftmapping.cpp | 73 +++++------ src/blacksim/fscommon/aircraftmapping.h | 4 +- tests/blackmisc/testvalueobject.cpp | 33 +++-- tests/blackmisc/testvalueobject.h | 1 - 54 files changed, 1016 insertions(+), 754 deletions(-) diff --git a/src/blackcore/airspace_monitor.cpp b/src/blackcore/airspace_monitor.cpp index 2ac1ab157..a86b5ec84 100644 --- a/src/blackcore/airspace_monitor.cpp +++ b/src/blackcore/airspace_monitor.cpp @@ -247,7 +247,8 @@ namespace BlackCore if (callsign.isEmpty() || model.isEmpty()) return; // Request of other client, I can get the other's model from that - CIndexVariantMap vm(CClient::IndexQueriedModelString, QVariant(model)); + CIndexVariantMap vm( { CClient::IndexModel, CAircraftModel::IndexModelString }, QVariant(model)); + vm.addValue({ CClient::IndexModel, CAircraftModel::IndexIsQueriedModelString }, QVariant(true)); if (!this->m_otherClients.contains(&CClient::getCallsign, callsign)) { // with custom packets it can happen, diff --git a/src/blackmisc/audiodevice.h b/src/blackmisc/audiodevice.h index c40f51e16..8bfc07284 100644 --- a/src/blackmisc/audiodevice.h +++ b/src/blackmisc/audiodevice.h @@ -47,9 +47,6 @@ namespace BlackMisc //! Constructor. CAudioDevice(DeviceType type, const qint16 index, const QString &getName); - //! \copydoc CValueObject::toQVariant - virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } - //! Get the device index qint16 getIndex() const { return m_deviceIndex; } @@ -74,11 +71,14 @@ namespace BlackMisc //! \copydoc CValueObject::getValueHash virtual uint getValueHash() const override; + //! \copydoc CValueObject::toQVariant + virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } + //! \copydoc CValueObject::toJson virtual QJsonObject toJson() const override; //! \copydoc CValueObject::fromJson - void fromJson(const QJsonObject &json) override; + virtual void fromJson(const QJsonObject &json) override; //! Register metadata static void registerMetadata(); diff --git a/src/blackmisc/avaircraft.cpp b/src/blackmisc/avaircraft.cpp index 676f7fdae..f5a350793 100644 --- a/src/blackmisc/avaircraft.cpp +++ b/src/blackmisc/avaircraft.cpp @@ -11,6 +11,7 @@ #include "blackmisc/blackmiscfreefunctions.h" #include "blackmisc/pqconstants.h" #include "blackmisc/icon.h" +#include "blackmisc/propertyindex.h" using namespace BlackMisc::PhysicalQuantities; @@ -196,122 +197,74 @@ namespace BlackMisc /* * Property by index */ - QVariant CAircraft::propertyByIndex(int index) const + QVariant CAircraft::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - if (index >= static_cast(CAircraftIcao::IndexAircraftDesignator)) - return this->m_icao.propertyByIndex(index); - - if (index >= static_cast(CAircraftSituation::IndexPosition)) - return this->m_situation.propertyByIndex(index); - - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexCallsign: - return QVariant::fromValue(this->m_callsign); - case IndexPixmap: - return QVariant(this->m_callsign.toPixmap()); - case IndexCallsignAsString: - return QVariant::fromValue(this->m_callsign.toQString(true)); - case IndexCallsignAsStringAsSet: - return QVariant(this->m_callsign.getStringAsSet()); - case IndexPilotId: - return QVariant::fromValue(this->m_pilot.getId()); - case IndexPilotRealName: - return QVariant::fromValue(this->m_pilot.getRealName()); + return this->m_callsign.propertyByIndex(index.copyFrontRemoved()); + case IndexPilot: + return this->m_pilot.propertyByIndex(index.copyFrontRemoved()); case IndexDistance: - return this->m_distanceToPlane.toQVariant(); + return this->m_distanceToPlane.propertyByIndex(index.copyFrontRemoved()); case IndexCom1System: - return this->m_com1system.toQVariant(); - case IndexFrequencyCom1: - return this->m_com1system.getFrequencyActive().toQVariant(); + return this->m_com1system.propertyByIndex(index.copyFrontRemoved()); + case IndexCom2System: + return this->m_com2system.propertyByIndex(index.copyFrontRemoved()); case IndexTransponder: - return this->m_transponder.toQVariant(); - case IndexTansponderFormatted: - return QVariant::fromValue(this->m_transponder.getTransponderCodeAndModeFormatted()); + return this->m_transponder.propertyByIndex(index.copyFrontRemoved()); case IndexSituation: - return this->m_situation.toQVariant(); + return this->m_situation.propertyByIndex(index.copyFrontRemoved()); case IndexIcao: - return this->m_icao.toQVariant(); + return this->m_icao.propertyByIndex(index.copyFrontRemoved()); default: - break; + return (ICoordinateGeodetic::canHandleIndex(index)) ? + ICoordinateGeodetic::propertyByIndex(index) : + CValueObject::propertyByIndex(index); } - - Q_ASSERT_X(false, "CAircraft", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); - } - - /* - * Property as string by index - */ - QString CAircraft::propertyByIndexAsString(int index, bool i18n) const - { - QVariant qv = this->propertyByIndex(index); - // special treatment - // this is required, as it is possible that an aircraft is not - // containing all properties - switch (index) - { - case IndexFrequencyCom1: - if (!CComSystem::isValidCivilAviationFrequency(qv.value())) - return ""; - else - return qv.value().valueRoundedWithUnit(3, i18n); - break; - case IndexDistance: - { - CLength distance = qv.value(); - if (distance.isNegativeWithEpsilonConsidered()) return ""; - return distance.toQString(i18n); - } - default: - break; - } - return BlackMisc::qVariantToString(qv, i18n); } /* * Property by index (setter) */ - void CAircraft::setPropertyByIndex(const QVariant &variant, int index) + void CAircraft::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - if (index >= static_cast(CAircraftIcao::IndexAircraftDesignator)) - return this->m_icao.setPropertyByIndex(variant, index); - - if (index >= static_cast(CAircraftSituation::IndexPosition)) - return this->m_situation.setPropertyByIndex(variant, index); - - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexCallsign: - this->setCallsign(variant.value()); + this->m_callsign.setPropertyByIndex(variant, index.copyFrontRemoved()); break; - case IndexCallsignAsString: - this->m_callsign = CCallsign(variant.value()); - break; - case IndexPilotRealName: - this->m_pilot.setRealName(variant.value()); + case IndexPilot: + this->m_pilot.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexDistance: - this->m_distanceToPlane = variant.value(); + this->m_distanceToPlane.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexCom1System: - this->setCom1System(variant.value()); + this->m_com1system.setPropertyByIndex(variant, index.copyFrontRemoved()); break; - case IndexFrequencyCom1: - this->m_com1system.setFrequencyActive(variant.value()); + case IndexCom2System: + this->m_com2system.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexTransponder: - this->setTransponder(variant.value()); + this->m_transponder.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexIcao: - this->setIcaoInfo(variant.value()); + this->m_icao.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexSituation: - this->setSituation(variant.value()); + this->m_situation.setPropertyByIndex(variant, index.copyFrontRemoved()); break; default: - Q_ASSERT_X(false, "CAircraft", "index unknown"); + CValueObject::setPropertyByIndex(variant, index); break; } } diff --git a/src/blackmisc/avaircraft.h b/src/blackmisc/avaircraft.h index 13d5d47cb..330509491 100644 --- a/src/blackmisc/avaircraft.h +++ b/src/blackmisc/avaircraft.h @@ -20,6 +20,7 @@ #include "aviocomsystem.h" #include "valueobject.h" #include "namevariantpairlist.h" +#include "propertyindex.h" namespace BlackMisc { @@ -31,6 +32,19 @@ namespace BlackMisc class CAircraft : public BlackMisc::CValueObject, public BlackMisc::Geo::ICoordinateGeodetic { public: + //! Properties by index + enum ColumnIndex + { + IndexCallsign = BlackMisc::CPropertyIndex::GlobalIndexCAircraft, + IndexPilot, + IndexDistance, + IndexCom1System, + IndexCom2System, + IndexTransponder, + IndexSituation, + IndexIcao + }; + //! Default constructor. CAircraft() : m_distanceToPlane(0, BlackMisc::PhysicalQuantities::CLengthUnit::nullUnit()) {} @@ -38,10 +52,10 @@ namespace BlackMisc CAircraft(const CCallsign &callsign, const BlackMisc::Network::CUser &user, const CAircraftSituation &situation); //! \copydoc CValueObject::toQVariant - virtual QVariant toQVariant() const override - { - return QVariant::fromValue(*this); - } + virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } + + //! \copydoc CValueObject::toIcon() + virtual BlackMisc::CIcon toIcon() const override { return this->m_callsign.toIcon(); } //! Get callsign. const CCallsign &getCallsign() const { return m_callsign; } @@ -213,39 +227,18 @@ namespace BlackMisc //! \copydoc CValueObject::fromJson virtual void fromJson(const QJsonObject &json) override; + //! \copydoc CValueObject::propertyByIndex() + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; + + //! \copydoc CValueObject::setPropertyByIndex(variant, index) + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; + //! Register metadata static void registerMetadata(); //! Members static const QStringList &jsonMembers(); - //! Properties by index - enum ColumnIndex - { - IndexCallsign = 0, - IndexPixmap, - IndexCallsignAsString, - IndexCallsignAsStringAsSet, - IndexPilotId, - IndexPilotRealName, - IndexDistance, - IndexCom1System, - IndexFrequencyCom1, - IndexTransponder, - IndexTansponderFormatted, - IndexSituation, - IndexIcao - }; - - //! \copydoc CValueObject::propertyByIndex() - virtual QVariant propertyByIndex(int index) const override; - - //! \copydoc CValueObject::propertyByIndexAsString() - virtual QString propertyByIndexAsString(int index, bool i18n) const override; - - //! \copydoc CValueObject::setPropertyByIndex(variant, index) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; - protected: //! \copydoc CValueObject::convertToQString() virtual QString convertToQString(bool i18n = false) const override; diff --git a/src/blackmisc/avaircrafticao.cpp b/src/blackmisc/avaircrafticao.cpp index 31ee9acbc..57e313ebb 100644 --- a/src/blackmisc/avaircrafticao.cpp +++ b/src/blackmisc/avaircrafticao.cpp @@ -8,6 +8,7 @@ */ #include "avaircrafticao.h" +#include "blackmisc/propertyindex.h" #include "blackmisc/blackmiscfreefunctions.h" #include @@ -128,9 +129,11 @@ namespace BlackMisc /* * Property by index */ - QVariant CAircraftIcao::propertyByIndex(int index) const + QVariant CAircraftIcao::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexAircraftDesignator: return QVariant::fromValue(this->m_aircraftDesignator); @@ -143,29 +146,23 @@ namespace BlackMisc case IndexAsString: return QVariant::fromValue(this->asString()); default: - break; + return CValueObject::propertyByIndex(index); } - - Q_ASSERT_X(false, "CAircraftIcao", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); - } - - /* - * Property as string by index - */ - QString CAircraftIcao::propertyByIndexAsString(int index, bool i18n) const - { - QVariant qv = this->propertyByIndex(index); - return BlackMisc::qVariantToString(qv, i18n); } /* * Property by index */ - void CAircraftIcao::setPropertyByIndex(const QVariant &variant, int index) + void CAircraftIcao::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexAircraftDesignator: this->setAircraftDesignator(variant.value()); @@ -180,7 +177,7 @@ namespace BlackMisc this->setAircraftColor(variant.value()); break; default: - Q_ASSERT_X(false, "CAircraftIcao", "index unknown"); + CValueObject::setPropertyByIndex(variant, index); break; } } diff --git a/src/blackmisc/avaircrafticao.h b/src/blackmisc/avaircrafticao.h index 1a59bf99c..51cb2fb33 100644 --- a/src/blackmisc/avaircrafticao.h +++ b/src/blackmisc/avaircrafticao.h @@ -12,7 +12,7 @@ #ifndef BLACKMISC_AIRCRAFTICAO_H #define BLACKMISC_AIRCRAFTICAO_H -#include "valueobject.h" +#include "propertyindex.h" namespace BlackMisc { @@ -28,7 +28,7 @@ namespace BlackMisc //! Properties by index enum ColumnIndex { - IndexAircraftDesignator, + IndexAircraftDesignator = BlackMisc::CPropertyIndex::GlobalIndexCAircraftIcao, IndexCombinedAircraftType, IndexAirlineDesignator, IndexAircraftColor, @@ -151,13 +151,10 @@ namespace BlackMisc virtual void fromJson(const QJsonObject &json) override; //! \copydoc CValueObject::propertyByIndex - virtual QVariant propertyByIndex(int index) const override; - - //! \copydoc CValueObject::propertyByIndex(index, i18n) - virtual QString propertyByIndexAsString(int index, bool i18n) const override; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex(variant, index) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! Register metadata static void registerMetadata(); diff --git a/src/blackmisc/avaircraftsituation.cpp b/src/blackmisc/avaircraftsituation.cpp index e7b2aaffc..aa015a44b 100644 --- a/src/blackmisc/avaircraftsituation.cpp +++ b/src/blackmisc/avaircraftsituation.cpp @@ -9,7 +9,9 @@ #include "avaircraftsituation.h" #include "blackmisc/blackmiscfreefunctions.h" +#include "blackmisc/propertyindex.h" +using namespace BlackMisc; using namespace BlackMisc::PhysicalQuantities; using namespace BlackMisc::Geo; @@ -104,28 +106,28 @@ namespace BlackMisc /* * Property by index */ - QVariant CAircraftSituation::propertyByIndex(int index) const + QVariant CAircraftSituation::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexPosition: - return QVariant::fromValue(this->m_position); - case IndexPositionLatitude: - return QVariant::fromValue(this->latitude()); - case IndexPositionLongitude: - return QVariant::fromValue(this->longitude()); - case IndexPositionHeight: - return QVariant::fromValue(this->getHeight()); + return this->m_position.propertyByIndex(index.copyFrontRemoved()); + case IndexLatitude: + return this->latitude().propertyByIndex(index.copyFrontRemoved()); + case IndexLongitude: + return this->longitude().propertyByIndex(index.copyFrontRemoved()); case IndexAltitude: - return QVariant::fromValue(this->m_altitude); + return this->m_altitude.propertyByIndex(index.copyFrontRemoved()); case IndexHeading: - return QVariant::fromValue(this->m_heading); + return this->m_heading.propertyByIndex(index.copyFrontRemoved()); case IndexPitch: - return QVariant::fromValue(this->m_pitch); + return this->m_pitch.propertyByIndex(index.copyFrontRemoved()); case IndexBank: - return QVariant::fromValue(this->m_bank); + return this->m_bank.propertyByIndex(index.copyFrontRemoved()); case IndexGroundspeed: - return QVariant::fromValue(this->m_groundspeed); + return this->m_groundspeed.propertyByIndex(index.copyFrontRemoved()); case IndexTimeStamp: return QVariant::fromValue(this->m_timestamp); case IndexTimeStampFormatted: @@ -135,43 +137,38 @@ namespace BlackMisc } Q_ASSERT_X(false, "CAircraftSituation", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); + QString m = QString("no property, index ").append(index.toQString()); return QVariant::fromValue(m); } - /* - * Property as string by index - */ - QString CAircraftSituation::propertyByIndexAsString(int index, bool i18n) const - { - QVariant qv = this->propertyByIndex(index); - return BlackMisc::qVariantToString(qv, i18n); - } - /* * Property by index */ - void CAircraftSituation::setPropertyByIndex(const QVariant &variant, int index) + void CAircraftSituation::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexPosition: - this->setPosition(variant.value()); + this->m_position.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexAltitude: - this->setAltitude(variant.value()); + this->m_altitude.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexPitch: - this->setPitch(variant.value()); + this->m_pitch.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexBank: - this->setBank(variant.value()); + this->m_bank.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexGroundspeed: - this->setGroundspeed(variant.value()); - break; - case IndexPositionHeight: - this->setHeight(variant.value()); + this->m_groundspeed.setPropertyByIndex(variant, index.copyFrontRemoved()); break; default: Q_ASSERT_X(false, "CAircraftSituation", "index unknown (setter)"); diff --git a/src/blackmisc/avaircraftsituation.h b/src/blackmisc/avaircraftsituation.h index f0b90691d..0ea006a7b 100644 --- a/src/blackmisc/avaircraftsituation.h +++ b/src/blackmisc/avaircraftsituation.h @@ -44,10 +44,9 @@ namespace BlackMisc //! Properties by index enum ColumnIndex { - IndexPosition = 1000, // used, so it can be chained in aircraft - IndexPositionLatitude, - IndexPositionLongitude, - IndexPositionHeight, + IndexPosition, + IndexLatitude, + IndexLongitude, IndexAltitude, IndexHeading, IndexBank, @@ -58,13 +57,10 @@ namespace BlackMisc }; //! \copydoc CValueObject::propertyByIndex(index) - virtual QVariant propertyByIndex(int index) const override; - - //! \copydoc CValueObject::propertyByIndexAsString - virtual QString propertyByIndexAsString(int index, bool i18n) const override; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex(variant,index) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! \copydoc CValueObject::toQVariant virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } diff --git a/src/blackmisc/avairport.cpp b/src/blackmisc/avairport.cpp index 185a6deef..f9b10af26 100644 --- a/src/blackmisc/avairport.cpp +++ b/src/blackmisc/avairport.cpp @@ -9,6 +9,7 @@ #include "avairport.h" #include "blackmiscfreefunctions.h" +#include "propertyindex.h" using namespace BlackMisc::PhysicalQuantities; using namespace BlackMisc::Geo; @@ -162,70 +163,65 @@ namespace BlackMisc /* * Property by index */ - QVariant CAirport::propertyByIndex(int index) const + QVariant CAirport::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - if (index > static_cast(CAirport::IndexBearing)) - { - return this->m_position.propertyByIndex(index); - } - - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexIcao: - return this->m_icao.toQVariant(); - case IndexIcaoAsString: - return QVariant(this->m_icao.asString()); + return this->m_icao.propertyByIndex(index.copyFrontRemoved()); case IndexDescriptiveName: return QVariant(this->m_descriptiveName); case IndexPosition: - return this->m_position.toQVariant(); + return this->m_position.propertyByIndex(index.copyFrontRemoved()); case IndexElevation: - return this->getElevation().toQVariant(); + return this->getElevation().propertyByIndex(index.copyFrontRemoved()); case IndexBearing: - return this->m_bearingToPlane.toQVariant(); + return this->m_bearingToPlane.propertyByIndex(index.copyFrontRemoved()); case IndexDistance: - return this->m_distanceToPlane.toQVariant(); + return this->m_distanceToPlane.propertyByIndex(index.copyFrontRemoved()); default: - break; + return (ICoordinateGeodetic::canHandleIndex(index)) ? + ICoordinateGeodetic::propertyByIndex(index) : + CValueObject::propertyByIndex(index); } Q_ASSERT_X(false, "CAirport", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); + QString m = QString("no property, index ").append(index.toQString()); return QVariant::fromValue(m); } /* * Set property as index */ - void CAirport::setPropertyByIndex(const QVariant &variant, int index) + void CAirport::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - if (index >= static_cast(CAirport::IndexBearing)) + if (index.isMyself()) { - this->m_position.setPropertyByIndex(variant, index); + this->fromQVariant(variant); + return; } - - switch (index) + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexIcao: - this->setIcao(variant.value()); - break; - case IndexIcaoAsString: - this->setIcao(CAirportIcao(variant.toString())); + this->m_icao.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexDescriptiveName: this->setDescriptiveName(variant.toString()); break; case IndexPosition: - this->setPosition(variant.value()); + this->m_position.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexBearing: - this->setBearingToPlane(variant.value()); + this->m_bearingToPlane.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexDistance: - this->setDistanceToPlane(variant.value()); + this->m_distanceToPlane.setPropertyByIndex(variant, index.copyFrontRemoved()); break; default: - Q_ASSERT_X(false, "CAirport", "index unknown (setter)"); + CValueObject::setPropertyByIndex(variant, index); break; } } diff --git a/src/blackmisc/avairport.h b/src/blackmisc/avairport.h index a101fd3ab..61534cbb7 100644 --- a/src/blackmisc/avairport.h +++ b/src/blackmisc/avairport.h @@ -14,6 +14,7 @@ #include "avairporticao.h" #include "coordinategeodetic.h" +#include "propertyindex.h" namespace BlackMisc { @@ -29,8 +30,7 @@ namespace BlackMisc //! Properties by index enum ColumnIndex { - IndexIcao = 0, - IndexIcaoAsString, + IndexIcao = BlackMisc::CPropertyIndex::GlobalIndexCAirport, IndexDescriptiveName, IndexPosition, IndexElevation, @@ -123,10 +123,10 @@ namespace BlackMisc virtual uint getValueHash() const override; //! \copydoc CValueObject::propertyByIndex() - virtual QVariant propertyByIndex(int index) const override; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex(variant, index) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! \copydoc CValueObject::toJson virtual QJsonObject toJson() const override; diff --git a/src/blackmisc/avatcstation.cpp b/src/blackmisc/avatcstation.cpp index 4f8831f2b..35a92b925 100644 --- a/src/blackmisc/avatcstation.cpp +++ b/src/blackmisc/avatcstation.cpp @@ -11,6 +11,7 @@ #include "aviocomsystem.h" #include "voiceroom.h" #include "icon.h" +#include "propertyindex.h" #include "blackmiscfreefunctions.h" using namespace BlackMisc::PhysicalQuantities; @@ -315,69 +316,57 @@ namespace BlackMisc /* * Property by index */ - QVariant CAtcStation::propertyByIndex(int index) const + QVariant CAtcStation::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexBookedFrom: return QVariant(this->m_bookedFromUtc); case IndexBookedUntil: return QVariant(this->m_bookedUntilUtc); case IndexCallsign: - return this->m_callsign.toQVariant(); - case IndexCallsignAsString: - return QVariant(this->m_callsign.asString()); - case IndexCallsignAsStringAsSet: - return QVariant(this->m_callsign.getStringAsSet()); - case IndexPixmap: - return QVariant(this->m_callsign.toPixmap()); + return this->m_callsign.propertyByIndex(index.copyFrontRemoved()); case IndexController: - return this->m_controller.toQVariant(); - case IndexControllerRealName: - return QVariant(this->getControllerRealName()); - case IndexControllerId: - return QVariant(this->getControllerId()); + return this->m_controller.propertyByIndex(index.copyFrontRemoved()); case IndexFrequency: - return this->m_frequency.toQVariant(); + return this->m_frequency.propertyByIndex(index.copyFrontRemoved()); case IndexIsOnline: return QVariant(this->m_isOnline); case IndexLatitude: - return this->latitude().toQVariant(); + return this->latitude().propertyByIndex(index.copyFrontRemoved()); case IndexDistance: - return this->m_distanceToPlane.toQVariant(); + return this->m_distanceToPlane.propertyByIndex(index.copyFrontRemoved()); case IndexLongitude: - return this->longitude().toQVariant(); + return this->longitude().propertyByIndex(index.copyFrontRemoved()); case IndexPosition: - return this->m_position.toQVariant(); + return this->m_position.propertyByIndex(index.copyFrontRemoved()); case IndexRange: - return this->m_range.toQVariant(); + return this->m_range.propertyByIndex(index.copyFrontRemoved()); case IndexAtis: - return this->m_atis.toQVariant(); - case IndexAtisMessage: - return QVariant(this->m_atis.getMessage()); + return this->m_atis.propertyByIndex(index.copyFrontRemoved()); case IndexMetar: - return this->m_metar.toQVariant(); - case IndexMetarMessage: - return QVariant(this->m_metar.getMessage()); + return this->m_metar.propertyByIndex(index.copyFrontRemoved()); case IndexVoiceRoom: - return QVariant(this->m_voiceRoom.toQVariant()); - case IndexVoiceRoomUrl: - return QVariant(this->m_voiceRoom.getVoiceRoomUrl()); + return QVariant(this->m_voiceRoom.propertyByIndex(index.copyFrontRemoved())); default: - break; + if (ICoordinateGeodetic::canHandleIndex(index)) + { + return ICoordinateGeodetic::propertyByIndex(index); + } + return CValueObject::propertyByIndex(index); } - - Q_ASSERT_X(false, "CAtcStation", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); } /* * Set property as index */ - void CAtcStation::setPropertyByIndex(const QVariant &variant, int index) + void CAtcStation::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) { this->fromQVariant(variant); return; } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexBookedFrom: this->setBookedFromUtc(variant.value()); @@ -386,55 +375,37 @@ namespace BlackMisc this->setBookedUntilUtc(variant.value()); break; case IndexCallsign: - this->setCallsign(variant.value()); - break; - case IndexCallsignAsString: - this->setCallsign(CCallsign(variant.value())); + this->m_callsign.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexController: - this->setController(variant.value()); - break; - case IndexControllerRealName: - this->setControllerRealName(variant.value()); - break; - case IndexControllerId: - this->setControllerId(variant.value()); + this->m_controller.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexFrequency: - this->setFrequency(variant.value()); + this->m_frequency.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexIsOnline: this->setOnline(variant.value()); break; case IndexPosition: - this->setPosition(variant.value()); + this->m_position.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexRange: - this->setRange(variant.value()); + this->m_range.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexDistance: - this->setDistanceToPlane(variant.value()); + this->m_distanceToPlane.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexAtis: - this->setAtis(variant.value()); - break; - case IndexAtisMessage: - this->setAtisMessage(variant.value()); + this->m_atis.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexMetar: - this->setMetar(variant.value()); - break; - case IndexMetarMessage: - this->setMetarMessage(variant.value()); + this->m_metar.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexVoiceRoom: - this->setVoiceRoom(variant.value()); - break; - case IndexVoiceRoomUrl: - this->setVoiceRoom(CVoiceRoom(variant.toString())); + this->m_voiceRoom.setPropertyByIndex(variant, index.copyFrontRemoved()); break; default: - Q_ASSERT_X(false, "CAtcStation", "index unknown (setter)"); + CValueObject::setPropertyByIndex(variant, index); break; } } @@ -460,13 +431,15 @@ namespace BlackMisc /* * Property as string by index */ - QString CAtcStation::propertyByIndexAsString(int index, bool i18n) const + QString CAtcStation::propertyByIndexAsString(const BlackMisc::CPropertyIndex &index, bool i18n) const { QVariant qv = this->propertyByIndex(index); + ColumnIndex i = index.frontCasted(); + // special treatment // this is required as it is possible an ATC station is not containing all // properties - switch (index) + switch (i) { case IndexFrequency: if (!CComSystem::isValidCivilAviationFrequency(qv.value())) diff --git a/src/blackmisc/avatcstation.h b/src/blackmisc/avatcstation.h index 76547bb1a..3d108394a 100644 --- a/src/blackmisc/avatcstation.h +++ b/src/blackmisc/avatcstation.h @@ -39,13 +39,8 @@ namespace BlackMisc //! Properties by index enum ColumnIndex { - IndexCallsign = 0, - IndexPixmap, // representing icon - IndexCallsignAsString, - IndexCallsignAsStringAsSet, + IndexCallsign = BlackMisc::CPropertyIndex::GlobalIndexCAtcStation, IndexController, - IndexControllerRealName, - IndexControllerId, IndexFrequency, IndexPosition, IndexRange, @@ -56,11 +51,8 @@ namespace BlackMisc IndexLatitude, IndexLongitude, IndexAtis, - IndexAtisMessage, IndexMetar, - IndexMetarMessage, IndexVoiceRoom, - IndexVoiceRoomUrl }; //! Default constructor. @@ -77,10 +69,10 @@ namespace BlackMisc const CInformationMessage &atis = CInformationMessage(CInformationMessage::ATIS), const CInformationMessage &metar = CInformationMessage(CInformationMessage::METAR)); //! \copydoc CValueObject::toQVariant() - virtual QVariant toQVariant() const override - { - return QVariant::fromValue(*this); - } + virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } + + //! \copydoc CValueObject::toIcon() + virtual BlackMisc::CIcon toIcon() const override { return this->m_callsign.toIcon(); } //! Equal operator == bool operator ==(const CAtcStation &other) const; @@ -278,13 +270,13 @@ namespace BlackMisc virtual uint getValueHash() const override; //! \copydoc CValueObject::propertyByIndex() - virtual QVariant propertyByIndex(int index) const override; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex(variant, index) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; + virtual void setPropertyByIndex(const QVariant &variant, const CPropertyIndex &index) override; //! \copydoc CValueObject::propertyByIndexAsString() - virtual QString propertyByIndexAsString(int index, bool i18n = false) const override; + virtual QString propertyByIndexAsString(const BlackMisc::CPropertyIndex &index, bool i18n = false) const override; //! \copydoc CValueObject::toJson virtual QJsonObject toJson() const override; diff --git a/src/blackmisc/avcallsign.cpp b/src/blackmisc/avcallsign.cpp index 27ac293b2..f6472a671 100644 --- a/src/blackmisc/avcallsign.cpp +++ b/src/blackmisc/avcallsign.cpp @@ -121,6 +121,53 @@ namespace BlackMisc BlackMisc::deserializeJson(json, CCallsign::jsonMembers(), TupleConverter::toTuple(*this)); } + /* + * Index + */ + QVariant CCallsign::propertyByIndex(const CPropertyIndex &index) const + { + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexCallsignString: + return QVariant(this->asString()); + case IndexCallsignStringAsSet: + return QVariant(this->getStringAsSet()); + case IndexTelephonyDesignator: + return QVariant(this->getTelephonyDesignator()); + default: + return CValueObject::propertyByIndex(index); + } + } + + /* + * Index + */ + void CCallsign::setPropertyByIndex(const QVariant &variant, const CPropertyIndex &index) + { + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexCallsignString: + this->m_callsign = variant.toString(); + break; + case IndexCallsignStringAsSet: + this->m_callsignAsSet = variant.toString(); + break; + case IndexTelephonyDesignator: + this->m_telephonyDesignator = variant.toString(); + break; + default: + return CValueObject::setPropertyByIndex(variant, index); + } + } + /* * Members */ diff --git a/src/blackmisc/avcallsign.h b/src/blackmisc/avcallsign.h index 96e24165e..1b4b78bd8 100644 --- a/src/blackmisc/avcallsign.h +++ b/src/blackmisc/avcallsign.h @@ -13,6 +13,7 @@ #define BLACKMISC_CALLSIGN_H #include "valueobject.h" +#include "propertyindex.h" #include "icon.h" namespace BlackMisc @@ -24,6 +25,14 @@ namespace BlackMisc { public: + //! Indexes + enum ColumnIndex + { + IndexCallsignString = BlackMisc::CPropertyIndex::GlobalIndexCCallsign, + IndexCallsignStringAsSet, + IndexTelephonyDesignator + }; + //! Default constructor. CCallsign() {} @@ -82,6 +91,12 @@ namespace BlackMisc //! \copydoc CValueObject::fromJson virtual void fromJson(const QJsonObject &json) override; + //! \copydoc CValueObject::propertyByIndex + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; + + //! \copydoc CValueObject::setPropertyByIndex(variant, index) + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; + //! Register metadata static void registerMetadata(); diff --git a/src/blackmisc/aviomodulator.cpp b/src/blackmisc/aviomodulator.cpp index 1c6b8de42..601a60193 100644 --- a/src/blackmisc/aviomodulator.cpp +++ b/src/blackmisc/aviomodulator.cpp @@ -11,6 +11,7 @@ #include "blackmisc/aviocomsystem.h" #include "blackmisc/avionavsystem.h" #include "blackmisc/avioadfsystem.h" +#include "blackmisc/propertyindex.h" #include "blackmisc/blackmiscfreefunctions.h" using BlackMisc::PhysicalQuantities::CFrequency; @@ -55,6 +56,64 @@ namespace BlackMisc BlackMisc::deserializeJson(json, CModulator::jsonMembers(), TupleConverter::toTuple(*this)); } + /* + * Property by index + */ + template QVariant CModulator::propertyByIndex(const CPropertyIndex &index) const + { + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexActiveFrequency: + return this->getFrequencyActive().propertyByIndex(index.copyFrontRemoved()); + case IndexStandbyFrequency: + return this->getFrequencyStandby().propertyByIndex(index.copyFrontRemoved()); + case IndexEnabled: + return QVariant(this->isEnabled()); + case IndexInputVolume: + return QVariant(this->getVolumeInput()); + case IndexOutputVolume: + return QVariant(this->getVolumeOutput()); + default: + return CValueObject::propertyByIndex(index); + } + } + + /* + * Property by index + */ + template void CModulator::setPropertyByIndex(const QVariant &variant, const CPropertyIndex &index) + { + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexActiveFrequency: + this->m_frequencyActive.setPropertyByIndex(variant, index.copyFrontRemoved()); + break; + case IndexStandbyFrequency: + this->m_frequencyStandby.setPropertyByIndex(variant, index.copyFrontRemoved()); + break; + case IndexEnabled: + this->setEnabled(variant.toBool()); + break; + case IndexInputVolume: + this->setVolumeInput(variant.toInt()); + break; + case IndexOutputVolume: + this->setVolumeOutput(variant.toInt()); + break; + default: + CValueObject::setPropertyByIndex(variant, index); + break; + } + } + /* * Members */ diff --git a/src/blackmisc/aviomodulator.h b/src/blackmisc/aviomodulator.h index b2b43bdc4..7307dbf5d 100644 --- a/src/blackmisc/aviomodulator.h +++ b/src/blackmisc/aviomodulator.h @@ -13,6 +13,7 @@ #define BLACKMISC_AVIOMODULATORUNIT_H #include +#include "blackmisc/propertyindex.h" #include "blackmisc/aviobase.h" #include "blackmisc/mathematics.h" @@ -30,6 +31,17 @@ namespace BlackMisc { public: + + //! Column indexes + enum ColumnIndex + { + IndexActiveFrequency = BlackMisc::CPropertyIndex::GlobalIndexCModulator, + IndexStandbyFrequency, + IndexOutputVolume, + IndexInputVolume, + IndexEnabled + }; + //! Virtual destructor virtual ~CModulator() {} @@ -90,6 +102,12 @@ namespace BlackMisc //! \copydoc CValueObject::fromJson virtual void fromJson(const QJsonObject &json) override; + //! \copydoc CValueObject::propertyByIndex + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; + + //! \copydoc CValueObject::setPropertyByIndex(variant, index) + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; + //! Register metadata static void registerMetadata(); diff --git a/src/blackmisc/aviotransponder.cpp b/src/blackmisc/aviotransponder.cpp index d40b6a859..03f8462cd 100644 --- a/src/blackmisc/aviotransponder.cpp +++ b/src/blackmisc/aviotransponder.cpp @@ -8,6 +8,7 @@ */ #include "blackmisc/aviotransponder.h" +#include "blackmisc/propertyindex.h" #include "blackmisc/blackmiscfreefunctions.h" namespace BlackMisc @@ -222,5 +223,67 @@ namespace BlackMisc { BlackMisc::deserializeJson(json, CTransponder::jsonMembers(), TupleConverter::toTuple(*this)); } + + /* + * Property + */ + QVariant CTransponder::propertyByIndex(const CPropertyIndex &index) const + { + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexMode: + return QVariant(this->getTransponderMode()); + case IndexModeAsString: + return QVariant(this->getModeAsString()); + case IndexTransponderCode: + return QVariant(this->getTransponderCode()); + case IndexTransponderCodeFormatted: + return QVariant(this->getTransponderCodeFormatted()); + case IndexTransponderCodeAndModeFormatted: + return QVariant(this->getTransponderCodeAndModeFormatted()); + default: + break; + } + + Q_ASSERT_X(false, "CTransponder", "index unknown"); + QString m = QString("no property, index ").append(index.toQString()); + return QVariant::fromValue(m); + } + + void CTransponder::setPropertyByIndex(const QVariant &variant, const CPropertyIndex &index) + { + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexMode: + this->setTransponderMode(static_cast(variant.toInt())); + break; + case IndexModeAsString: + this->setTransponderMode(modeFromString(variant.toString())); + break; + case IndexTransponderCode: + case IndexTransponderCodeFormatted: + if (variant.canConvert()) + { + this->setTransponderCode(variant.toInt()); + } + else + { + this->setTransponderCode(variant.toString()); + } + break; + case IndexTransponderCodeAndModeFormatted: + default: + Q_ASSERT_X(false, "CTransponder", "index unknown"); + break; + } + } } // namespace } // namespace diff --git a/src/blackmisc/aviotransponder.h b/src/blackmisc/aviotransponder.h index b3ce05a80..e1befe285 100644 --- a/src/blackmisc/aviotransponder.h +++ b/src/blackmisc/aviotransponder.h @@ -34,6 +34,15 @@ namespace BlackMisc ModeS = 20 }; + //! Indexes + enum ColumnIndex { + IndexMode, + IndexModeAsString, + IndexTransponderCode, + IndexTransponderCodeFormatted, + IndexTransponderCodeAndModeFormatted + }; + //! Default constructor CTransponder() : CAvionicsBase("transponder"), m_transponderCode(0), m_transponderMode(StateStandby) {} @@ -162,6 +171,12 @@ namespace BlackMisc //! \copydoc CValueObject::fromJson void fromJson(const QJsonObject &json) override; + //! \copydoc CValueObject::propertyByIndex + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; + + //! \copydoc CValueObject::setPropertyByIndex(variant, index) + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; + //! \copydoc TupleConverter<>::jsonMembers() static const QStringList &jsonMembers(); diff --git a/src/blackmisc/blackmiscfreefunctions.cpp b/src/blackmisc/blackmiscfreefunctions.cpp index f0a16d8db..a5fec8701 100644 --- a/src/blackmisc/blackmiscfreefunctions.cpp +++ b/src/blackmisc/blackmiscfreefunctions.cpp @@ -16,6 +16,7 @@ #include "audioallclasses.h" #include "hwallclasses.h" #include "settingsblackmiscclasses.h" +#include "propertyindex.h" #include "indexvariantmap.h" #include "namevariantpairlist.h" #include "variant.h" @@ -152,6 +153,7 @@ void BlackMisc::registerMetadata() { CPropertyIndex::registerMetadata(); CVariant::registerMetadata(); + CPropertyIndex::registerMetadata(); CIndexVariantMap::registerMetadata(); CNameVariantPair::registerMetadata(); CNameVariantPairList::registerMetadata(); diff --git a/src/blackmisc/coordinategeodetic.cpp b/src/blackmisc/coordinategeodetic.cpp index 9a55aa37d..4eaf1a996 100644 --- a/src/blackmisc/coordinategeodetic.cpp +++ b/src/blackmisc/coordinategeodetic.cpp @@ -9,6 +9,7 @@ #include "blackmisc/coordinategeodetic.h" #include "blackmisc/blackmiscfreefunctions.h" +#include "blackmisc/propertyindex.h" #include "mathematics.h" #include @@ -209,71 +210,76 @@ namespace BlackMisc return Geo::initialBearing((*this), otherCoordinate); } - /* - * My index - */ - bool ICoordinateGeodetic::indexInRange(int index) - { - return index >= static_cast(IndexLatitude) && - index <= static_cast(IndexLongitudeAsString); - } - /* * Property by index */ - QVariant ICoordinateGeodetic::propertyByIndex(int index) const + QVariant ICoordinateGeodetic::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - - switch (index) + if (!index.isMyself()) { - case IndexLatitude: - return this->latitude().toQVariant(); - case IndexLongitude: - return this->longitude().toQVariant(); - case IndexLatitudeAsString: - return QVariant(this->latitudeAsString()); - case IndexLongitudeAsString: - return QVariant(this->longitudeAsString()); - default: - break; + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexLatitude: + return this->latitude().propertyByIndex(index.copyFrontRemoved()); + case IndexLongitude: + return this->longitude().propertyByIndex(index.copyFrontRemoved()); + case IndexLatitudeAsString: + return QVariant(this->latitudeAsString()); + case IndexLongitudeAsString: + return QVariant(this->longitudeAsString()); + default: + break; + } } Q_ASSERT_X(false, "ICoordinateGeodetic", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); + QString m = QString("no property, index ").append(index.toQString()); return QVariant::fromValue(m); } - /* * Property by index */ - QVariant CCoordinateGeodetic::propertyByIndex(int index) const + QVariant CCoordinateGeodetic::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - if (ICoordinateGeodetic::indexInRange(index)) - { - return ICoordinateGeodetic::propertyByIndex(index); - } - - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { + case IndexLatitude: + return this->m_latitude.propertyByIndex(index.copyFrontRemoved()); + case IndexLatitudeAsString: + return QVariant(this->m_latitude.toQString()); + case IndexLongitude: + return this->m_longitude.propertyByIndex(index.copyFrontRemoved()); + case IndexLongitudeAsString: + return QVariant(this->m_longitude.toQString()); case IndexGeodeticHeight: - return this->m_geodeticHeight.toQVariant(); - break; + return this->m_geodeticHeight.propertyByIndex(index.copyFrontRemoved()); + case IndexGeodeticHeightAsString: + return QVariant(this->m_geodeticHeight.toQString()); default: - break; + if (ICoordinateGeodetic::canHandleIndex(index)) + { + return ICoordinateGeodetic::propertyByIndex(index); + } + return CValueObject::propertyByIndex(index); } - - Q_ASSERT_X(false, "CCoordinateGeodetic", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); } /* * Set property as index */ - void CCoordinateGeodetic::setPropertyByIndex(const QVariant &variant, int index) + void CCoordinateGeodetic::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexGeodeticHeight: this->setGeodeticHeight(variant.value()); @@ -290,8 +296,11 @@ namespace BlackMisc case IndexLongitudeAsString: this->setLongitude(CLongitude::fromWgs84(variant.toString())); break; + case IndexGeodeticHeightAsString: + this->m_geodeticHeight.parseFromString(variant.toString()); + break; default: - Q_ASSERT_X(false, "CCoordinateGeodetic", "index unknown (setter)"); + CValueObject::setPropertyByIndex(variant, index); break; } } diff --git a/src/blackmisc/coordinategeodetic.h b/src/blackmisc/coordinategeodetic.h index c63ab6398..25226d075 100644 --- a/src/blackmisc/coordinategeodetic.h +++ b/src/blackmisc/coordinategeodetic.h @@ -16,6 +16,7 @@ #include "blackmisc/geolatitude.h" #include "blackmisc/geolongitude.h" #include "blackmisc/pqlength.h" +#include "propertyindex.h" namespace BlackMisc { @@ -29,11 +30,10 @@ namespace BlackMisc class ICoordinateGeodetic { public: - //! Properties by index enum ColumnIndex { - IndexLatitude = 6000, + IndexLatitude = BlackMisc::CPropertyIndex::GlobalIndexICoordinateGeodetic, IndexLongitude, IndexLatitudeAsString, IndexLongitudeAsString @@ -48,17 +48,14 @@ namespace BlackMisc //! Longitude virtual const CLongitude &longitude() const = 0; + //! \copydoc CValueObject::propertyByIndex + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const; + //! Latitude as string - QString latitudeAsString() const - { - return this->latitude().toQString(true); - } + QString latitudeAsString() const { return this->latitude().toQString(true); } //! Longitude as string - QString longitudeAsString() const - { - return this->longitude().toQString(true); - } + QString longitudeAsString() const { return this->longitude().toQString(true); } //! Great circle distance BlackMisc::PhysicalQuantities::CLength greatCircleDistance(const ICoordinateGeodetic &otherCoordinate) const; @@ -66,11 +63,12 @@ namespace BlackMisc //! Initial bearing BlackMisc::PhysicalQuantities::CAngle initialBearing(const ICoordinateGeodetic &otherCoordinate) const; - //! In range - static bool indexInRange(int index); - - //! \copydoc CValueObject::propertyByIndex - virtual QVariant propertyByIndex(int index) const; + //! Can given index be handled + static bool canHandleIndex(const BlackMisc::CPropertyIndex &index) + { + int i = index.frontCasted(); + return (i >= static_cast(IndexLatitude)) && (i <= static_cast(IndexLongitudeAsString)); + } }; //! Great circle distance between points @@ -86,14 +84,15 @@ namespace BlackMisc class CCoordinateGeodetic : public CValueObject, public ICoordinateGeodetic { public: - //! Column index + //! Properties by index enum ColumnIndex { - IndexLatitude = 6000, + IndexLatitude = BlackMisc::CPropertyIndex::GlobalIndexCCoordinateGeodetic, IndexLongitude, IndexLatitudeAsString, IndexLongitudeAsString, - IndexGeodeticHeight + IndexGeodeticHeight, + IndexGeodeticHeightAsString }; private: @@ -149,10 +148,10 @@ namespace BlackMisc virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } //! \copydoc CValueObject::propertyByIndex - virtual QVariant propertyByIndex(int index) const override; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex - virtual void setPropertyByIndex(const QVariant &variant, int index) override; + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! Switch unit of latitude / longitude CCoordinateGeodetic &switchUnit(const BlackMisc::PhysicalQuantities::CAngleUnit &unit) diff --git a/src/blackmisc/geolongitude.h b/src/blackmisc/geolongitude.h index 8514ffd1e..08c657444 100644 --- a/src/blackmisc/geolongitude.h +++ b/src/blackmisc/geolongitude.h @@ -43,10 +43,7 @@ namespace BlackMisc CLongitude(double value, const BlackMisc::PhysicalQuantities::CAngleUnit &unit) : CEarthAngle(value, unit) {} //! \copydoc CValueObject::toQVariant - virtual QVariant toQVariant() const override - { - return QVariant::fromValue(*this); - } + virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } //! Virtual destructor virtual ~CLongitude() {} diff --git a/src/blackmisc/hotkeyfunction.h b/src/blackmisc/hotkeyfunction.h index 7d9883b2c..1daac17f3 100644 --- a/src/blackmisc/hotkeyfunction.h +++ b/src/blackmisc/hotkeyfunction.h @@ -49,9 +49,16 @@ namespace BlackMisc void setFunction(const Function &function) { m_function = function; } //! \copydoc CValueObject::toQVariant - virtual QVariant toQVariant() const override + virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } + + //! \copydoc CValueObject::fromQVariant + virtual void fromQVariant(const QVariant &variant) override { - return QVariant::fromValue(*this); + Q_ASSERT(variant.canConvert()); + if (variant.canConvert()) + { + (*this) = variant.value(); + } } //! \copydoc CValueObject::getValueHash diff --git a/src/blackmisc/hwkeyboardkey.cpp b/src/blackmisc/hwkeyboardkey.cpp index 60508a17e..551beb44e 100644 --- a/src/blackmisc/hwkeyboardkey.cpp +++ b/src/blackmisc/hwkeyboardkey.cpp @@ -9,6 +9,7 @@ #include "hwkeyboardkey.h" #include "blackmiscfreefunctions.h" +#include "propertyindex.h" #include namespace BlackMisc @@ -29,23 +30,16 @@ namespace BlackMisc qDBusRegisterMetaType(); } - /* - * To JSON - */ QJsonObject CKeyboardKey::toJson() const { return BlackMisc::serializeJson(TupleConverter::toMetaTuple(*this)); } - /* - * From Json - */ void CKeyboardKey::fromJson(const QJsonObject &json) { BlackMisc::deserializeJson(json, TupleConverter::toMetaTuple(*this)); } - QString CKeyboardKey::convertToQString(bool /* i18n */) const { QString s = this->getModifier1AsString(); @@ -138,51 +132,33 @@ namespace BlackMisc return modifiers; } - /* - * Compare - */ int CKeyboardKey::compareImpl(const CValueObject &otherBase) const { const auto &other = static_cast(otherBase); return compare(TupleConverter::toMetaTuple(*this), TupleConverter::toMetaTuple(other)); } - /* - * Marshall to DBus - */ void CKeyboardKey::marshallToDbus(QDBusArgument &argument) const { argument << TupleConverter::toMetaTuple(*this); } - /* - * Unmarshall from DBus - */ void CKeyboardKey::unmarshallFromDbus(const QDBusArgument &argument) { argument >> TupleConverter::toMetaTuple(*this); } - /* - * Hash - */ uint CKeyboardKey::getValueHash() const { return qHash(TupleConverter::toMetaTuple(*this)); } - /* - * Equal? - */ bool CKeyboardKey::operator ==(const CKeyboardKey &other) const { if (this == &other) return true; return TupleConverter::toMetaTuple(*this) == TupleConverter::toMetaTuple(other); } - /* - * Unequal? - */ bool CKeyboardKey::operator !=(const CKeyboardKey &other) const { return !((*this) == other); @@ -328,9 +304,21 @@ namespace BlackMisc return CKeyboardKey::equalsModifierReleaxed(this->getModifier1(), key.getModifier1()); } - QVariant CKeyboardKey::propertyByIndex(int index) const + bool CKeyboardKey::equalsWithoutFunction(const CKeyboardKey &key) const { - switch (index) + if (key == (*this)) return true; + CKeyboardKey k1(*this); + CKeyboardKey k2(*this); + k1.setFunction(HotkeyNone); + k2.setFunction(HotkeyNone); + return k1 == k2; + } + + QVariant CKeyboardKey::propertyByIndex(const BlackMisc::CPropertyIndex &index) const + { + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexModifier1: return QVariant(static_cast(this->m_modifier1)); @@ -351,7 +339,7 @@ namespace BlackMisc } Q_ASSERT_X(false, "CKeyboardKey", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); + QString m = QString("no property, index ").append(index.toQString()); return QVariant::fromValue(m); } @@ -363,9 +351,15 @@ namespace BlackMisc return ks; } - void CKeyboardKey::setPropertyByIndex(const QVariant &variant, int index) + void CKeyboardKey::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexKey: case IndexKeyAsString: diff --git a/src/blackmisc/hwkeyboardkey.h b/src/blackmisc/hwkeyboardkey.h index 3cc5b336e..c525375f2 100644 --- a/src/blackmisc/hwkeyboardkey.h +++ b/src/blackmisc/hwkeyboardkey.h @@ -210,10 +210,10 @@ namespace BlackMisc bool equalsWithRelaxedModifiers(const CKeyboardKey &key) const; //! \copydoc CValueObject::setPropertyByIndex - virtual void setPropertyByIndex(const QVariant &variant, int index); + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! \copydoc CValueObject::propertyByIndex - virtual QVariant propertyByIndex(int index) const; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! Modifier to string static QString modifierToString(Modifier modifier); diff --git a/src/blackmisc/indexvariantmap.cpp b/src/blackmisc/indexvariantmap.cpp index 7f56b96bd..733e80a92 100644 --- a/src/blackmisc/indexvariantmap.cpp +++ b/src/blackmisc/indexvariantmap.cpp @@ -21,7 +21,7 @@ namespace BlackMisc /* * Constructor single value */ - CIndexVariantMap::CIndexVariantMap(int index, const QVariant &value) + CIndexVariantMap::CIndexVariantMap(const CPropertyIndex &index, const QVariant &value) { this->addValue(index, value); } @@ -49,7 +49,7 @@ namespace BlackMisc { if (this->isEmpty()) return QString("{wildcard: %1}").arg(this->m_wildcard ? "true" : "false"); QString s; - foreach(int index, this->m_values.keys()) + foreach(CPropertyIndex index, this->m_values.keys()) { CVariant v = this->m_values.value(index); @@ -57,7 +57,7 @@ namespace BlackMisc s.append("{wildcard: ").append(this->m_wildcard ? "true" : "false").append(" ") : s.append(", "); - s.append('{').append(QString::number(index)).append(": "); + s.append('{').append(index.toQString(i18n)).append(": "); s.append("(").append(QString::number(v.userType())).append(") "); QString vs = v.toString(i18n); s.append(vs); @@ -81,7 +81,6 @@ namespace BlackMisc bool CIndexVariantMap::isA(int metaTypeId) const { if (metaTypeId == qMetaTypeId()) { return true; } - return this->CValueObject::isA(metaTypeId); } @@ -113,7 +112,7 @@ namespace BlackMisc argument >> indexes; argument >> values; Q_ASSERT(indexes.size() == values.size()); - QMap newMap; + QMap newMap; for (int i = 0; i < indexes.size(); i++) { newMap.insert(indexes[i], values[i]); @@ -125,7 +124,7 @@ namespace BlackMisc /* * Add value */ - void CIndexVariantMap::addValue(int index, const QVariant &value) + void CIndexVariantMap::addValue(const CPropertyIndex &index, const QVariant &value) { this->m_values.insert(index, value); } diff --git a/src/blackmisc/indexvariantmap.h b/src/blackmisc/indexvariantmap.h index dccc29cb7..b4045a86f 100644 --- a/src/blackmisc/indexvariantmap.h +++ b/src/blackmisc/indexvariantmap.h @@ -9,8 +9,9 @@ //! \file -#include "valueobject.h" #include "variant.h" +#include "propertyindex.h" +#include "valueobject.h" #include #include @@ -19,6 +20,9 @@ namespace BlackMisc { + // Forward declaration + class CPropertyIndex; + /*! * Specialized value object compliant map for variants, * based on Column indexes @@ -35,7 +39,7 @@ namespace BlackMisc CIndexVariantMap(bool wildcard = false); //! Single value constructor - CIndexVariantMap(int index, const QVariant &value); + CIndexVariantMap(const CPropertyIndex &index, const QVariant &value); //! \copydoc CValueObject::toQVariant virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } @@ -44,25 +48,25 @@ namespace BlackMisc virtual ~CIndexVariantMap() {} //! Add a value - void addValue(int index, const QVariant &value); + void addValue(const CPropertyIndex &index, const QVariant &value); //! Add a value as non QVariant - template void addValue(int index, const T &value) { this->m_values.insert(index, CVariant::fromValue(value)); } + template void addValue(const CPropertyIndex &index, const T &value) { this->m_values.insert(index, CVariant::fromValue(value)); } //! Is empty? bool isEmpty() const { return this->m_values.isEmpty(); } //! Value - QVariant value(int index) const { return this->m_values.value(index).toQVariant(); } + QVariant value(const CPropertyIndex &index) const { return this->m_values.value(index).toQVariant(); } //! Set value - void value(int index, const QVariant &value) { this->m_values.value(index, value); } + void value(const CPropertyIndex &index, const QVariant &value) { this->m_values.value(index, value); } //! Indexes - QList indexes() const { return this->m_values.keys(); } + QList indexes() const { return this->m_values.keys(); } //! Contains index? - bool contains(int index) const { return this->m_values.contains(index); } + bool contains(const CPropertyIndex &index) const { return this->m_values.contains(index); } //! values QList values() const { return this->m_values.values(); } @@ -83,7 +87,7 @@ namespace BlackMisc bool operator !=(const CIndexVariantMap &other) const; //! Map - const QMap &map() const { return this->m_values; } + const QMap &map() const { return this->m_values; } //! \copydoc CValueObject::getValueHash virtual uint getValueHash() const override; @@ -92,7 +96,7 @@ namespace BlackMisc static void registerMetadata(); protected: - QMap m_values; //!< values + QMap m_values; //!< values bool m_wildcard; //!< wildcard //! \copydoc CValueObject::convertToQString diff --git a/src/blackmisc/namevariantpair.cpp b/src/blackmisc/namevariantpair.cpp index a794e5773..334a5dea1 100644 --- a/src/blackmisc/namevariantpair.cpp +++ b/src/blackmisc/namevariantpair.cpp @@ -117,15 +117,17 @@ namespace BlackMisc /* * Property by index */ - QVariant CNameVariantPair::propertyByIndex(int index) const + QVariant CNameVariantPair::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexName: return QVariant(this->m_name); case IndexVariant: return this->m_variant.toQVariant(); - case IndexIcon: + case IndexCallsignIcon: return this->m_icon.toQVariant(); case IndexPixmap: return this->m_icon.toPixmap(); @@ -134,16 +136,22 @@ namespace BlackMisc } Q_ASSERT_X(false, "CNameVariantPair", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); + QString m = QString("no property, index ").append(index.toQString()); return QVariant::fromValue(m); } /* * Property by index (setter) */ - void CNameVariantPair::setPropertyByIndex(const QVariant &variant, int index) + void CNameVariantPair::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexName: this->setName(variant.value()); @@ -151,7 +159,7 @@ namespace BlackMisc case IndexVariant: this->m_variant = variant; break; - case IndexIcon: + case IndexCallsignIcon: if (variant.canConvert()) { CIcons::IconIndex index = static_cast(variant.toInt()); diff --git a/src/blackmisc/namevariantpair.h b/src/blackmisc/namevariantpair.h index 5854a98e7..f8822a826 100644 --- a/src/blackmisc/namevariantpair.h +++ b/src/blackmisc/namevariantpair.h @@ -77,15 +77,15 @@ namespace BlackMisc { IndexName = 0, IndexVariant, - IndexIcon, + IndexCallsignIcon, IndexPixmap }; //! \copydoc CValueObject::propertyByIndex() - virtual QVariant propertyByIndex(int index) const override; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex(variant, index) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; protected: //! \copydoc CValueObject::convertToQString() diff --git a/src/blackmisc/nwaircraftmapping.cpp b/src/blackmisc/nwaircraftmapping.cpp index a66fd1cf4..bd9d4a539 100644 --- a/src/blackmisc/nwaircraftmapping.cpp +++ b/src/blackmisc/nwaircraftmapping.cpp @@ -8,6 +8,7 @@ */ #include "nwaircraftmapping.h" +#include "propertyindex.h" using namespace BlackMisc::Aviation; using namespace BlackMisc::Network; @@ -144,36 +145,44 @@ namespace BlackMisc /* * Property by index */ - QVariant CAircraftMapping::propertyByIndex(int index) const + QVariant CAircraftMapping::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexModel: - return this->m_model.toQVariant(); + return this->m_model.propertyByIndex(index.copyFrontRemoved()); break; case IndexIcaoCode: - return this->m_icao.toQVariant(); + return this->m_model.propertyByIndex(index.copyFrontRemoved()); break; default: break; } Q_ASSERT_X(false, "CAircraftMapping", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); + QString m = QString("no property, index ").append(index.toQString()); return QVariant::fromValue(m); } /* * Set property as index */ - void CAircraftMapping::setPropertyByIndex(const QVariant &variant, int index) + void CAircraftMapping::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexModel: - this->m_model = variant.value(); + this->m_model.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexIcaoCode: - this->m_icao = variant.value(); + this->m_icao.setPropertyByIndex(variant, index.copyFrontRemoved()); break; default: Q_ASSERT_X(false, "CAircraftMapping", "index unknown"); diff --git a/src/blackmisc/nwaircraftmapping.h b/src/blackmisc/nwaircraftmapping.h index bc2c677ad..ca96a58c3 100644 --- a/src/blackmisc/nwaircraftmapping.h +++ b/src/blackmisc/nwaircraftmapping.h @@ -51,7 +51,7 @@ namespace BlackMisc public: //! Properties - enum IndexProperties + enum ColumnIndex { IndexModel, IndexIcaoCode @@ -73,10 +73,10 @@ namespace BlackMisc bool operator !=(const CAircraftMapping &other) const; //! \copydoc CValueObject::propertyByIndex - QVariant propertyByIndex(int index) const override; + QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex - void setPropertyByIndex(const QVariant &variant, int index) override; + void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! ICAO void setIcao(const BlackMisc::Aviation::CAircraftIcao &icao) { this->m_icao = icao; } diff --git a/src/blackmisc/nwaircraftmodel.cpp b/src/blackmisc/nwaircraftmodel.cpp index b42ae2f9a..c0e6c0103 100644 --- a/src/blackmisc/nwaircraftmodel.cpp +++ b/src/blackmisc/nwaircraftmodel.cpp @@ -128,39 +128,45 @@ namespace BlackMisc /* * Property by index */ - QVariant CAircraftModel::propertyByIndex(int index) const + QVariant CAircraftModel::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexModelString: return QVariant(this->m_modelString); break; - case IndexQueriedModelString: + case IndexIsQueriedModelString: return QVariant(this->m_queriedModelStringFlag); break; default: + return CValueObject::propertyByIndex(index); break; } - Q_ASSERT_X(false, "CAircraftModel", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); } /* * Set property as index */ - void CAircraftModel::setPropertyByIndex(const QVariant &variant, int index) + void CAircraftModel::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexModelString: this->m_modelString = variant.toString(); break; - case IndexQueriedModelString: + case IndexIsQueriedModelString: this->m_queriedModelStringFlag = variant.toBool(); break; default: - Q_ASSERT_X(false, "CAircraftModel", "index unknown"); + CValueObject::setPropertyByIndex(variant, index); break; } } diff --git a/src/blackmisc/nwaircraftmodel.h b/src/blackmisc/nwaircraftmodel.h index de1ca787a..1559db599 100644 --- a/src/blackmisc/nwaircraftmodel.h +++ b/src/blackmisc/nwaircraftmodel.h @@ -13,7 +13,7 @@ #define BLACKMISC_AIRCRAFTMODEL_H #include "nwuser.h" -#include "valueobject.h" +#include "propertyindex.h" namespace BlackMisc { @@ -28,10 +28,10 @@ namespace BlackMisc public: //! Indexes - enum ColumnIndex : uint + enum ColumnIndex { - IndexModelString = 100, - IndexQueriedModelString + IndexModelString = BlackMisc::CPropertyIndex::GlobalIndexCAircraftModel, + IndexIsQueriedModelString }; //! Default constructor. @@ -59,10 +59,10 @@ namespace BlackMisc void fromJson(const QJsonObject &json) override; //! \copydoc CValueObject::propertyByIndex(int) - virtual QVariant propertyByIndex(int index) const override; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex(const QVariant, int) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! Queried model string const QString &getModelString() const { return this->m_modelString; } diff --git a/src/blackmisc/nwclient.cpp b/src/blackmisc/nwclient.cpp index 935ab60e3..abd7cec3c 100644 --- a/src/blackmisc/nwclient.cpp +++ b/src/blackmisc/nwclient.cpp @@ -9,6 +9,8 @@ #include "nwclient.h" #include "icon.h" +#include "avcallsign.h" + #include namespace BlackMisc @@ -173,83 +175,66 @@ namespace BlackMisc /* * Property by index */ - QVariant CClient::propertyByIndex(int index) const + QVariant CClient::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - if (index < static_cast(IndexQueriedModelString)) - { - return this->m_user.propertyByIndex(index); - } - else if (index < static_cast(IndexCapabilities)) - { - return this->m_model.propertyByIndex(index); - } - - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexCapabilities: return this->m_capabilities.toQVariant(); - break; case IndexCapabilitiesString: return QVariant(this->getCapabilitiesAsString()); - break; + case IndexCallsign: + return this->getCallsign().propertyByIndex(index.copyFrontRemoved()); + case IndexUser: + return this->getUser().propertyByIndex(index.copyFrontRemoved()); case IndexModel: - return QVariant(this->m_model.toQVariant()); - break; + return this->m_model.propertyByIndex(index.copyFrontRemoved()); case IndexServer: return QVariant(this->m_server); - break; case IndexVoiceCapabilities: - return this->m_voiceCapabilities.toQVariant(); - break; - case IndexVoiceCapabilitiesString: - return QVariant(this->m_voiceCapabilities.toQString(false)); - break; + return this->m_voiceCapabilities.propertyByIndex(index.copyFrontRemoved()); case IndexVoiceCapabilitiesPixmap: return QVariant(this->m_voiceCapabilities.toPixmap()); - break; default: - break; + return CValueObject::propertyByIndex(index); } - Q_ASSERT_X(false, "CClient", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); } /* * Set property as index */ - void CClient::setPropertyByIndex(const QVariant &variant, int index) + void CClient::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - if (index < static_cast(IndexQueriedModelString)) + if (index.isMyself()) { - this->m_user.setPropertyByIndex(variant, index); + this->fromQVariant(variant); return; } - else if (index < static_cast(IndexCapabilities)) - { - this->m_model.setPropertyByIndex(variant, index); - return; - } - - switch (index) + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexCapabilities: this->m_capabilities = variant.value(); break; case IndexModel: - this->m_model = variant.value(); + this->m_model.setPropertyByIndex(variant, index.copyFrontRemoved());; break; case IndexServer: this->m_server = variant.toString(); break; - case IndexVoiceCapabilities: - this->m_voiceCapabilities = variant.value(); + case IndexUser: + this->m_user.setPropertyByIndex(variant, index.copyFrontRemoved()); break; - case IndexVoiceCapabilitiesString: - this->m_voiceCapabilities = CVoiceCapabilities(variant.toString()); + case IndexCallsign: + this->m_user.setCallsign(variant.value()); + break; + case IndexVoiceCapabilities: + this->m_voiceCapabilities.setPropertyByIndex(variant, index.copyFrontRemoved()); break; default: - Q_ASSERT_X(false, "CClient", "index unknown"); + CValueObject::setPropertyByIndex(variant, index); break; } } diff --git a/src/blackmisc/nwclient.h b/src/blackmisc/nwclient.h index 42330bcd9..8367590f7 100644 --- a/src/blackmisc/nwclient.h +++ b/src/blackmisc/nwclient.h @@ -15,7 +15,7 @@ #include "nwuser.h" #include "nwaircraftmodel.h" #include "nwvoicecapabilities.h" -#include "valueobject.h" +#include "propertyindex.h" #include "indexvariantmap.h" namespace BlackMisc @@ -30,22 +30,14 @@ namespace BlackMisc public: //! Properties by index - enum ColumnIndex : uint + enum ColumnIndex { - // user - IndexEmail = 0, - IndexId, - IndexPassword, - IndexRealName, - IndexCallsign, - IndexCallsignIcon, - // model - IndexQueriedModelString = 100, - // own indexes - IndexCapabilities = 1000, + IndexCapabilities = BlackMisc::CPropertyIndex::GlobalIndexCClient, IndexCapabilitiesString, IndexModel, IndexServer, + IndexUser, + IndexCallsign, IndexVoiceCapabilities, IndexVoiceCapabilitiesString, IndexVoiceCapabilitiesPixmap @@ -134,18 +126,18 @@ namespace BlackMisc //! \copydoc CValueObject::toIcon() virtual CIcon toIcon() const override { return this->m_user.toIcon(); } + //! \copydoc CValueObject::propertyByIndex(int) + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; + + //! \copydoc CValueObject::setPropertyByIndex(const QVariant, int) + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; + //! Register metadata static void registerMetadata(); //! \copydoc TupleConverter<>::jsonMembers() static const QStringList &jsonMembers(); - //! \copydoc CValueObject::propertyByIndex(int) - virtual QVariant propertyByIndex(int index) const override; - - //! \copydoc CValueObject::setPropertyByIndex(const QVariant, int) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; - protected: //! \copydoc CValueObject::convertToQString virtual QString convertToQString(bool i18n = false) const override; diff --git a/src/blackmisc/nwserver.cpp b/src/blackmisc/nwserver.cpp index a3de28a94..acf26ef5c 100644 --- a/src/blackmisc/nwserver.cpp +++ b/src/blackmisc/nwserver.cpp @@ -9,6 +9,7 @@ #include "nwserver.h" #include "blackmisc/blackmiscfreefunctions.h" +#include "blackmisc/propertyindex.h" #include namespace BlackMisc @@ -107,9 +108,11 @@ namespace BlackMisc /* * Property by index */ - QVariant CServer::propertyByIndex(int index) const + QVariant CServer::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexAddress: return QVariant::fromValue(this->m_address); @@ -119,10 +122,8 @@ namespace BlackMisc return QVariant::fromValue(this->m_name); case IndexPort: return QVariant::fromValue(this->m_port); - case IndexUserId: - return QVariant::fromValue(this->m_user.getId()); - case IndexUserRealName: - return QVariant::fromValue(this->m_user.getRealName()); + case IndexUser: + return this->m_user.propertyByIndex(index.copyFrontRemoved()); case IndexIsAcceptingConnections: return QVariant::fromValue(this->m_isAcceptingConnections); default: @@ -130,16 +131,23 @@ namespace BlackMisc } Q_ASSERT_X(false, "CServer", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); + QString m = QString("no property, index ").append(index.toQString()); return QVariant::fromValue(m); } /* * Property by index (setter) */ - void CServer::setPropertyByIndex(const QVariant &variant, int index) + void CServer::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexAddress: this->setAddress(variant.value()); @@ -153,14 +161,8 @@ namespace BlackMisc case IndexName: this->setName(variant.value()); break; - case IndexUserId: - this->m_user.setId(variant.value()); - break; - case IndexUserPassword: - this->m_user.setPassword(variant.value()); - break; - case IndexUserRealName: - this->m_user.setRealName(variant.value()); + case IndexUser: + this->m_user.setPropertyByIndex(variant, index.copyFrontRemoved()); break; case IndexIsAcceptingConnections: this->setIsAcceptingConnections(variant.value()); diff --git a/src/blackmisc/nwuser.cpp b/src/blackmisc/nwuser.cpp index 39780803f..edaf3d7c5 100644 --- a/src/blackmisc/nwuser.cpp +++ b/src/blackmisc/nwuser.cpp @@ -10,6 +10,7 @@ #include "nwuser.h" #include "blackmisc/icon.h" #include "blackmisc/blackmiscfreefunctions.h" +#include "blackmisc/propertyindex.h" #include namespace BlackMisc @@ -165,9 +166,11 @@ namespace BlackMisc /* * Property by index */ - QVariant CUser::propertyByIndex(int index) const + QVariant CUser::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexEmail: return QVariant(this->m_email); @@ -178,24 +181,24 @@ namespace BlackMisc case IndexRealName: return QVariant(this->m_realname); case IndexCallsign: - return this->m_callsign.toQVariant(); - case IndexCallsignPixmap: - return QVariant(this->m_callsign.toPixmap()); + return this->m_callsign.propertyByIndex(index.copyFrontRemoved()); default: - break; + return CValueObject::propertyByIndex(index); } - - Q_ASSERT_X(false, "CUser", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); } /* * Set property as index */ - void CUser::setPropertyByIndex(const QVariant &variant, int index) + void CUser::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexEmail: this->setEmail(variant.value()); @@ -210,10 +213,10 @@ namespace BlackMisc this->setRealName(variant.value()); break; case IndexCallsign: - this->setCallsign(variant.value()); + this->m_callsign.setPropertyByIndex(variant, index.copyFrontRemoved()); break; default: - Q_ASSERT_X(false, "CUser", "index unknown (setter)"); + CValueObject::setPropertyByIndex(variant, index); break; } } diff --git a/src/blackmisc/nwuser.h b/src/blackmisc/nwuser.h index 0ced05699..18459dc5e 100644 --- a/src/blackmisc/nwuser.h +++ b/src/blackmisc/nwuser.h @@ -14,6 +14,7 @@ #include "avcallsign.h" #include "avairporticao.h" +#include "propertyindex.h" namespace BlackMisc { @@ -33,12 +34,11 @@ namespace BlackMisc */ enum ColumnIndex { - IndexEmail, + IndexEmail = BlackMisc::CPropertyIndex::GlobalIndexCUser, IndexId, IndexPassword, IndexRealName, - IndexCallsign, - IndexCallsignPixmap + IndexCallsign }; //! Default constructor. @@ -117,9 +117,6 @@ namespace BlackMisc //! Set associated callsign void setCallsign(const BlackMisc::Aviation::CCallsign &callsign) { m_callsign = callsign; } - //! \copydoc CValueObject::toIcon() - virtual BlackMisc::CIcon toIcon() const override { return this->getCallsign().toIcon(); } - //! Equal operator == bool operator ==(const CUser &other) const; @@ -129,17 +126,20 @@ namespace BlackMisc //! \copydoc CValueObject::getValueHash() virtual uint getValueHash() const override; + //! \copydoc CValueObject::toIcon() + virtual BlackMisc::CIcon toIcon() const override { return this->getCallsign().toIcon(); } + //! \copydoc CValueObject::toJson virtual QJsonObject toJson() const override; //! \copydoc CValueObject::fromJson - void fromJson(const QJsonObject &json) override; + virtual void fromJson(const QJsonObject &json) override; - //! Register metadata - static void registerMetadata(); + //! \copydoc CValueObject::propertyByIndex(int) + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; - //! Members - static const QStringList &jsonMembers(); + //! \copydoc CValueObject::setPropertyByIndex(const QVariant, int) + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; /*! * This and another user exchange missing data. @@ -148,11 +148,11 @@ namespace BlackMisc */ void syncronizeData(CUser &otherUser); - //! \copydoc CValueObject::propertyByIndex(int) - virtual QVariant propertyByIndex(int index) const override; + //! Register metadata + static void registerMetadata(); - //! \copydoc CValueObject::setPropertyByIndex(const QVariant, int) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; + //! Members + static const QStringList &jsonMembers(); protected: //! \copydoc CValueObject::convertToQString diff --git a/src/blackmisc/nwvoicecapabilites.cpp b/src/blackmisc/nwvoicecapabilites.cpp index 75b05af98..3b79c8d3b 100644 --- a/src/blackmisc/nwvoicecapabilites.cpp +++ b/src/blackmisc/nwvoicecapabilites.cpp @@ -133,8 +133,10 @@ namespace BlackMisc return CIconList::iconForIndex(CIcons::NetworkCapabilityUnknown); case VoiceReceivingOnly: return CIconList::iconForIndex(CIcons::NetworkCapabilityVoiceReceiveOnly); + default: + break; } - Q_ASSERT("Wrong index"); + Q_ASSERT(false); return CIconList::iconForIndex(CIcons::NetworkCapabilityUnknown); // never reached } diff --git a/src/blackmisc/nwvoicecapabilities.h b/src/blackmisc/nwvoicecapabilities.h index 084328b80..d079f7652 100644 --- a/src/blackmisc/nwvoicecapabilities.h +++ b/src/blackmisc/nwvoicecapabilities.h @@ -39,7 +39,7 @@ namespace BlackMisc CVoiceCapabilities() {} //! Constructor by callsign - CVoiceCapabilities(VoiceCapabilities capabilities) : m_voiceCapabilities(static_cast(capabilities)) {} + CVoiceCapabilities(VoiceCapabilities capabilities) : m_voiceCapabilities(static_cast(capabilities)) {} //! Constructor. CVoiceCapabilities(const QString &flightPlanRemarks); @@ -51,7 +51,7 @@ namespace BlackMisc VoiceCapabilities getCapabilities() const { return static_cast(m_voiceCapabilities); } //! Set capabilites - void setCapabilities(VoiceCapabilities capabilites) { m_voiceCapabilities = static_cast(capabilites); } + void setCapabilities(VoiceCapabilities capabilites) { m_voiceCapabilities = static_cast(capabilites); } //! \copydoc CValueObject::toIcon() virtual CIcon toIcon() const override; @@ -98,7 +98,7 @@ namespace BlackMisc private: BLACK_ENABLE_TUPLE_CONVERSION(CVoiceCapabilities) - uint m_voiceCapabilities; + int m_voiceCapabilities = Unknown; //! Capabilites from flight plans remarks such as "/V/" void fromFlightPlanRemarks(const QString &flightPlanRemarks); diff --git a/src/blackmisc/setkeyboardhotkey.cpp b/src/blackmisc/setkeyboardhotkey.cpp index 361bf79ac..b6f41cf93 100644 --- a/src/blackmisc/setkeyboardhotkey.cpp +++ b/src/blackmisc/setkeyboardhotkey.cpp @@ -130,9 +130,11 @@ namespace BlackMisc m_key = obj.m_key; } - QVariant CSettingKeyboardHotkey::propertyByIndex(int index) const + QVariant CSettingKeyboardHotkey::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexFunction: return QVariant(m_hotkeyFunction.getFunction()); @@ -153,17 +155,19 @@ namespace BlackMisc case IndexKeyAsStringRepresentation: return QVariant(m_key.getKeyAsStringRepresentation()); default: - break; + return CValueObject::propertyByIndex(index); } - - Q_ASSERT_X(false, "CSettingKeyboardHotkey", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); } - void CSettingKeyboardHotkey::setPropertyByIndex(const QVariant &variant, int index) + void CSettingKeyboardHotkey::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexFunction: { @@ -192,9 +196,10 @@ namespace BlackMisc this->setObject(variant.value()); break; default: - Q_ASSERT_X(false, "CSettingKeyboardHotkey", "index unknown (setter)"); + CValueObject::setPropertyByIndex(variant, index); break; } } + } // namespace Hardware } // BlackMisc diff --git a/src/blackmisc/setkeyboardhotkey.h b/src/blackmisc/setkeyboardhotkey.h index cf3e46f1c..d01466503 100644 --- a/src/blackmisc/setkeyboardhotkey.h +++ b/src/blackmisc/setkeyboardhotkey.h @@ -12,7 +12,7 @@ #ifndef BLACKMISC_SETTINGS_KEYBOARDHOTKEY_H #define BLACKMISC_SETTINGS_KEYBOARDHOTKEY_H -#include "valueobject.h" +#include "propertyindex.h" #include "hwkeyboardkey.h" #include "hotkeyfunction.h" #include @@ -52,9 +52,16 @@ namespace BlackMisc CSettingKeyboardHotkey(const Hardware::CKeyboardKey &key, const CHotkeyFunction &function); //! \copydoc CValueObject::toQVariant - virtual QVariant toQVariant() const override + virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } + + //! \copydoc CValueObject::fromQVariant + virtual void fromQVariant(const QVariant &variant) override { - return QVariant::fromValue(*this); + Q_ASSERT(variant.canConvert()); + if (variant.canConvert()) + { + (*this) = variant.value(); + } } //! \copydoc CValueObject::getValueHash @@ -109,10 +116,10 @@ namespace BlackMisc static QString toStringRepresentation(int key) { return Hardware::CKeyboardKey::toStringRepresentation(key); } //! \copydoc CValueObject::setPropertyByIndex - virtual void setPropertyByIndex(const QVariant &variant, int index); + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! \copydoc CValueObject::propertyByIndex - virtual QVariant propertyByIndex(int index) const; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; protected: //! \copydoc CValueObject::convertToQString diff --git a/src/blackmisc/statusmessage.cpp b/src/blackmisc/statusmessage.cpp index e6ed7f258..4fa8bb019 100644 --- a/src/blackmisc/statusmessage.cpp +++ b/src/blackmisc/statusmessage.cpp @@ -9,6 +9,7 @@ #include "statusmessage.h" #include "blackmiscfreefunctions.h" +#include "propertyindex.h" #include "iconlist.h" #include @@ -266,9 +267,11 @@ namespace BlackMisc /* * Property by index */ - QVariant CStatusMessage::propertyByIndex(int index) const + QVariant CStatusMessage::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexMessage: return QVariant(this->m_message); @@ -278,6 +281,11 @@ namespace BlackMisc return QVariant(this->getSeverityAsString()); case IndexTimestamp: return QVariant(this->m_timestamp); + case IndexTimestampFormatted: + { + if (this->m_timestamp.isNull() || !this->m_timestamp.isValid()) return ""; + return this->m_timestamp.toString("HH:mm::ss.zzz"); + } case IndexType: return QVariant(static_cast(this->m_type)); case IndexTypeAsString: @@ -287,16 +295,22 @@ namespace BlackMisc } Q_ASSERT_X(false, "CStatusMessage", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); + QString m = QString("no property, index ").append(index.toQString()); return QVariant::fromValue(m); } /* * Set property as index */ - void CStatusMessage::setPropertyByIndex(const QVariant &variant, int index) + void CStatusMessage::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexMessage: this->m_message = variant.value(); @@ -311,32 +325,11 @@ namespace BlackMisc this->m_type = static_cast(variant.value()); break; default: - Q_ASSERT_X(false, "CStatusMessage", "index unknown (setter)"); + CValueObject::setPropertyByIndex(variant, index); break; } } - /* - * Property as string by index - */ - QString CStatusMessage::propertyByIndexAsString(int index, bool i18n) const - { - QVariant qv = this->propertyByIndex(index); - switch (index) - { - case IndexTimestamp: - { - QDateTime dt = qv.value(); - if (dt.isNull() || !dt.isValid()) return ""; - return dt.toString("HH:mm::ss.zzz"); - break; - } - default: - break; - } - return BlackMisc::qVariantToString(qv, i18n); - } - /* * Message as HTML */ diff --git a/src/blackmisc/statusmessage.h b/src/blackmisc/statusmessage.h index 31b2306d4..f9232188f 100644 --- a/src/blackmisc/statusmessage.h +++ b/src/blackmisc/statusmessage.h @@ -13,7 +13,7 @@ #define BLACKMISC_STATUSMESSAGE_H #include "icon.h" -#include "valueobject.h" +#include "propertyindex.h" #include namespace BlackMisc @@ -28,8 +28,8 @@ namespace BlackMisc //! Status types enum StatusType { - TypeUnknown, // not set - TypeUnspecific, // intentionally set + TypeUnknown, //!< not set + TypeUnspecific, //!< intentionally set, but not specific TypeValidation, TypeTrafficNetwork, TypeSimulator, @@ -51,22 +51,15 @@ namespace BlackMisc //! Properties by index enum ColumnIndex { - IndexType, + IndexType = BlackMisc::CPropertyIndex::GlobalIndexCStatusMessage, IndexTypeAsString, IndexSeverity, IndexSeverityAsString, IndexMessage, - IndexTimestamp + IndexTimestamp, + IndexTimestampFormatted }; - private: - BLACK_ENABLE_TUPLE_CONVERSION(CStatusMessage) - StatusType m_type; - StatusSeverity m_severity; - QString m_message; - QDateTime m_timestamp; - - public: //! Constructor CStatusMessage() : m_type(TypeUnknown), m_severity(SeverityInfo) {} @@ -107,13 +100,10 @@ namespace BlackMisc const QString &getSeverityAsString() const; //! \copydoc CValueObject::propertyByIndex(int) - virtual QVariant propertyByIndex(int index) const override; + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::propertyByIndex(const QVariant, int) - virtual void setPropertyByIndex(const QVariant &variant, int index) override; - - //! \copydoc CValueObject::propertyByIndexAsString - virtual QString propertyByIndexAsString(int index, bool i18n) const override; + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; //! To HTML QString toHtml() const; @@ -160,6 +150,14 @@ namespace BlackMisc //! \copydoc CValueObject::compareImpl virtual int compareImpl(const CValueObject &other) const override; + + private: + BLACK_ENABLE_TUPLE_CONVERSION(CStatusMessage) + StatusType m_type; + StatusSeverity m_severity; + QString m_message; + QDateTime m_timestamp; + }; } diff --git a/src/blackmisc/valueobject.cpp b/src/blackmisc/valueobject.cpp index 598535d52..87c547af4 100644 --- a/src/blackmisc/valueobject.cpp +++ b/src/blackmisc/valueobject.cpp @@ -8,6 +8,7 @@ */ #include "valueobject.h" +#include "propertyindex.h" #include "indexvariantmap.h" #include "blackmiscfreefunctions.h" #include "iconlist.h" @@ -51,26 +52,48 @@ namespace BlackMisc /* * Setter for property by index */ - void CValueObject::setPropertyByIndex(const QVariant & /** variant **/, int /** index **/) + void CValueObject::setPropertyByIndex(const QVariant &variant, const CPropertyIndex &index) { - // not all classes have to implement this - qFatal("Property by index setter not implemented"); + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + + // not all classes have implemented nesting + const QString m = QString("Property by index not found (setter), index: ").append(index.toQString()); + qFatal(m.toLatin1().constData()); } /* * By index */ - QVariant CValueObject::propertyByIndex(int /** index **/) const + QVariant CValueObject::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - // not all classes have to implement this - qFatal("Property by index not implemented"); - return QVariant("propertyByIndex not implemented"); // avoid compiler warning + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexIcon: + return this->toIcon().toQVariant(); + case IndexPixmap: + return QVariant(this->toPixmap()); + case IndexString: + return QVariant(this->toQString()); + default: + break; + } + + // not all classes have implemented nesting + const QString m = QString("Property by index not found, index: ").append(index.toQString()); + qFatal(m.toLatin1().constData()); + return QVariant(m); // avoid compiler warning } /* * By index as string */ - QString CValueObject::propertyByIndexAsString(int index, bool i18n) const + QString CValueObject::propertyByIndexAsString(const CPropertyIndex &index, bool i18n) const { // default implementation, requires propertyByIndex QVariant qv = this->propertyByIndex(index); diff --git a/src/blackmisc/valueobject.h b/src/blackmisc/valueobject.h index 958ee192e..1a73aa468 100644 --- a/src/blackmisc/valueobject.h +++ b/src/blackmisc/valueobject.h @@ -31,6 +31,7 @@ namespace BlackMisc { // forward declaration + class CPropertyIndex; class CIndexVariantMap; class CIcon; @@ -159,6 +160,14 @@ namespace BlackMisc friend int compare(const CValueObject &v1, const CValueObject &v2); public: + //! Base class enums + enum ColumnIndex + { + IndexPixmap, + IndexIcon, + IndexString + }; + //! Virtual destructor virtual ~CValueObject() {} @@ -195,30 +204,17 @@ namespace BlackMisc //! As pixmap, required for most GUI views virtual QPixmap toPixmap() const; - /*! - * \brief Set property by index - * \remarks Intentionally not abstract, avoiding all classes need to implement this method - * \param variant - * \param index as used in Qt table views - */ - virtual void setPropertyByIndex(const QVariant &variant, int index); + //! Set property by index + //! \remarks Intentionally not abstract, avoiding all classes need to implement this method + virtual void setPropertyByIndex(const QVariant &variant, const CPropertyIndex &index); - /*! - * \brief Property by index - * \remarks Intentionally not abstract, avoiding all classes need to implement this method - * \param index as used in Qt table views - * \return - */ - virtual QVariant propertyByIndex(int index) const; + //! Property by index + //! \remarks Intentionally not abstract, avoiding all classes need to implement this method + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const; - /*! - * \brief Property by index as String - * \remarks Intentionally not abstract, avoiding all classes need to implement this method - * \param index as used in Qt table views - * \param i18n - * \return - */ - virtual QString propertyByIndexAsString(int index, bool i18n = false) const; + //! Property by index as String + //! Intentionally not abstract, avoiding all classes need to implement this method + virtual QString propertyByIndexAsString(const CPropertyIndex &index, bool i18n = false) const; //! The stored object as CValueObject static const CValueObject *fromQVariant(const QVariant &qv); diff --git a/src/blackmisc/voiceroom.cpp b/src/blackmisc/voiceroom.cpp index 8f09bbe97..e3c88e93e 100644 --- a/src/blackmisc/voiceroom.cpp +++ b/src/blackmisc/voiceroom.cpp @@ -9,6 +9,7 @@ #include "voiceroom.h" #include "blackmisc/blackmiscfreefunctions.h" +#include "blackmisc/propertyindex.h" #include #include #include @@ -17,18 +18,13 @@ namespace BlackMisc { namespace Audio { - CVoiceRoom::CVoiceRoom(const QString &serverUrl, bool connected) : + /* + * Constructor + */ + CVoiceRoom::CVoiceRoom(const QString &voiceRoomUrl, bool connected) : m_connected(connected), m_audioPlaying(false) { - if (serverUrl.contains("/")) - { - QString url = serverUrl.trimmed().toLower(); - url.replace(CVoiceRoom::protocolComplete(), ""); - url.replace(CVoiceRoom::protocol(), ""); - QStringList splitParts = serverUrl.split("/"); - m_hostname = splitParts.at(0); - m_channel = splitParts.at(1); - } + this->setVoiceRoomUrl(voiceRoomUrl); } /* @@ -98,6 +94,65 @@ namespace BlackMisc return BlackMisc::serializeJson(CVoiceRoom::jsonMembers(), TupleConverter::toTuple(*this)); } + /* + * Property by index + */ + QVariant CVoiceRoom::propertyByIndex(const CPropertyIndex &index) const + { + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexAudioPlaying: + return QVariant(this->isAudioPlaying()); + case IndexConnected: + return QVariant(this->isConnected()); + case IndexChannel: + return QVariant(this->getChannel()); + case IndexHostname: + return QVariant(this->getHostname()); + case IndexUrl: + return QVariant(this->getVoiceRoomUrl()); + default: + return CValueObject::propertyByIndex(index); + } + } + + /* + * Property by index + */ + void CVoiceRoom::setPropertyByIndex(const QVariant &variant, const CPropertyIndex &index) + { + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexAudioPlaying: + this->setAudioPlaying(variant.toBool()); + break; + case IndexConnected: + this->setConnected(variant.toBool()); + break; + case IndexChannel: + this->setChannel(variant.value()); + break; + case IndexHostname: + this->setHostName(variant.value()); + break; + case IndexUrl: + this->setVoiceRoomUrl(variant.value()); + break; + default: + CValueObject::setPropertyByIndex(variant, index); + break; + } + } + /* * To JSON */ @@ -114,7 +169,6 @@ namespace BlackMisc return TupleConverter::jsonMembers(); } - /* * To string */ @@ -158,6 +212,27 @@ namespace BlackMisc return url; } + /* + * Voice room URL + */ + void CVoiceRoom::setVoiceRoomUrl(const QString &serverUrl) + { + if (serverUrl.isEmpty()) + { + m_hostname = ""; + m_channel = ""; + } + else if (serverUrl.contains("/")) + { + QString url = serverUrl.trimmed().toLower(); + url.replace(CVoiceRoom::protocolComplete(), ""); + url.replace(CVoiceRoom::protocol(), ""); + QStringList splitParts = serverUrl.split("/"); + m_hostname = splitParts.at(0); + m_channel = splitParts.at(1); + } + } + /* * ATIS voice channel */ diff --git a/src/blackmisc/voiceroom.h b/src/blackmisc/voiceroom.h index dd520aa23..d814780bd 100644 --- a/src/blackmisc/voiceroom.h +++ b/src/blackmisc/voiceroom.h @@ -9,7 +9,7 @@ //! \file -#include "valueobject.h" +#include "propertyindex.h" #include #ifndef BLACKMISC_VOICEROOM_H @@ -26,6 +26,16 @@ namespace BlackMisc { public: + //! Properties by index + enum ColumnIndex + { + IndexHostname = BlackMisc::CPropertyIndex::GlobalIndexCVoiceRoom, + IndexChannel, + IndexUrl, + IndexConnected, + IndexAudioPlaying + }; + //! Default constructor. CVoiceRoom() : m_connected(false), m_audioPlaying(false) {} @@ -34,16 +44,13 @@ namespace BlackMisc m_hostname(hostname), m_channel(channel), m_connected(false), m_audioPlaying(false) {} //! Constructor. - CVoiceRoom(const QString &serverUrl, bool connected = false); + CVoiceRoom(const QString &voiceRoomUrl, bool connected = false); //! \copydoc CValueObject::toQVariant - virtual QVariant toQVariant() const override - { - return QVariant::fromValue(*this); - } + virtual QVariant toQVariant() const override { return QVariant::fromValue(*this); } //! Get the host name - const QString &getHostName() const { return m_hostname; } + const QString &getHostname() const { return m_hostname; } //! Get the voice room channel const QString &getChannel() const { return m_channel; } @@ -61,6 +68,9 @@ namespace BlackMisc */ QString getVoiceRoomUrl(bool noProtocol = true) const; + //! Set voice room URL + void setVoiceRoomUrl(const QString &serverUrl); + //! Valid voice room object? bool isValid() const { return !this->m_hostname.isEmpty() && !this->m_channel.isEmpty(); } @@ -91,6 +101,12 @@ namespace BlackMisc //! \copydoc CValueObject::toJson virtual QJsonObject toJson() const override; + //! \copydoc CValueObject::propertyByIndex + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; + + //! \copydoc CValueObject::setPropertyByIndex + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; + //! \copydoc CValueObject::fromJson void fromJson(const QJsonObject &json) override; diff --git a/src/blacksim/fscommon/aircraftcfgentries.cpp b/src/blacksim/fscommon/aircraftcfgentries.cpp index c1d318d0c..f15f63292 100644 --- a/src/blacksim/fscommon/aircraftcfgentries.cpp +++ b/src/blacksim/fscommon/aircraftcfgentries.cpp @@ -59,29 +59,60 @@ namespace BlackSim /* * Get particular column */ - QVariant CAircraftCfgEntries::propertyByIndex(int index) const + QVariant CAircraftCfgEntries::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexFilePath: - return this->m_filePath; + return QVariant(this->m_filePath); case IndexTitle: - return this->m_title; + return QVariant(this->m_title); case IndexAtcType: - return this->m_atcType; + return QVariant(this->m_atcType); case IndexAtcModel: - return this->m_atcModel; + return QVariant(this->m_atcModel); case IndexParkingCode: - return this->m_atcParkingCode; + return QVariant(this->m_atcParkingCode); case IndexEntryIndex: - return this->m_index; + return QVariant(this->m_index); default: + return CValueObject::propertyByIndex(index); + } + } + + /* + * Set property as index + */ + void CAircraftCfgEntries::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) + { + if (index.isMyself()) { this->fromQVariant(variant); return; } + ColumnIndex i = index.frontCasted(); + switch (i) + { + case IndexAtcModel: + this->setAtcModel(variant.toString()); + break; + case IndexAtcType: + this->setAtcType(variant.toString()); + break; + case IndexEntryIndex: + this->setIndex(variant.toInt()); + break; + case IndexFilePath: + this->setFilePath(variant.toString()); + break; + case IndexParkingCode: + this->setAtcParkingCode(variant.toString()); + break; + case IndexTitle: + this->setTitle(variant.toString()); + break; + default: + CValueObject::setPropertyByIndex(variant, index); break; } - - Q_ASSERT_X(false, "CAircraftCfgEntries", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); } /* diff --git a/src/blacksim/fscommon/aircraftcfgentries.h b/src/blacksim/fscommon/aircraftcfgentries.h index dda08e571..f420f4d8b 100644 --- a/src/blacksim/fscommon/aircraftcfgentries.h +++ b/src/blacksim/fscommon/aircraftcfgentries.h @@ -64,9 +64,6 @@ namespace BlackSim //! operator != bool operator !=(const CAircraftCfgEntries &other) const; - //! \copydoc CValueObject::propertyByIndex - QVariant propertyByIndex(int index) const; - //! Filepath QString getFilePath() const { return this->m_filePath; } @@ -115,6 +112,12 @@ namespace BlackSim //! \copydoc CValueObject::fromJson virtual void fromJson(const QJsonObject &json) override; + //! \copydoc CValueObject::propertyByIndex + virtual QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; + + //! \copydoc CValueObject::setPropertyByIndex + virtual void setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) override; + //! Register the metatypes static void registerMetadata(); diff --git a/src/blacksim/fscommon/aircraftmapping.cpp b/src/blacksim/fscommon/aircraftmapping.cpp index 337cb63b4..402a9a0cc 100644 --- a/src/blacksim/fscommon/aircraftmapping.cpp +++ b/src/blacksim/fscommon/aircraftmapping.cpp @@ -120,95 +120,86 @@ namespace BlackSim /* * Get column */ - QVariant CAircraftMapping::propertyByIndex(int index) const + QVariant CAircraftMapping::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - // non throwing implementation - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexMappingId: - return this->m_mappingId; + return QVariant(this->m_mappingId); case IndexProposalId: - return m_proposalId; + return QVariant(m_proposalId); case IndexAircraftKey: - return m_fsAircraftKey; + return QVariant(m_fsAircraftKey); case IndexAircraftDesignator: - return m_aircraftDesignator; + return QVariant(m_aircraftDesignator); case IndexAirlineDesignator: - return m_airlineDesignator; + return QVariant(m_airlineDesignator); case IndexAircraftCombinedType: - return m_aircraftCombinedType; + return QVariant(m_aircraftCombinedType); case IndexWakeTurbulenceCategory: - return m_wakeTurbulenceCategory; + return QVariant(m_wakeTurbulenceCategory); case IndexAirlineColor: - return this->m_aircraftColor; + return QVariant(this->m_aircraftColor); case IndexLastChanged: - return this->getLastChangedFormatted(); + return QVariant(this->getLastChangedFormatted()); case IndexSimulatorInfo: - return this->m_simulatorInfo.toQVariant(); + return this->m_simulatorInfo.propertyByIndex(index.copyFrontRemoved()); default: - break; + return CValueObject::propertyByIndex(index); } - - Q_ASSERT_X(false, "CAircraftMapping", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); } /* * Set column's value */ - void CAircraftMapping::setPropertyByIndex(const QVariant &value, int index) + void CAircraftMapping::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - // non throwing implementation - bool changed; - - switch (index) + if (index.isMyself()) + { + this->setPropertyByIndex(variant, index); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexMappingId: { bool ok = false; - qint32 id = value.toInt(&ok); + qint32 id = variant.toInt(&ok); this->m_mappingId = ok ? id : CAircraftMapping::InvalidId; } - changed = true; break; case IndexProposalId: { bool ok = false; - qint32 id = value.toInt(&ok); + qint32 id = variant.toInt(&ok); this->m_proposalId = ok ? id : CAircraftMapping::InvalidId; } - changed = true; break; case IndexAircraftKey: - m_fsAircraftKey = value.toString(); - changed = true; + m_fsAircraftKey = variant.toString(); break; case IndexAircraftDesignator: - this->setAircraftDesignator(value.toString()); - changed = true; + this->setAircraftDesignator(variant.toString()); break; case IndexAirlineDesignator: - this->setAirlineDesignator(value.toString()); - changed = true; + this->setAirlineDesignator(variant.toString()); break; case IndexAircraftCombinedType: - this->setAircraftCombinedType(value.toString()); - changed = true; + this->setAircraftCombinedType(variant.toString()); break; case IndexWakeTurbulenceCategory: - this->setWakeTurbulenceCategory(value.toString()); - changed = true; + this->setWakeTurbulenceCategory(variant.toString()); break; case IndexAirlineColor: - this->m_aircraftColor = value.toString(); - changed = true; + this->m_aircraftColor = variant.toString(); break; default: - changed = false; + CValueObject::setPropertyByIndex(variant, index); break; } - if (changed) this->setChanged(changed); } /* diff --git a/src/blacksim/fscommon/aircraftmapping.h b/src/blacksim/fscommon/aircraftmapping.h index 00216789c..623095e3f 100644 --- a/src/blacksim/fscommon/aircraftmapping.h +++ b/src/blacksim/fscommon/aircraftmapping.h @@ -64,7 +64,7 @@ namespace BlackSim //! Columns enum ColumnIndex { - IndexMappingId = 0, + IndexMappingId = BlackMisc::CPropertyIndex::GlobalIndexCAircraftMapping, IndexProposalId, IndexAircraftKey, IndexAircraftDesignator, @@ -184,7 +184,7 @@ namespace BlackSim void setSimulatorText(const QString &simulator); //! \copydoc CValueObject::propertyByIndex - QVariant propertyByIndex(int index) const override; + QVariant propertyByIndex(const BlackMisc::CPropertyIndex &index) const override; //! \copydoc CValueObject::setPropertyByIndex() void setPropertyByIndex(const QVariant &value, const BlackMisc::CPropertyIndex &index) override; diff --git a/tests/blackmisc/testvalueobject.cpp b/tests/blackmisc/testvalueobject.cpp index aa9da289f..b86303fee 100644 --- a/tests/blackmisc/testvalueobject.cpp +++ b/tests/blackmisc/testvalueobject.cpp @@ -95,38 +95,33 @@ namespace BlackMisc /* * Property by index */ - QVariant CTestValueObject::propertyByIndex(int index) const + QVariant CTestValueObject::propertyByIndex(const BlackMisc::CPropertyIndex &index) const { - switch (index) + if (index.isMyself()) { return this->toQVariant(); } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexDescription: return QVariant::fromValue(this->m_description); case IndexName: return QVariant::fromValue(this->m_name); default: - break; + return CValueObject::propertyByIndex(index); } - - Q_ASSERT_X(false, "CTestValueObject", "index unknown"); - QString m = QString("no property, index ").append(QString::number(index)); - return QVariant::fromValue(m); - } - - /* - * Property as string by index - */ - QString CTestValueObject::propertyByIndexAsString(int index, bool i18n) const - { - QVariant qv = this->propertyByIndex(index); - return BlackMisc::qVariantToString(qv, i18n); } /* * Property by index (setter) */ - void CTestValueObject::setPropertyByIndex(const QVariant &variant, int index) + void CTestValueObject::setPropertyByIndex(const QVariant &variant, const BlackMisc::CPropertyIndex &index) { - switch (index) + if (index.isMyself()) + { + this->fromQVariant(variant); + return; + } + ColumnIndex i = index.frontCasted(); + switch (i) { case IndexDescription: this->setDescription(variant.value()); @@ -135,7 +130,7 @@ namespace BlackMisc this->setName(variant.value()); break; default: - Q_ASSERT_X(false, "CTestValueObject", "index unknown"); + CValueObject::setPropertyByIndex(variant, index); break; } } diff --git a/tests/blackmisc/testvalueobject.h b/tests/blackmisc/testvalueobject.h index 669d4609f..843ecc759 100644 --- a/tests/blackmisc/testvalueobject.h +++ b/tests/blackmisc/testvalueobject.h @@ -39,7 +39,6 @@ namespace BlackMisc CTestValueObject(const QString &name, const QString &description) : m_name(name), m_description(description) {} - //! Get name const QString &getName() const { return m_name; }