mirror of
https://github.com/swift-project/pilotclient.git
synced 2026-03-30 20:15:35 +08:00
ef21ec67f3
* separator can cause issue when sending data (WebService, FSD) * re-parsing (print and parse again) can cause to undesired results as the separator is mistaken as decimal separator with a different locale * separator now a parameter so it can still be used
1011 lines
40 KiB
C++
1011 lines
40 KiB
C++
/* Copyright (C) 2013
|
|
* swift project Community / Contributors
|
|
*
|
|
* This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
|
|
* directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
|
|
* including this file, may be copied, modified, propagated, or distributed except according to the terms
|
|
* contained in the LICENSE file.
|
|
*/
|
|
|
|
//! \file
|
|
|
|
#ifndef BLACKMISC_PQ_UNITS_H
|
|
#define BLACKMISC_PQ_UNITS_H
|
|
|
|
#pragma push_macro("min")
|
|
#undef min
|
|
|
|
#include "blackmisc/blackmiscexport.h"
|
|
#include "blackmisc/dbus.h"
|
|
#include "blackmisc/pq/measurementunit.h"
|
|
#include "blackmisc/propertyindexvariantmap.h"
|
|
#include "blackmisc/variant.h"
|
|
|
|
#include <math.h>
|
|
#include <QDBusArgument>
|
|
#include <QList>
|
|
#include <QMetaType>
|
|
#include <QString>
|
|
#include <QtGlobal>
|
|
#include <QtMath>
|
|
#include <cstddef>
|
|
|
|
//
|
|
// Used with the template for quantities. This is the reason for
|
|
// having all units in one file, since template requires concrete instantiations
|
|
//
|
|
// I18N: http://qt-project.org/doc/qt-4.8/linguist-programmers.html#translating-text-that-is-outside-of-a-qobject-subclass
|
|
//
|
|
namespace BlackMisc
|
|
{
|
|
namespace PhysicalQuantities
|
|
{
|
|
//! Specialized class for distance units (meter, foot, nautical miles).
|
|
class BLACKMISC_EXPORT CLengthUnit final :
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CLengthUnit>,
|
|
public Mixin::DBusOperators<CLengthUnit>,
|
|
public Mixin::Index<CLengthUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
struct NauticalMilesToMeters { static double factor() { return 1852.0; } };
|
|
struct FeetToMeters { static double factor() { return 0.3048; } };
|
|
struct MilesToMeters { static double factor() { return 1609.344; } };
|
|
struct StatuteMilesToMeters { static double factor() { return 1609.3472; } };
|
|
using MetersToMeters = One;
|
|
|
|
virtual void anchor();
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CLengthUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CLengthUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CLengthUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static CLengthUnit defaultUnit() { return m(); }
|
|
|
|
//! Null unit
|
|
static const CLengthUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CLengthUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! Meter m
|
|
static const CLengthUnit &m()
|
|
{
|
|
static const CMeasurementUnit::Data m_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "meter")), constQLatin1("m"), IdentityConverter());
|
|
static const CLengthUnit m(m_);
|
|
return m;
|
|
}
|
|
|
|
//! Nautical miles NM
|
|
static const CLengthUnit &NM()
|
|
{
|
|
static const CMeasurementUnit::Data NM_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "nautical mile")), constQLatin1("NM"), LinearConverter<NauticalMilesToMeters>(), 3);
|
|
static const CLengthUnit NM(NM_);
|
|
return NM;
|
|
}
|
|
|
|
//! Foot ft
|
|
static const CLengthUnit &ft()
|
|
{
|
|
static const CMeasurementUnit::Data ft_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "foot")), constQLatin1("ft"), LinearConverter<FeetToMeters>(), 1);
|
|
static const CLengthUnit ft(ft_);
|
|
return ft;
|
|
}
|
|
|
|
//! Kilometer km
|
|
static const CLengthUnit &km()
|
|
{
|
|
static const CMeasurementUnit::Data km_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "kilometer")), constQLatin1("km"), LinearConverter<Kilo<MetersToMeters> >(), 3);
|
|
static const CLengthUnit km(km_);
|
|
return km;
|
|
}
|
|
|
|
//! Centimeter cm
|
|
static const CLengthUnit &cm()
|
|
{
|
|
static const CMeasurementUnit::Data cm_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "centimeter")), constQLatin1("cm"), LinearConverter<Centi<MetersToMeters> >(), 1);
|
|
static const CLengthUnit cm(cm_);
|
|
return cm;
|
|
}
|
|
|
|
//! International mile
|
|
static const CLengthUnit &mi()
|
|
{
|
|
static const CMeasurementUnit::Data mi_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "mile")), constQLatin1("mi"), LinearConverter<MilesToMeters>(), 3);
|
|
static const CLengthUnit mi(mi_);
|
|
return mi;
|
|
}
|
|
|
|
//! Statute mile
|
|
static const CLengthUnit &SM()
|
|
{
|
|
static const CMeasurementUnit::Data sm_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "statute mile")), constQLatin1("SM"), LinearConverter<StatuteMilesToMeters>(), 3);
|
|
static const CLengthUnit sm(sm_);
|
|
return sm;
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CLengthUnit> &allUnits()
|
|
{
|
|
static const QList<CLengthUnit> u
|
|
{
|
|
CLengthUnit::nullUnit(),
|
|
CLengthUnit::cm(),
|
|
CLengthUnit::ft(),
|
|
CLengthUnit::km(),
|
|
CLengthUnit::m(),
|
|
CLengthUnit::mi(),
|
|
CLengthUnit::SM(),
|
|
CLengthUnit::NM()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CLengthUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
//! Specialized class for angles (degrees, radian).
|
|
class BLACKMISC_EXPORT CAngleUnit final :
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CAngleUnit>,
|
|
public Mixin::DBusOperators<CAngleUnit>,
|
|
public Mixin::Index<CAngleUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
struct RadiansToDegrees { static double factor() { return 180.0 / M_PI; } };
|
|
using DegreesToDegrees = One;
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CAngleUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CAngleUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CAngleUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static const CAngleUnit &defaultUnit() { return deg(); }
|
|
|
|
//! Null unit
|
|
static const CAngleUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CAngleUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! \copydoc CMeasurementUnit::makeRoundedQStringWithUnit
|
|
virtual QString makeRoundedQStringWithUnit(double value, int digits = -1, bool withGroupSeparator = false, bool i18n = false) const override;
|
|
|
|
//! Radians
|
|
static const CAngleUnit &rad()
|
|
{
|
|
static constexpr CMeasurementUnit::Data rad_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "radian")), constQLatin1("rad"), LinearConverter<RadiansToDegrees>());
|
|
static const CAngleUnit rad(rad_);
|
|
return rad;
|
|
}
|
|
|
|
//! Degrees
|
|
static const CAngleUnit °()
|
|
{
|
|
static const CMeasurementUnit::Data deg_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "degree")), constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "deg")), IdentityConverter());
|
|
static const CAngleUnit deg(deg_);
|
|
return deg;
|
|
}
|
|
|
|
//! Sexagesimal degree (degrees, minutes, seconds, decimal seconds)
|
|
static const CAngleUnit &sexagesimalDeg()
|
|
{
|
|
static const CMeasurementUnit::Data deg_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "degree, minute, second")), constQLatin1("DMS"), SubdivisionConverter2<DegreesToDegrees, InEachHundred<60> >(), 4);
|
|
static const CAngleUnit deg(deg_);
|
|
return deg;
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "%L1 %L2 %L3");
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "-%L1 %L2 %L3");
|
|
}
|
|
|
|
//! Sexagesimal degree (degrees, minutes, decimal minutes)
|
|
static const CAngleUnit &sexagesimalDegMin()
|
|
{
|
|
static const CMeasurementUnit::Data deg_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "degree, minute")), constQLatin1("MinDec"), SubdivisionConverter<DegreesToDegrees, InEachHundred<60> >(), 4);
|
|
static const CAngleUnit deg(deg_);
|
|
return deg;
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "%L1 %L2");
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "-%L1 %L2");
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CAngleUnit> &allUnits()
|
|
{
|
|
static const QList<CAngleUnit> u
|
|
{
|
|
CAngleUnit::nullUnit(),
|
|
CAngleUnit::deg(),
|
|
CAngleUnit::rad(),
|
|
CAngleUnit::sexagesimalDeg(),
|
|
CAngleUnit::sexagesimalDegMin()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CAngleUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
//! Specialized class for frequency (hertz, mega hertz, kilo hertz).
|
|
class BLACKMISC_EXPORT CFrequencyUnit final :
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CFrequencyUnit>,
|
|
public Mixin::DBusOperators<CFrequencyUnit>,
|
|
public Mixin::Index<CFrequencyUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
using HertzToHertz = One;
|
|
|
|
virtual void anchor();
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CFrequencyUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CFrequencyUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CFrequencyUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static const CFrequencyUnit &defaultUnit() { return Hz(); }
|
|
|
|
//! Null unit
|
|
static const CFrequencyUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CFrequencyUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! Hertz
|
|
static const CFrequencyUnit &Hz()
|
|
{
|
|
static const CMeasurementUnit::Data Hz_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "hertz")), constQLatin1("Hz"), IdentityConverter());
|
|
static const CFrequencyUnit Hz(Hz_);
|
|
return Hz;
|
|
}
|
|
|
|
//! Kilohertz
|
|
static const CFrequencyUnit &kHz()
|
|
{
|
|
static const CMeasurementUnit::Data kHz_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "kilohertz")), constQLatin1("kHz"), LinearConverter<Kilo<HertzToHertz> >(), 1);
|
|
static const CFrequencyUnit kHz(kHz_);
|
|
return kHz;
|
|
}
|
|
|
|
//! Megahertz
|
|
static const CFrequencyUnit &MHz()
|
|
{
|
|
static const CMeasurementUnit::Data MHz_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "megahertz")), constQLatin1("MHz"), LinearConverter<Mega<HertzToHertz> >(), 2);
|
|
static const CFrequencyUnit MHz(MHz_);
|
|
return MHz;
|
|
}
|
|
|
|
//! Gigahertz
|
|
static const CFrequencyUnit &GHz()
|
|
{
|
|
static const CMeasurementUnit::Data GHz_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "gigahertz")), constQLatin1("GHz"), LinearConverter<Giga<HertzToHertz> >(), 2);
|
|
static const CFrequencyUnit GHz(GHz_);
|
|
return GHz;
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CFrequencyUnit> &allUnits()
|
|
{
|
|
static const QList<CFrequencyUnit> u
|
|
{
|
|
CFrequencyUnit::nullUnit(),
|
|
CFrequencyUnit::GHz(),
|
|
CFrequencyUnit::Hz(),
|
|
CFrequencyUnit::kHz(),
|
|
CFrequencyUnit::MHz()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CFrequencyUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
//! Specialized class for mass units (kg, lbs).
|
|
class BLACKMISC_EXPORT CMassUnit final :
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CMassUnit>,
|
|
public Mixin::DBusOperators<CMassUnit>,
|
|
public Mixin::Index<CMassUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
using GramsToKilograms = Milli<One>;
|
|
struct PoundsToKilograms { static double factor() { return 0.45359237; } };
|
|
|
|
virtual void anchor();
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CMassUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CMassUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CMassUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static const CMassUnit &defaultUnit() { return kg(); }
|
|
|
|
//! Null unit
|
|
static const CMassUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CMassUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! Kilogram, SI base unit
|
|
static const CMassUnit &kg()
|
|
{
|
|
static const CMeasurementUnit::Data kg_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "kilogram")), constQLatin1("kg"), IdentityConverter(), 1);
|
|
static const CMassUnit kg(kg_);
|
|
return kg;
|
|
}
|
|
|
|
//! Gram, SI unit
|
|
static const CMassUnit &g()
|
|
{
|
|
static const CMeasurementUnit::Data g_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "gram")), constQLatin1("g"), LinearConverter<GramsToKilograms>(), 0);
|
|
static const CMassUnit g(g_);
|
|
return g;
|
|
}
|
|
|
|
//! Tonne, aka metric ton (1000kg)
|
|
static const CMassUnit &tonne()
|
|
{
|
|
static const CMeasurementUnit::Data t_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "tonne")), constQLatin1("t"), LinearConverter<Mega<GramsToKilograms> >(), 3);
|
|
static const CMassUnit t(t_);
|
|
return t;
|
|
}
|
|
|
|
//! Short ton (2000lb) used in the United States
|
|
static const CMassUnit &shortTon()
|
|
{
|
|
static const CMeasurementUnit::Data ton_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "short ton")), constQLatin1("ton"), LinearConverter<Two<Kilo<PoundsToKilograms> > >(), 3);
|
|
static const CMassUnit ton(ton_);
|
|
return ton;
|
|
}
|
|
|
|
//! Pound, aka mass pound
|
|
static const CMassUnit &lb()
|
|
{
|
|
static const CMeasurementUnit::Data lbs_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "pound")), constQLatin1("lb"), LinearConverter<PoundsToKilograms>(), 1);
|
|
static const CMassUnit lbs(lbs_);
|
|
return lbs;
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CMassUnit> &allUnits()
|
|
{
|
|
static const QList<CMassUnit> u
|
|
{
|
|
CMassUnit::nullUnit(),
|
|
CMassUnit::g(),
|
|
CMassUnit::kg(),
|
|
CMassUnit::lb(),
|
|
CMassUnit::tonne(),
|
|
CMassUnit::shortTon()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CMassUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
//! Specialized class for pressure (psi, hPa, bar).
|
|
class BLACKMISC_EXPORT CPressureUnit final :
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CPressureUnit>,
|
|
public Mixin::DBusOperators<CPressureUnit>,
|
|
public Mixin::Index<CPressureUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
using PascalsToHectopascals = Centi<One>;
|
|
struct PsiToHectopascals { static double factor() { return 68.948; } };
|
|
struct InchesToHectopascals { static double factor() { return 33.86389; } };
|
|
struct MillimetersToHectopascals { static double factor() { return 860.142806; } };
|
|
|
|
virtual void anchor();
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CPressureUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CPressureUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CPressureUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static const CPressureUnit &defaultUnit() { return hPa(); }
|
|
|
|
//! Null unit
|
|
static const CPressureUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CPressureUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! Pascal
|
|
static const CPressureUnit &Pa()
|
|
{
|
|
static const CMeasurementUnit::Data Pa_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "pascal")), constQLatin1("Pa"), LinearConverter<PascalsToHectopascals>());
|
|
static const CPressureUnit Pa(Pa_);
|
|
return Pa;
|
|
}
|
|
|
|
//! Hectopascal
|
|
static const CPressureUnit &hPa()
|
|
{
|
|
static const CMeasurementUnit::Data hPa_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "hectopascal")), constQLatin1("hPa"), IdentityConverter());
|
|
static const CPressureUnit hPa(hPa_);
|
|
return hPa;
|
|
}
|
|
|
|
//! Pounds per square inch
|
|
static const CPressureUnit &psi()
|
|
{
|
|
static const CMeasurementUnit::Data psi_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "pound per square inch")), constQLatin1("psi"), LinearConverter<PsiToHectopascals>(), 2);
|
|
static const CPressureUnit psi(psi_);
|
|
return psi;
|
|
}
|
|
|
|
//! Bar
|
|
static const CPressureUnit &bar()
|
|
{
|
|
static const CMeasurementUnit::Data bar_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "bar")), constQLatin1("bar"), LinearConverter<Kilo<One> >(), 1);
|
|
static const CPressureUnit bar(bar_);
|
|
return bar;
|
|
}
|
|
|
|
//! Millibar, actually the same as hPa
|
|
static const CPressureUnit &mbar()
|
|
{
|
|
static const CMeasurementUnit::Data mbar_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "millibar")), constQLatin1("mbar"), IdentityConverter(), 1);
|
|
static const CPressureUnit mbar(mbar_);
|
|
return mbar;
|
|
}
|
|
|
|
//! Inch of mercury at 0°C
|
|
static const CPressureUnit &inHg()
|
|
{
|
|
static const CMeasurementUnit::Data inHg_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "inch of mercury")), constQLatin1("inHg"), LinearConverter<InchesToHectopascals>());
|
|
static const CPressureUnit inHg(inHg_);
|
|
return inHg;
|
|
}
|
|
|
|
//! Millimeter of mercury
|
|
static const CPressureUnit &mmHg()
|
|
{
|
|
static const CMeasurementUnit::Data mmhg_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "millimeter of mercury")), constQLatin1("mmHg"), LinearConverter<MillimetersToHectopascals>());
|
|
static const CPressureUnit mmhg(mmhg_);
|
|
return mmhg;
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CPressureUnit> &allUnits()
|
|
{
|
|
static const QList<CPressureUnit> u
|
|
{
|
|
CPressureUnit::nullUnit(),
|
|
CPressureUnit::bar(),
|
|
CPressureUnit::hPa(),
|
|
CPressureUnit::inHg(),
|
|
CPressureUnit::mmHg(),
|
|
CPressureUnit::mbar(),
|
|
CPressureUnit::psi()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CPressureUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
//! Specialized class for temperatur units (kelvin, centidegree).
|
|
class BLACKMISC_EXPORT CTemperatureUnit final :
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CTemperatureUnit>,
|
|
public Mixin::DBusOperators<CTemperatureUnit>,
|
|
public Mixin::Index<CTemperatureUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
struct KelvinToCentigrade
|
|
{
|
|
static double factor() { return 1.0; }
|
|
static double offset() { return 273.15; }
|
|
};
|
|
struct FahrenheitToCentigrade
|
|
{
|
|
static double factor() { return 5.0 / 9.0; }
|
|
static double offset() { return 32.0; }
|
|
};
|
|
|
|
virtual void anchor();
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CTemperatureUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CTemperatureUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CTemperatureUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static const CTemperatureUnit &defaultUnit() { return C(); }
|
|
|
|
//! Null unit
|
|
static const CTemperatureUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CTemperatureUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! Kelvin
|
|
static const CTemperatureUnit &K()
|
|
{
|
|
static const CMeasurementUnit::Data K_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "Kelvin")), constQLatin1("K"), AffineConverter<KelvinToCentigrade>());
|
|
static const CTemperatureUnit K(K_);
|
|
return K;
|
|
}
|
|
|
|
//! Centigrade C
|
|
static const CTemperatureUnit &C()
|
|
{
|
|
static const CMeasurementUnit::Data C_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "centigrade")), constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "C")), IdentityConverter());
|
|
static const CTemperatureUnit C(C_);
|
|
return C;
|
|
}
|
|
|
|
//! Fahrenheit F
|
|
static const CTemperatureUnit &F()
|
|
{
|
|
static const CMeasurementUnit::Data F_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "Fahrenheit")), constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "F")), AffineConverter<FahrenheitToCentigrade>());
|
|
static const CTemperatureUnit F(F_);
|
|
return F;
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CTemperatureUnit> &allUnits()
|
|
{
|
|
static const QList<CTemperatureUnit> u
|
|
{
|
|
CTemperatureUnit::nullUnit(),
|
|
CTemperatureUnit::C(),
|
|
CTemperatureUnit::F(),
|
|
CTemperatureUnit::K()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CTemperatureUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
//! Specialized class for speed units (m/s, ft/s, NM/h).
|
|
class BLACKMISC_EXPORT CSpeedUnit final:
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CSpeedUnit>,
|
|
public Mixin::DBusOperators<CSpeedUnit>,
|
|
public Mixin::Index<CSpeedUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
struct KnotsToMps { static double factor() { return 1852.0 / 3600.0; } };
|
|
struct KphToMps { static double factor() { return 1.0 / 3.6; } };
|
|
struct FtPerSecToMps { static double factor() { return 0.3048 ; } };
|
|
struct FtPerMinToMps { static double factor() { return 0.3048 / 60.0; } };
|
|
|
|
virtual void anchor();
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CSpeedUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CSpeedUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CSpeedUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static const CSpeedUnit &defaultUnit() { return m_s(); }
|
|
|
|
//! Null unit
|
|
static const CSpeedUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CSpeedUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! Meter/second m/s
|
|
static const CSpeedUnit &m_s()
|
|
{
|
|
static const CMeasurementUnit::Data ms_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "meter per second")), constQLatin1("m/s"), IdentityConverter());
|
|
static const CSpeedUnit ms(ms_);
|
|
return ms;
|
|
}
|
|
|
|
//! Knots
|
|
static const CSpeedUnit &kts()
|
|
{
|
|
static const CMeasurementUnit::Data kts_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "knot")), constQLatin1("kts"), LinearConverter<KnotsToMps>(), 1);
|
|
static const CSpeedUnit kts(kts_);
|
|
return kts;
|
|
}
|
|
|
|
//! Nautical miles per hour NM/h (same as kts)
|
|
static const CSpeedUnit &NM_h()
|
|
{
|
|
static const CMeasurementUnit::Data NMh_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "nautical mile per hour")), constQLatin1("NM/h"), LinearConverter<KnotsToMps>(), 1);
|
|
static const CSpeedUnit NMh(NMh_);
|
|
return NMh;
|
|
}
|
|
|
|
//! Feet/second ft/s
|
|
static const CSpeedUnit &ft_s()
|
|
{
|
|
static const CMeasurementUnit::Data fts_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "foot per second")), constQLatin1("ft/s"), LinearConverter<FtPerSecToMps>(), 0);
|
|
static const CSpeedUnit fts(fts_);
|
|
return fts;
|
|
}
|
|
|
|
//! Feet/min ft/min
|
|
static const CSpeedUnit &ft_min()
|
|
{
|
|
static const CMeasurementUnit::Data ftmin_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "foot per minute")), constQLatin1("ft/min"), LinearConverter<FtPerMinToMps>(), 0);
|
|
static const CSpeedUnit ftmin(ftmin_);
|
|
return ftmin;
|
|
}
|
|
|
|
//! Kilometer/hour km/h
|
|
static const CSpeedUnit &km_h()
|
|
{
|
|
static const CMeasurementUnit::Data kmh_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "kilometer per hour")), constQLatin1("km/h"), LinearConverter<KphToMps>(), 1);
|
|
static const CSpeedUnit kmh(kmh_);
|
|
return kmh;
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CSpeedUnit> &allUnits()
|
|
{
|
|
static const QList<CSpeedUnit> u
|
|
{
|
|
CSpeedUnit::nullUnit(),
|
|
CSpeedUnit::ft_min(),
|
|
CSpeedUnit::ft_s(),
|
|
CSpeedUnit::km_h(),
|
|
CSpeedUnit::kts(),
|
|
CSpeedUnit::m_s(),
|
|
CSpeedUnit::NM_h()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CSpeedUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
//! Specialized class for time units (ms, hour, min).
|
|
class BLACKMISC_EXPORT CTimeUnit final:
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CTimeUnit>,
|
|
public Mixin::DBusOperators<CTimeUnit>,
|
|
public Mixin::Index<CTimeUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
using SecondsToSeconds = One;
|
|
struct DaysToSeconds { static double factor() { return 60.0 * 60.0 * 24.0; } };
|
|
struct HoursToSeconds { static double factor() { return 60.0 * 60.0; } };
|
|
struct MinutesToSeconds { static double factor() { return 60.0; } };
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CTimeUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CTimeUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CTimeUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static const CTimeUnit &defaultUnit() { return s(); }
|
|
|
|
//! Null unit
|
|
static const CTimeUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CTimeUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! \copydoc CMeasurementUnit::makeRoundedQStringWithUnit
|
|
virtual QString makeRoundedQStringWithUnit(double value, int digits = -1, bool withGroupSeparator = false, bool i18n = false) const override;
|
|
|
|
//! Second s
|
|
static const CTimeUnit &s()
|
|
{
|
|
static const CMeasurementUnit::Data s_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "second")), constQLatin1("s"), IdentityConverter(), 1);
|
|
static const CTimeUnit s(s_);
|
|
return s;
|
|
}
|
|
|
|
//! Millisecond ms
|
|
static const CTimeUnit &ms()
|
|
{
|
|
static const CMeasurementUnit::Data ms_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "millisecond")), constQLatin1("ms"), LinearConverter<Milli<SecondsToSeconds> >(), 0);
|
|
static const CTimeUnit ms(ms_);
|
|
return ms;
|
|
}
|
|
|
|
//! Hour
|
|
static const CTimeUnit &h()
|
|
{
|
|
static const CMeasurementUnit::Data h_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "hour")), constQLatin1("h"), LinearConverter<HoursToSeconds>(), 1);
|
|
static const CTimeUnit h(h_);
|
|
return h;
|
|
}
|
|
|
|
//! Minute
|
|
static const CTimeUnit &min()
|
|
{
|
|
static const CMeasurementUnit::Data minute_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "minute")), constQLatin1("min"), LinearConverter<MinutesToSeconds>(), 2);
|
|
static const CTimeUnit minute(minute_);
|
|
return minute;
|
|
}
|
|
|
|
//! Day
|
|
static const CTimeUnit &d()
|
|
{
|
|
static const CMeasurementUnit::Data day_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "day")), constQLatin1("d"), LinearConverter<DaysToSeconds>(), 1);
|
|
static const CTimeUnit day(day_);
|
|
return day;
|
|
}
|
|
|
|
//! Hours, minutes, seconds
|
|
static const CTimeUnit &hms()
|
|
{
|
|
static const CMeasurementUnit::Data hms_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "hour, minute, second")), constQLatin1("hms"), SubdivisionConverter2<HoursToSeconds, InEachHundred<60> >(), 4);
|
|
static const CTimeUnit hms(hms_);
|
|
return hms;
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "%L1h%L2m%L3s");
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "%-L1h%L2m%L3s");
|
|
}
|
|
|
|
//! Hours, minutes
|
|
static const CTimeUnit &hrmin()
|
|
{
|
|
static const CMeasurementUnit::Data hrmin_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "hour, minute")), constQLatin1("hm"), SubdivisionConverter<HoursToSeconds, InEachHundred<60> >(), 3);
|
|
static const CTimeUnit hrmin(hrmin_);
|
|
return hrmin;
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "%L1h%L2m");
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "-%L1h%L2m");
|
|
}
|
|
|
|
//! Minutes, seconds
|
|
static const CTimeUnit &minsec()
|
|
{
|
|
static const CMeasurementUnit::Data minsec_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "minute, second")), constQLatin1("minsec"), SubdivisionConverter<MinutesToSeconds, InEachHundred<60> >(), 2);
|
|
static const CTimeUnit minsec(minsec_);
|
|
return minsec;
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "%L1m%L2s");
|
|
(void)QT_TRANSLATE_NOOP("CMeasurementUnit", "-%L1m%L2s");
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CTimeUnit> &allUnits()
|
|
{
|
|
static const QList<CTimeUnit> u
|
|
{
|
|
CTimeUnit::nullUnit(),
|
|
CTimeUnit::d(),
|
|
CTimeUnit::h(),
|
|
CTimeUnit::hms(),
|
|
CTimeUnit::hrmin(),
|
|
CTimeUnit::min(),
|
|
CTimeUnit::ms(),
|
|
CTimeUnit::s()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CTimeUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
//! Specialized class for acceleration units (m/s2, ft/s2).
|
|
class BLACKMISC_EXPORT CAccelerationUnit final:
|
|
public CMeasurementUnit,
|
|
public Mixin::MetaType<CAccelerationUnit>,
|
|
public Mixin::DBusOperators<CAccelerationUnit>,
|
|
public Mixin::Index<CAccelerationUnit>
|
|
{
|
|
private:
|
|
using CMeasurementUnit::CMeasurementUnit;
|
|
|
|
struct FeetToMeters { static double factor() { return 0.3048; } };
|
|
|
|
virtual void anchor();
|
|
|
|
public:
|
|
//! Base type
|
|
using base_type = CMeasurementUnit;
|
|
|
|
BLACKMISC_DECLARE_USING_MIXIN_METATYPE(CAccelerationUnit)
|
|
|
|
//! Default constructor, required for Qt Metasystem
|
|
CAccelerationUnit() : CMeasurementUnit(defaultUnit()) {}
|
|
|
|
//! Null constructor
|
|
CAccelerationUnit(std::nullptr_t) : CMeasurementUnit(nullUnit()) {}
|
|
|
|
//! Default unit
|
|
static const CAccelerationUnit &defaultUnit() { return m_s2(); }
|
|
|
|
//! Null unit
|
|
static const CAccelerationUnit &nullUnit()
|
|
{
|
|
static const CMeasurementUnit::Data nu_(constQLatin1("null"), constQLatin1("null"));
|
|
static const CAccelerationUnit nu(nu_);
|
|
return nu;
|
|
}
|
|
|
|
//! Meter/second^2 (m/s^2)
|
|
static const CAccelerationUnit &m_s2()
|
|
{
|
|
static const CMeasurementUnit::Data ms2_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "meter per second per second")), constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "m/s^2")), IdentityConverter(), 1);
|
|
static const CAccelerationUnit ms2(ms2_);
|
|
return ms2;
|
|
}
|
|
|
|
//! Feet/second^2
|
|
static const CAccelerationUnit &ft_s2()
|
|
{
|
|
static const CMeasurementUnit::Data fts2_(constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "foot per second per second")), constQLatin1(QT_TRANSLATE_NOOP("CMeasurementUnit", "ft/s^2")), LinearConverter<FeetToMeters>(), 0);
|
|
static const CAccelerationUnit fts2(fts2_);
|
|
return fts2;
|
|
}
|
|
|
|
//! All units
|
|
static const QList<CAccelerationUnit> &allUnits()
|
|
{
|
|
static const QList<CAccelerationUnit> u
|
|
{
|
|
CAccelerationUnit::nullUnit(),
|
|
CAccelerationUnit::ft_s2(),
|
|
CAccelerationUnit::m_s2()
|
|
};
|
|
return u;
|
|
}
|
|
|
|
//! \copydoc BlackMisc::Mixin::DBusByMetaClass::unmarshallFromDbus
|
|
void unmarshallFromDbus(const QDBusArgument &argument)
|
|
{
|
|
QString unitName;
|
|
argument >> unitName;
|
|
(*this) = CMeasurementUnit::unitFromSymbol<CAccelerationUnit>(unitName);
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
} // namespace
|
|
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CLengthUnit)
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CAngleUnit)
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CFrequencyUnit)
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CMassUnit)
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CPressureUnit)
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CTemperatureUnit)
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CSpeedUnit)
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CTimeUnit)
|
|
Q_DECLARE_METATYPE(BlackMisc::PhysicalQuantities::CAccelerationUnit)
|
|
|
|
#pragma pop_macro("min")
|
|
|
|
#endif // guard
|