physicalquantity.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2013 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_MISC_PQ_PHYSICALQUANTITY_H
#define SWIFT_MISC_PQ_PHYSICALQUANTITY_H
 
#include <QDBusArgument>
#include <QJsonObject>
#include <QString>
#include <QtGlobal>
 
#include "misc/mixin/mixindatastream.h"
#include "misc/mixin/mixindbus.h"
#include "misc/mixin/mixinicon.h"
#include "misc/mixin/mixinindex.h"
#include "misc/mixin/mixinjson.h"
#include "misc/mixin/mixinmetatype.h"
#include "misc/mixin/mixinstring.h"
#include "misc/pq/pqstring.h"
#include "misc/pq/units.h"
#include "misc/propertyindexref.h"
#include "misc/swiftmiscexport.h"
 
namespace swift::misc::physical_quantities
{
    template <class MU, class PQ>
    class CPhysicalQuantity;
}
 
#define SWIFT_TEMPLATE_PQ_MIXINS(MU, PQ, Extern, Export)                                                               \
    namespace swift::misc::physical_quantities                                                                         \
    {                                                                                                                  \
        class PQ;                                                                                                      \
    }                                                                                                                  \
    namespace swift::misc::private_ns                                                                                  \
    {                                                                                                                  \
        Extern template struct Export CValueObjectMetaInfo<physical_quantities::PQ>;                                   \
        Extern template struct Export MetaTypeHelper<physical_quantities::PQ>;                                         \
    }                                                                                                                  \
    namespace swift::misc::mixin                                                                                       \
    {                                                                                                                  \
        Extern template class Export                                                                                   \
            DBusOperators<physical_quantities::CPhysicalQuantity<physical_quantities::MU, physical_quantities::PQ>>;   \
        Extern template class Export DataStreamOperators<                                                              \
            physical_quantities::CPhysicalQuantity<physical_quantities::MU, physical_quantities::PQ>>;                 \
        Extern template class Export                                                                                   \
            JsonOperators<physical_quantities::CPhysicalQuantity<physical_quantities::MU, physical_quantities::PQ>>;   \
        Extern template class Export Index<physical_quantities::PQ>;                                                   \
        Extern template class Export MetaType<physical_quantities::PQ>;                                                \
        Extern template class Export String<physical_quantities::PQ>;                                                  \
        Extern template class Export                                                                                   \
            Icon<physical_quantities::CPhysicalQuantity<physical_quantities::MU, physical_quantities::PQ>>;            \
    }
 
#if defined(Q_OS_WIN) && defined(Q_CC_GNU)
#    define SWIFT_DECLARE_PQ_MIXINS(MU, PQ)
#    define SWIFT_DEFINE_PQ_MIXINS(MU, PQ)
#elif defined(Q_OS_WIN) && defined(Q_CC_CLANG)
#    define SWIFT_DECLARE_PQ_MIXINS(MU, PQ) SWIFT_TEMPLATE_PQ_MIXINS(MU, PQ, extern, )
#    define SWIFT_DEFINE_PQ_MIXINS(MU, PQ) SWIFT_TEMPLATE_PQ_MIXINS(MU, PQ, , SWIFT_MISC_EXPORT)
#else
#    define SWIFT_DECLARE_PQ_MIXINS(MU, PQ) SWIFT_TEMPLATE_PQ_MIXINS(MU, PQ, extern, )
#    define SWIFT_DEFINE_PQ_MIXINS(MU, PQ) SWIFT_TEMPLATE_PQ_MIXINS(MU, PQ, , )
#endif
 
SWIFT_DECLARE_PQ_MIXINS(CAngleUnit, CAngle)
SWIFT_DECLARE_PQ_MIXINS(CLengthUnit, CLength)
SWIFT_DECLARE_PQ_MIXINS(CPressureUnit, CPressure)
SWIFT_DECLARE_PQ_MIXINS(CFrequencyUnit, CFrequency)
SWIFT_DECLARE_PQ_MIXINS(CMassUnit, CMass)
SWIFT_DECLARE_PQ_MIXINS(CTemperatureUnit, CTemperature)
SWIFT_DECLARE_PQ_MIXINS(CSpeedUnit, CSpeed)
SWIFT_DECLARE_PQ_MIXINS(CTimeUnit, CTime)
SWIFT_DECLARE_PQ_MIXINS(CAccelerationUnit, CAcceleration)
 
namespace swift::misc::physical_quantities
{
    class CAngle;
    class CLength;
    class CPressure;
    class CFrequency;
    class CMass;
    class CTemperature;
    class CSpeed;
    class CTime;
    class CAcceleration;
 
    template <class MU, class PQ>
    class CPhysicalQuantity :
        public mixin::DBusOperators<CPhysicalQuantity<MU, PQ>>,
        public mixin::DataStreamOperators<CPhysicalQuantity<MU, PQ>>,
        public mixin::JsonOperators<CPhysicalQuantity<MU, PQ>>,
        public mixin::Index<PQ>,
        public mixin::MetaType<PQ>,
        public mixin::String<PQ>,
        public mixin::Icon<CPhysicalQuantity<MU, PQ>>
    {
        friend int compare(const PQ &a, const PQ &b) { return compareImpl(a, b); }
 
    public:
        enum ColumnIndex
        {
            IndexUnit = CPropertyIndexRef::GlobalIndexCPhysicalQuantity,
            IndexValue,
            IndexValueRounded0DigitsWithUnit,
            IndexValueRounded1DigitsWithUnit,
            IndexValueRounded2DigitsWithUnit,
            IndexValueRounded3DigitsWithUnit,
            IndexValueRounded6DigitsWithUnit
        };
 
        const MU &getUnit() const;
 
        void setUnit(const MU &unit);
 
        void setUnitBySymbol(const QString &unitName);
 
        QString getUnitSymbol() const;
 
        PQ &switchUnit(const MU &newUnit);
 
        PQ switchedUnit(const MU &newUnit) const;
 
        bool isNull() const;
 
        void setNull();
 
        double value(MU unit) const;
 
        double value() const;
 
        void setCurrentUnitValue(double value);
 
        int valueInteger(MU unit) const;
 
        QString valueIntegerAsString(MU unit) const { return QString::number(this->valueInteger(unit)); }
 
        int valueInteger() const;
 
        QString valueIntegerAsString() const { return QString::number(this->valueInteger()); }
 
        bool isInteger() const;
 
        double valueRounded(MU unit, int digits = -1) const;
 
        double valueRounded(int digits = -1) const;
 
        QString valueRoundedAsString(MU unit, int digits = -1) const;
 
        QString valueRoundedWithUnit(const MU &unit, int digits = -1, bool withGroupSeparator = false,
                                     bool i18n = false) const;
 
        QString valueRoundedWithUnit(int digits = -1, bool withGroupSeparator = false, bool i18n = false) const;
 
        void roundToEpsilon();
 
        void setValueSameUnit(double value);
 
        void addValueSameUnit(double value);
 
        void substractValueSameUnit(double value);
 
        CPhysicalQuantity &operator*=(double multiply);
 
        CPhysicalQuantity &operator/=(double divide);
 
        PQ operator*(double multiply) const;
 
        friend PQ operator*(double factor, const PQ &other) { return other * factor; }
 
        PQ operator/(double divide) const;
 
        PQ operator-() const;
 
        friend bool operator==(const CPhysicalQuantity &a, const CPhysicalQuantity &b) { return a.equals(b); }
 
        friend bool operator!=(const CPhysicalQuantity &a, const CPhysicalQuantity &b) { return !a.equals(b); }
 
        CPhysicalQuantity &operator+=(const CPhysicalQuantity &other);
 
        CPhysicalQuantity &operator-=(const CPhysicalQuantity &other);
 
        friend bool operator>(const CPhysicalQuantity &a, const CPhysicalQuantity &b) { return b.lessThan(a); }
 
        friend bool operator<(const CPhysicalQuantity &a, const CPhysicalQuantity &b) { return a.lessThan(b); }
 
        friend bool operator<=(const CPhysicalQuantity &a, const CPhysicalQuantity &b) { return !b.lessThan(a); }
 
        friend bool operator>=(const CPhysicalQuantity &a, const CPhysicalQuantity &b) { return !a.lessThan(b); }
 
        friend PQ operator+(const PQ &a, const PQ &b)
        {
            PQ copy(a);
            copy += b;
            return copy;
        }
 
        friend PQ operator-(const PQ &a, const PQ &b)
        {
            PQ copy(a);
            copy -= b;
            return copy;
        }
 
        bool isZeroEpsilonConsidered() const;
 
        bool isPositiveWithEpsilonConsidered() const;
 
        bool isNegativeWithEpsilonConsidered() const;
 
        const PQ &makePositive();
 
        const PQ &makeNegative();
 
        PQ abs() const;
 
        void marshallToDbus(QDBusArgument &argument) const;
 
        void unmarshallFromDbus(const QDBusArgument &argument);
 
        void marshallToDbus(QDBusArgument &argument, LosslessTag) const;
 
        void unmarshallFromDbus(const QDBusArgument &argument, LosslessTag);
 
        void marshalToDataStream(QDataStream &stream) const;
 
        void unmarshalFromDataStream(QDataStream &stream);
 
        size_t getValueHash() const;
 
        friend size_t qHash(const PQ &pq) { return pq.getValueHash(); } // clazy:exclude=qhash-namespace
 
        QJsonObject toJson() const;
 
        void convertFromJson(const QJsonObject &json);
 
        QVariant propertyByIndex(CPropertyIndexRef index) const;
 
        void setPropertyByIndex(CPropertyIndexRef index, const QVariant &variant);
 
        int comparePropertyByIndex(CPropertyIndexRef index, const PQ &pq) const;
 
        QString convertToQString(bool i18n = false) const;
 
        void parseFromString(const QString &value);
 
        void parseFromString(const QString &value, CPqString::SeparatorMode mode);
 
        void parseFromString(const QString &value, CPqString::SeparatorMode mode, const MU &defaultUnitIfMissing);
 
        int compare(const PQ &other) const { return compareImpl(*this->derived(), other); }
 
        static const PQ &maxValue(const PQ &pq1, const PQ &pq2);
 
        static const PQ &minValue(const PQ &pq1, const PQ &pq2);
 
        static int compare(const PQ &a, const PQ &b) { return compareImpl(a, b); }
 
        static const PQ &null();
 
        static PQ parsedFromString(const QString &value, CPqString::SeparatorMode mode = CPqString::SeparatorBestGuess);
 
        static PQ parsedFromString(const QString &value, CPqString::SeparatorMode mode, const MU &defaultUnitIfMissing);
 
    protected:
        CPhysicalQuantity(double value, MU unit);
 
        CPhysicalQuantity(const QString &unitString);
 
    private:
        double m_value; 
        MU m_unit; 
 
        using UnitClass = MU;
 
        static int compareImpl(const PQ &, const PQ &);
 
        bool equals(const CPhysicalQuantity &other) const;
 
        bool lessThan(const CPhysicalQuantity &other) const;
 
        PQ const *derived() const;
 
        PQ *derived();
    };
 
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CLengthUnit, CLength>;
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CPressureUnit, CPressure>;
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CFrequencyUnit, CFrequency>;
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CMassUnit, CMass>;
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CTemperatureUnit, CTemperature>;
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CSpeedUnit, CSpeed>;
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CAngleUnit, CAngle>;
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CTimeUnit, CTime>;
    extern template class SWIFT_MISC_EXPORT_DECLARE_TEMPLATE CPhysicalQuantity<CAccelerationUnit, CAcceleration>;
} // namespace swift::misc::physical_quantities
 
#endif // SWIFT_MISC_PQ_PHYSICALQUANTITY_H