measurementunit.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_MEASUREMENTUNIT_H
#define SWIFT_MISC_PQ_MEASUREMENTUNIT_H
 
#include <cmath>
#include <cstddef>
#include <string>
 
#include <QCoreApplication>
#include <QDBusArgument>
#include <QHash>
#include <QList>
#include <QSharedData>
#include <QSharedDataPointer>
#include <QString>
#include <Qt>
#include <QtDebug>
#include <QtGlobal>
 
#include "misc/math/mathutils.h"
#include "misc/mixin/mixinhash.h"
#include "misc/mixin/mixinicon.h"
#include "misc/mixin/mixinstring.h"
#include "misc/stringutils.h"
#include "misc/swiftmiscexport.h"
 
namespace swift::misc::physical_quantities
{
    class SWIFT_MISC_EXPORT CMeasurementUnit :
        public mixin::String<CMeasurementUnit>,
        public mixin::Icon<CMeasurementUnit>
    {
    protected:
        using ConverterFunction = double (*)(double);
 
        struct NilConverter
        {
            static double toDefault(double) { return 0.0; } 
            static double fromDefault(double) { return 0.0; } 
        };
 
        struct IdentityConverter
        {
            static double toDefault(double value) { return value; } 
            static double fromDefault(double value) { return value; } 
        };
 
        template <class Policy>
        struct LinearConverter
        {
            static double toDefault(double value)
            {
                return value * Policy::factor();
            } 
            static double fromDefault(double value)
            {
                return value / Policy::factor();
            } 
        };
 
        template <class Policy>
        struct AffineConverter
        {
            static double toDefault(double value)
            {
                return (value - Policy::offset()) * Policy::factor();
            } 
            static double fromDefault(double value)
            {
                return value / Policy::factor() + Policy::offset();
            } 
        };
 
        template <class FactorPolicy, class SubdivPolicy>
        struct SubdivisionConverter
        {
            static double toDefault(double value)
            {
                using swift::misc::math::CMathUtils;
                double part2 = CMathUtils::fract(value) * SubdivPolicy::fraction();
                value = CMathUtils::trunc(value) + part2 / SubdivPolicy::subfactor();
                return value * FactorPolicy::factor();
            }
            static double fromDefault(double value)
            {
                using swift::misc::math::CMathUtils;
                double part1 = CMathUtils::trunc(value / FactorPolicy::factor());
                double remaining = std::fmod(value / FactorPolicy::factor(), 1.0);
                double part2 = remaining * SubdivPolicy::subfactor();
                return part1 + part2 / SubdivPolicy::fraction();
            }
        };
 
        template <class FactorPolicy, class SubdivPolicy>
        struct SubdivisionConverter2
        {
            static double toDefault(double value)
            {
                using swift::misc::math::CMathUtils;
                double part2 = CMathUtils::fract(value) * SubdivPolicy::fraction();
                double part3 = CMathUtils::fract(part2) * SubdivPolicy::fraction();
                value = CMathUtils::trunc(value) +
                        (CMathUtils::trunc(part2) + part3 / SubdivPolicy::subfactor()) / SubdivPolicy::subfactor();
                return value * FactorPolicy::factor();
            }
            static double fromDefault(double value)
            {
                using swift::misc::math::CMathUtils;
                double part1 = CMathUtils::trunc(value / FactorPolicy::factor());
                double remaining = std::fmod(value / FactorPolicy::factor(), 1.0);
                double part2 = CMathUtils::trunc(remaining * SubdivPolicy::subfactor());
                remaining = std::fmod(remaining * SubdivPolicy::subfactor(), 1.0);
                double part3 = remaining * SubdivPolicy::subfactor();
                return part1 + part2 / SubdivPolicy::fraction() +
                       part3 / (SubdivPolicy::fraction() * SubdivPolicy::fraction());
            }
        };
 
        struct One
        {
            static double factor() { return 1; } 
        };
        template <class Policy>
        struct Two
        {
            static double factor() { return Policy::factor() * 2.0; } 
        };
        template <class Policy>
        struct Milli
        {
            static double factor() { return Policy::factor() / 1000.0; } 
        };
        template <class Policy>
        struct Centi
        {
            static double factor() { return Policy::factor() / 100.0; } 
        };
        template <class Policy>
        struct Hecto
        {
            static double factor() { return Policy::factor() * 100.0; } 
        };
        template <class Policy>
        struct Kilo
        {
            static double factor() { return Policy::factor() * 1000.0; } 
        };
        template <class Policy>
        struct Mega
        {
            static double factor() { return Policy::factor() * 1e+6; } 
        };
        template <class Policy>
        struct Giga
        {
            static double factor() { return Policy::factor() * 1e+9; } 
        };
        template <int Subfactor>
        struct InEachHundred
        {
            static double fraction() { return 100.0; } 
            static double subfactor() { return float(Subfactor); } 
        };
 
    protected:
        struct Data
        {
            template <class Converter>
            constexpr Data(QLatin1String name, QLatin1String symbol, Converter, int displayDigits = 2,
                           double epsilon = 1e-9)
                : m_name(name), m_symbol(symbol), m_epsilon(epsilon), m_displayDigits(displayDigits),
                  m_toDefault(Converter::toDefault), m_fromDefault(Converter::fromDefault)
            {}
 
            constexpr Data(QLatin1String name, QLatin1String symbol) : m_name(name), m_symbol(symbol) {}
 
            QLatin1String m_name; 
            QLatin1String m_symbol; 
            double m_epsilon = 0.0; 
            int m_displayDigits = 0; 
            ConverterFunction m_toDefault = nullptr; 
            ConverterFunction m_fromDefault = nullptr; 
        };
 
        template <int N>
        static constexpr QLatin1String constQLatin1(const char (&str)[N])
        {
            return QLatin1String(str, N - 1); // -1 because N includes the null terminator
        }
 
        CMeasurementUnit(const Data &data) : m_data(&data) {}
 
        CMeasurementUnit(const Data &&) = delete;
 
        ~CMeasurementUnit() = default;
 
        CMeasurementUnit(const CMeasurementUnit &) = default;
 
        CMeasurementUnit &operator=(const CMeasurementUnit &) = default;
 
    private:
        const Data *m_data = (static_cast<void>(throw std::logic_error("Uninitialized pimpl")), nullptr);
 
    public:
        QString convertToQString(bool i18n = false) const { return this->getSymbol(i18n); }
 
        void marshallToDbus(QDBusArgument &argument) const { argument << m_data->m_symbol; }
 
        void unmarshallFromDbus(const QDBusArgument &)
        {
            // the concrete implementations will override this default
            // this is required so I can also stream None
            (*this) = CMeasurementUnit::None();
        }
 
        void marshalToDataStream(QDataStream &stream) const { stream << QString(m_data->m_symbol); }
 
        void unmarshalFromDataStream(QDataStream &)
        {
            // the concrete implementations will override this default
            // this is required so that None can be marshalled
            *this = CMeasurementUnit::None();
        }
 
        friend bool operator==(const CMeasurementUnit &a, const CMeasurementUnit &b)
        {
            if (&a == &b) return true;
            return a.m_data->m_name == b.m_data->m_name;
        }
 
        friend bool operator!=(const CMeasurementUnit &a, const CMeasurementUnit &b) { return !(a == b); }
 
        friend size_t qHash(const CMeasurementUnit &unit) { return ::qHash(unit.getName()); }
 
        QString getName(bool i18n = false) const
        {
            return i18n ? QCoreApplication::translate("CMeasurementUnit", m_data->m_name.latin1()) : m_data->m_name;
        }
 
        QString getSymbol(bool i18n = false) const
        {
            return i18n ? QCoreApplication::translate("CMeasurementUnit", m_data->m_symbol.latin1()) : m_data->m_symbol;
        }
 
        bool endsStringWithNameOrSymbol(const QString &candidate, Qt::CaseSensitivity cs = Qt::CaseSensitive) const
        {
            const QString c = candidate.trimmed();
            return c.endsWith(this->getName(false), cs) || c.endsWith(this->getName(true)) ||
                   c.endsWith(this->getSymbol(false), cs) || c.endsWith(this->getSymbol(true));
        }
 
        double roundValue(double value, int digits = -1) const;
 
        double roundToEpsilon(double value) const;
 
        virtual QString makeRoundedQString(double value, int digits = -1, bool withGroupSeparator = false,
                                           bool i18n = false) const;
 
        virtual QString makeRoundedQStringWithUnit(double value, int digits = -1, bool withGroupSeparator = false,
                                                   bool i18n = false) const;
 
        double getEpsilon() const { return m_data->m_epsilon; }
 
        int getDisplayDigits() const { return m_data->m_displayDigits; }
 
        double convertFrom(double value, const CMeasurementUnit &unit) const;
 
        bool isEpsilon(double value) const
        {
            if (this->isNull()) return false;
            if (qFuzzyIsNull(value)) return true;
            return std::abs(value) <= m_data->m_epsilon;
        }
 
        bool isNull() const { return m_data->m_toDefault == nullptr; }
 
        // --------------------------------------------------------------------
        // -- static
        // --------------------------------------------------------------------
 
        template <class U>
        static U unitFromSymbol(const QString &symbol, bool strict = true)
        {
            if (symbol.isEmpty()) { return U::defaultUnit(); }
 
            static const bool cs = hasCaseSensitiveSymbols<U>();
            for (const auto &unit : U::allUnits())
            {
                if (strict && cs)
                {
                    if (unit.getSymbol() == symbol) { return unit; }
                }
                else
                {
                    if (stringCompare(unit.getSymbol(), symbol, Qt::CaseInsensitive)) { return unit; }
                }
            }
            if (strict) qFatal("Illegal unit name");
            return U::defaultUnit();
        }
 
        template <class U>
        static const QStringList &allSymbols()
        {
            static const QStringList symbols = [] {
                QStringList s;
                for (const auto &unit : U::allUnits()) { s.push_back(unit.getSymbol()); }
                return s;
            }();
            return symbols;
        }
 
        template <class U>
        static const QStringList &allSymbolsLowerCase()
        {
            static const QStringList symbols = [] {
                QSet<QString> s;
                for (const QString &symbol : allSymbols<U>()) { s.insert(symbol.toLower()); }
                return s.values();
            }();
            return symbols;
        }
 
        template <class U>
        static bool hasCaseSensitiveSymbols()
        {
            static const bool cs = [] { return (allSymbolsLowerCase<U>().size() != allSymbols<U>().size()); }();
            return cs;
        }
 
        template <class U>
        static bool isValidUnitSymbol(const QString &symbol)
        {
            static const bool cs = hasCaseSensitiveSymbols<U>();
            return cs ? isValidUnitSymbol<U>(symbol, Qt::CaseSensitive) :
                        isValidUnitSymbol<U>(symbol, Qt::CaseInsensitive);
        }
 
        template <class U>
        static bool isValidUnitSymbol(const QString &symbol, Qt::CaseSensitivity caseSensitivity)
        {
            if (symbol.isEmpty()) return false;
            for (const auto &unit : U::allUnits())
            {
                if (stringCompare(unit.getSymbol(), symbol, caseSensitivity)) { return true; }
            }
            return false;
        }
 
        template <class U>
        static bool containsValidUnitSymbol(const QString &candidate,
                                            Qt::CaseSensitivity caseSensitivity = Qt::CaseSensitive)
        {
            if (candidate.isEmpty()) return false;
            for (const auto &unit : U::allUnits())
            {
                if (candidate.contains(unit.getSymbol(), caseSensitivity)) { return true; }
            }
            return false;
        }
 
        template <class U>
        static bool endWithValidUnitSymbol(const QString &candidate,
                                           Qt::CaseSensitivity caseSensitivity = Qt::CaseSensitive)
        {
            if (candidate.isEmpty()) return false;
            for (const auto &unit : U::allUnits())
            {
                if (candidate.endsWith(unit.getSymbol(), caseSensitivity)) { return true; }
            }
            return false;
        }
 
        static CMeasurementUnit None()
        {
            static constexpr CMeasurementUnit::Data none(constQLatin1("none"), constQLatin1(""), NilConverter(), 0, 0);
            return none;
        }
    };
} // namespace swift::misc::physical_quantities
 
#endif // SWIFT_MISC_PQ_MEASUREMENTUNIT_H