diff --git a/README.md b/README.md index 46ca427..c7f4faf 100644 --- a/README.md +++ b/README.md @@ -1,44 +1,45 @@ # KUnitConversion Converting physical units ## Introduction KUnitConversion provides functions to convert values in different physical units. It supports converting different prefixes (e.g. kilo, mega, giga) as well as converting between different unit systems (e.g. liters, gallons). The following areas are supported: * Acceleration * Angle * Area +* Binary Data * Currency * Density * Electrical Current * Electrical Resistance * Energy * Force * Frequency * Fuel efficiency * Length * Mass * Permeability * Power * Pressure * Temperature * Thermal Conductivity * Thermal Flux * Thermal Generation * Time * Velocity * Volume * Voltage ## Usage To convert 100 GBP into EUR, you can write: using namespace KUnitConversion; Value pounds(100, Gbp); Value eur = pounds.convertTo(Eur); diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 2eeac2b..f772b32 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,96 +1,97 @@ set(kunitconversion_LIB_SRCS converter.cpp value.cpp unit.cpp unitcategory.cpp length.cpp area.cpp volume.cpp temperature.cpp velocity.cpp mass.cpp pressure.cpp energy.cpp currency.cpp power.cpp timeunit.cpp fuel_efficiency.cpp density.cpp acceleration.cpp force.cpp angle.cpp frequency.cpp thermal_conductivity.cpp thermal_flux.cpp thermal_generation.cpp voltage.cpp electrical_current.cpp electrical_resistance.cpp permeability.cpp + binary_data.cpp ) add_library(KF5UnitConversion ${kunitconversion_LIB_SRCS}) if (WIN32) # As stated in http://msdn.microsoft.com/en-us/library/4hwaceh6.aspx M_PI only gets defined # when using MSVC if _USE_MATH_DEFINES is defined (this is needed for angle.cpp) target_compile_definitions(KF5UnitConversion PRIVATE _USE_MATH_DEFINES) endif() generate_export_header(KF5UnitConversion BASE_NAME KUnitConversion EXPORT_FILE_NAME ${CMAKE_CURRENT_BINARY_DIR}/kunitconversion/kunitconversion_export.h) add_library(KF5::UnitConversion ALIAS KF5UnitConversion) target_include_directories(KF5UnitConversion PUBLIC "$") target_include_directories(KF5UnitConversion INTERFACE "$") target_link_libraries(KF5UnitConversion PUBLIC Qt5::Core PRIVATE Qt5::Network KF5::I18n #i18n(), ... ) set_target_properties(KF5UnitConversion PROPERTIES VERSION ${KUNITCONVERSION_VERSION_STRING} SOVERSION ${KUNITCONVERSION_SOVERSION} EXPORT_NAME UnitConversion ) ecm_generate_headers(KUnitConversion_CamelCase_HEADERS HEADER_NAMES Converter Value Unit UnitCategory PREFIX KUnitConversion REQUIRED_HEADERS KUnitConversion_HEADERS ) install(FILES ${KUnitConversion_CamelCase_HEADERS} DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/KUnitConversion/KUnitConversion COMPONENT Devel) install(TARGETS KF5UnitConversion EXPORT KF5UnitConversionTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS}) install(FILES ${CMAKE_CURRENT_BINARY_DIR}/kunitconversion/kunitconversion_export.h ${KUnitConversion_HEADERS} DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/KUnitConversion/kunitconversion COMPONENT Devel ) if(BUILD_QCH) ecm_add_qch( KF5UnitConversion_QCH NAME KUnitConversion BASE_NAME KF5UnitConversion VERSION ${KF5_VERSION} ORG_DOMAIN org.kde SOURCES # using only public headers, to cover only public API ${KUnitConversion_HEADERS} MD_MAINPAGE "${CMAKE_SOURCE_DIR}/README.md" LINK_QCHS Qt5Core_QCH BLANK_MACROS KUNITCONVERSION_EXPORT KUNITCONVERSION_DEPRECATED KUNITCONVERSION_DEPRECATED_EXPORT TAGFILE_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR} QCH_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR} COMPONENT Devel ) endif() include(ECMGeneratePriFile) ecm_generate_pri_file(BASE_NAME KUnitConversion LIB_NAME KF5UnitConversion DEPS "core" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/KUnitConversion) install(FILES ${PRI_FILENAME} DESTINATION ${ECM_MKSPECS_INSTALL_DIR}) diff --git a/src/binary_data.cpp b/src/binary_data.cpp new file mode 100644 index 0000000..11a38e3 --- /dev/null +++ b/src/binary_data.cpp @@ -0,0 +1,365 @@ +/* + * Copyright (C) 2019 Jonathan Rubenstein + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + + +#include "binary_data_p.h" +#include "unit_p.h" + +#include + +#include + +namespace KUnitConversion +{ + +class BinaryPowerOfTwoUnitPrivate : public UnitPrivate +{ +public: + BinaryPowerOfTwoUnitPrivate(CategoryId categoryId, UnitId id, qreal multiplier, + const QString &symbol, const QString &description, + const QString &matchString, const KLocalizedString &symbolString, + const KLocalizedString &realString, const KLocalizedString &integerString) + : UnitPrivate(categoryId, id, multiplier, + symbol, description, + matchString, symbolString, + realString, integerString) + {} + + qreal toDefault(qreal value) const override + { + return value * pow(2.0, m_multiplier); + } + qreal fromDefault(qreal value) const override + { + return value / pow(2.0, m_multiplier); + } +}; + +BinaryData::BinaryData() : CustomCategory(BinaryDataCategory, i18n("Binary Data"), i18n("Binary Data Size")) +{ + KLocalizedString symbolString = ki18nc("%1 value, %2 unit symbol (binary data)", "%1 %2"); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Yobibyte, 83, + i18nc("binary data unit symbol", "YiB"), + i18nc("unit description in lists", "yobibytes"), + i18nc("unit synonyms for matching user input", + "YiB;yobibyte;yobibytes"), + symbolString, + ki18nc("amount in units (real)", "%1 yobibytes"), + ki18ncp("amount in units (integer)", "%1 yobibyte", "%1 yobibytes")))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Yobibit, 80, + i18nc("binary data unit symbol", "Yib"), + i18nc("unit description in lists", "yobibits"), + i18nc("unit synonyms for matching user input", + "Yib;yobibit;yobibits"), + symbolString, + ki18nc("amount in units (real)", "%1 yobibits"), + ki18ncp("amount in units (integer)", "%1 yobibit", "%1 yobibits")))); + + addUnit(CustomUnit(BinaryDataCategory, Yottabyte, 8e+24, + i18nc("binary data unit symbol", "YB"), + i18nc("unit description in lists", "yottabytes"), + i18nc("unit synonyms for matching user input", + "YB;yottabyte;yottabytes"), + symbolString, + ki18nc("amount in units (real)", "%1 yottabytes"), + ki18ncp("amount in units (integer)", "%1 yottabyte", "%1 yottabytes"))); + + addUnit(CustomUnit(BinaryDataCategory, Yottabit, 1e+24, + i18nc("binary data unit symbol", "Yb"), + i18nc("unit description in lists", "yottabits"), + i18nc("unit synonyms for matching user input", + "Yb;yottabit;yottabits"), + symbolString, + ki18nc("amount in units (real)", "%1 yottabits"), + ki18ncp("amount in units (integer)", "%1 yottabit", "%1 yottabits"))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Zebibyte, 73, + i18nc("binary data unit symbol", "ZiB"), + i18nc("unit description in lists", "zebibytes"), + i18nc("unit synonyms for matching user input", + "ZiB;zebibyte;zebibytes"), + symbolString, + ki18nc("amount in units (real)", "%1 zebibytes"), + ki18ncp("amount in units (integer)", "%1 zebibyte", "%1 zebibytes")))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Zebibit, 70, + i18nc("binary data unit symbol", "Zib"), + i18nc("unit description in lists", "zebibits"), + i18nc("unit synonyms for matching user input", + "Zib;zebibit;zebibits"), + symbolString, + ki18nc("amount in units (real)", "%1 zebibits"), + ki18ncp("amount in units (integer)", "%1 zebibit", "%1 zebibits")))); + + addUnit(CustomUnit(BinaryDataCategory, Zettabyte, 8e+21, + i18nc("binary data unit symbol", "ZB"), + i18nc("unit description in lists", "zettabytes"), + i18nc("unit synonyms for matching user input", + "ZB;zettabyte;zettabytes"), + symbolString, + ki18nc("amount in units (real)", "%1 zettabytes"), + ki18ncp("amount in units (integer)", "%1 zettabyte", "%1 zettabytes"))); + + addUnit(CustomUnit(BinaryDataCategory, Zettabit, 1e+21, + i18nc("binary data unit symbol", "Zb"), + i18nc("unit description in lists", "zettabits"), + i18nc("unit synonyms for matching user input", + "Zb;zettabit;zettabits"), + symbolString, + ki18nc("amount in units (real)", "%1 zettabits"), + ki18ncp("amount in units (integer)", "%1 zettabit", "%1 zettabits"))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Exbibyte, 63, + i18nc("binary data unit symbol", "EiB"), + i18nc("unit description in lists", "exbibytes"), + i18nc("unit synonyms for matching user input", + "EiB;exbibyte;exbibytes"), + symbolString, + ki18nc("amount in units (real)", "%1 exbibytes"), + ki18ncp("amount in units (integer)", "%1 exbibyte", "%1 exbibytes")))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Exbibit, 60, + i18nc("binary data unit symbol", "Eib"), + i18nc("unit description in lists", "exbibits"), + i18nc("unit synonyms for matching user input", + "Eib;exbibit;exbibits"), + symbolString, + ki18nc("amount in units (real)", "%1 exbibits"), + ki18ncp("amount in units (integer)", "%1 exbibit", "%1 exbibits")))); + + addUnit(CustomUnit(BinaryDataCategory, Exabyte, 8e+18, + i18nc("binary data unit symbol", "EB"), + i18nc("unit description in lists", "exabytes"), + i18nc("unit synonyms for matching user input", + "EB;exabyte;exabytes"), + symbolString, + ki18nc("amount in units (real)", "%1 exabytes"), + ki18ncp("amount in units (integer)", "%1 exabyte", "%1 exabytes"))); + + addUnit(CustomUnit(BinaryDataCategory, Exabit, 1e+18, + i18nc("binary data unit symbol", "Eb"), + i18nc("unit description in lists", "exabits"), + i18nc("unit synonyms for matching user input", + "Eb;exabit;exabits"), + symbolString, + ki18nc("amount in units (real)", "%1 exabits"), + ki18ncp("amount in units (integer)", "%1 exabit", "%1 exabits"))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Pebibyte, 53, + i18nc("binary data unit symbol", "PiB"), + i18nc("unit description in lists", "pebibytes"), + i18nc("unit synonyms for matching user input", + "PiB;pebibyte;pebibytes"), + symbolString, + ki18nc("amount in units (real)", "%1 pebibytes"), + ki18ncp("amount in units (integer)", "%1 pebibyte", "%1 pebibytes")))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Pebibit, 50, + i18nc("binary data unit symbol", "Pib"), + i18nc("unit description in lists", "pebibits"), + i18nc("unit synonyms for matching user input", + "Pib;pebibit;pebibits"), + symbolString, + ki18nc("amount in units (real)", "%1 pebibits"), + ki18ncp("amount in units (integer)", "%1 pebibit", "%1 pebibits")))); + + addUnit(CustomUnit(BinaryDataCategory, Petabyte, 8e+15, + i18nc("binary data unit symbol", "PB"), + i18nc("unit description in lists", "petabytes"), + i18nc("unit synonyms for matching user input", + "PB;petabyte;petabytes"), + symbolString, + ki18nc("amount in units (real)", "%1 petabytes"), + ki18ncp("amount in units (integer)", "%1 petabyte", "%1 petabytes"))); + + addUnit(CustomUnit(BinaryDataCategory, Petabit, 1e+15, + i18nc("binary data unit symbol", "Tb"), + i18nc("unit description in lists", "petabits"), + i18nc("unit synonyms for matching user input", + "Tb;petabit;petabits"), + symbolString, + ki18nc("amount in units (real)", "%1 petabits"), + ki18ncp("amount in units (integer)", "%1 petabit", "%1 petabits"))); + + addCommonUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Tebibyte, 43, + i18nc("binary data unit symbol", "TiB"), + i18nc("unit description in lists", "tebibytes"), + i18nc("unit synonyms for matching user input", + "TiB;tebibyte;tebibytes"), + symbolString, + ki18nc("amount in units (real)", "%1 tebibytes"), + ki18ncp("amount in units (integer)", "%1 tebibyte", "%1 tebibytes")))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Tebibit, 40, + i18nc("binary data unit symbol", "Tib"), + i18nc("unit description in lists", "tebibits"), + i18nc("unit synonyms for matching user input", + "Tib;tebibit;tebibits"), + symbolString, + ki18nc("amount in units (real)", "%1 tebibits"), + ki18ncp("amount in units (integer)", "%1 tebibit", "%1 tebibits")))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Terabyte, 8e+12, + i18nc("binary data unit symbol", "TB"), + i18nc("unit description in lists", "terabytes"), + i18nc("unit synonyms for matching user input", + "TB;terabyte;terabytes"), + symbolString, + ki18nc("amount in units (real)", "%1 terabytes"), + ki18ncp("amount in units (integer)", "%1 terabyte", "%1 terabytes"))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Terabit, 1e+12, + i18nc("binary data unit symbol", "Tb"), + i18nc("unit description in lists", "terabits"), + i18nc("unit synonyms for matching user input", + "Tb;terabit;terabits"), + symbolString, + ki18nc("amount in units (real)", "%1 terabits"), + ki18ncp("amount in units (integer)", "%1 terabit", "%1 terabits"))); + + addCommonUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Gibibyte, 33, + i18nc("binary data unit symbol", "GiB"), + i18nc("unit description in lists", "gibibytes"), + i18nc("unit synonyms for matching user input", + "GiB;gibibyte;gibibytes"), + symbolString, + ki18nc("amount in units (real)", "%1 gibibytes"), + ki18ncp("amount in units (integer)", "%1 gibibyte", "%1 gibibytes")))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Gibibit, 30, + i18nc("binary data unit symbol", "Gib"), + i18nc("unit description in lists", "gibibits"), + i18nc("unit synonyms for matching user input", + "Gib;gibibit;gibibits"), + symbolString, + ki18nc("amount in units (real)", "%1 gibibits"), + ki18ncp("amount in units (integer)", "%1 gibibit", "%1 gibibits")))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Gigabyte, 8e+09, + i18nc("binary data unit symbol", "GB"), + i18nc("unit description in lists", "gigabytes"), + i18nc("unit synonyms for matching user input", + "GB;gigabyte;gigabytes"), + symbolString, + ki18nc("amount in units (real)", "%1 gigabytes"), + ki18ncp("amount in units (integer)", "%1 gigabyte", "%1 gigabytes"))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Gigabit, 1e+09, + i18nc("binary data unit symbol", "Gb"), + i18nc("unit description in lists", "gigabits"), + i18nc("unit synonyms for matching user input", + "Gb;gigabit;gigabits"), + symbolString, + ki18nc("amount in units (real)", "%1 gigabits"), + ki18ncp("amount in units (integer)", "%1 gigabit", "%1 gigabits"))); + + addCommonUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Mebibyte, 23, + i18nc("binary data unit symbol", "MiB"), + i18nc("unit description in lists", "mebibytes"), + i18nc("unit synonyms for matching user input", + "MiB;mebibyte;mebibytes"), + symbolString, + ki18nc("amount in units (real)", "%1 mebibytes"), + ki18ncp("amount in units (integer)", "%1 mebibyte", "%1 mebibytes")))); + + addUnit(CustomUnit(new BinaryPowerOfTwoUnitPrivate(BinaryDataCategory, Mebibit, 20, + i18nc("binary data unit symbol", "Mib"), + i18nc("unit description in lists", "mebibits"), + i18nc("unit synonyms for matching user input", + "Mib;mebibit;mebibits"), + symbolString, + ki18nc("amount in units (real)", "%1 mebibits"), + ki18ncp("amount in units (integer)", "%1 mebibit", "%1 mebibits")))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Megabyte, 8e+06, + i18nc("binary data unit symbol", "MB"), + i18nc("unit description in lists", "megabytes"), + i18nc("unit synonyms for matching user input", + "MB;megabyte;megabytes"), + symbolString, + ki18nc("amount in units (real)", "%1 megabytes"), + ki18ncp("amount in units (integer)", "%1 megabyte", "%1 megabytes"))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Megabit, 1e+06, + i18nc("binary data unit symbol", "Mb"), + i18nc("unit description in lists", "megabits"), + i18nc("unit synonyms for matching user input", + "Mb;megabit;megabits"), + symbolString, + ki18nc("amount in units (real)", "%1 megabits"), + ki18ncp("amount in units (integer)", "%1 megabit", "%1 megabits"))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Kibibyte, 8192, + i18nc("binary data unit symbol", "KiB"), + i18nc("unit description in lists", "kibibytes"), + i18nc("unit synonyms for matching user input", + "KiB;kibibyte;kibibytes"), + symbolString, + ki18nc("amount in units (real)", "%1 kibibytes"), + ki18ncp("amount in units (integer)", "%1 kibibyte", "%1 kibibytes"))); + + addUnit(CustomUnit(BinaryDataCategory, Kibibit, 1024, + i18nc("binary data unit symbol", "Kib"), + i18nc("unit description in lists", "kibibits"), + i18nc("unit synonyms for matching user input", + "Kib;kibibit;kibibits"), + symbolString, + ki18nc("amount in units (real)", "%1 kibibits"), + ki18ncp("amount in units (integer)", "%1 kibibit", "%1 kibibits"))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Kilobyte, 8000, + i18nc("binary data unit symbol", "kB"), + i18nc("unit description in lists", "kilobytes"), + i18nc("unit synonyms for matching user input", + "kB;kilobyte;kilobytes"), + symbolString, + ki18nc("amount in units (real)", "%1 kilobytes"), + ki18ncp("amount in units (integer)", "%1 kilobyte", "%1 kilobytes"))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Kilobit, 1000, + i18nc("binary data unit symbol", "kb"), + i18nc("unit description in lists", "kilobits"), + i18nc("unit synonyms for matching user input", + "kb;kilobit;kilobits"), + symbolString, + ki18nc("amount in units (real)", "%1 kilobits"), + ki18ncp("amount in units (integer)", "%1 kilobit", "%1 kilobits"))); + + addCommonUnit(CustomUnit(BinaryDataCategory, Byte, 8, + i18nc("binary data unit symbol", "B"), + i18nc("unit description in lists", "bytes"), + i18nc("unit synonyms for matching user input", + "B;byte;bytes"), + symbolString, + ki18nc("amount in units (real)", "%1 bytes"), + ki18ncp("amount in units (integer)", "%1 byte", "%1 bytes"))); + + addDefaultUnit(CustomUnit(BinaryDataCategory, Bit, 1, + i18nc("binary data unit symbol", "b"), + i18nc("unit description in lists", "bits"), + i18nc("unit synonyms for matching user input", + "b;bit;bits"), + symbolString, + ki18nc("amount in units (real)", "%1 bits"), + ki18ncp("amount in units (integer)", "%1 bit", "%1 bits"))); +} + +} // KUnitConversion namespace diff --git a/src/binary_data_p.h b/src/binary_data_p.h new file mode 100644 index 0000000..5ab4785 --- /dev/null +++ b/src/binary_data_p.h @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2019 Jonathan Rubenstein + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Library General Public License as + * published by the Free Software Foundation; either version 2, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the + * Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + */ + +#ifndef BINARY_DATA_P_H +#define BINARY_DATA_P_H + +#include "unitcategory_p.h" + +namespace KUnitConversion +{ + +class BinaryData : public CustomCategory +{ +public: + BinaryData(); +}; + +} // KUnitConversion namespace + +#endif diff --git a/src/converter.cpp b/src/converter.cpp index 25e50d5..b8458c0 100644 --- a/src/converter.cpp +++ b/src/converter.cpp @@ -1,239 +1,241 @@ /* * Copyright (C) 2008-2009 Petri Damstén * Copyright (C) 2014 John Layt * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Library General Public License as * published by the Free Software Foundation; either version 2, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details * * You should have received a copy of the GNU Library General Public * License along with this program; if not, write to the * Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "converter.h" #include "acceleration_p.h" #include "angle_p.h" #include "area_p.h" +#include "binary_data_p.h" #include "currency_p.h" #include "density_p.h" #include "electrical_current_p.h" #include "electrical_resistance_p.h" #include "energy_p.h" #include "force_p.h" #include "frequency_p.h" #include "fuel_efficiency_p.h" #include "length_p.h" #include "mass_p.h" #include "permeability_p.h" #include "power_p.h" #include "pressure_p.h" #include "temperature_p.h" #include "thermal_conductivity_p.h" #include "thermal_generation_p.h" #include "thermal_flux_p.h" #include "timeunit_p.h" #include "velocity_p.h" #include "voltage_p.h" #include "volume_p.h" #include namespace KUnitConversion { class ConverterPrivate : public QSharedData { public: ConverterPrivate() { m_categories[LengthCategory] = Length(); m_categories[AreaCategory] = Area(); m_categories[VolumeCategory] = Volume(); m_categories[TemperatureCategory] = Temperature(); m_categories[VelocityCategory] = Velocity(); m_categories[MassCategory] = Mass(); m_categories[PressureCategory] = Pressure(); m_categories[EnergyCategory] = Energy(); m_categories[CurrencyCategory] = Currency(); m_categories[PowerCategory] = Power(); m_categories[TimeCategory] = Time(); m_categories[FuelEfficiencyCategory] = FuelEfficiency(); m_categories[DensityCategory] = Density(); m_categories[AccelerationCategory] = Acceleration(); m_categories[ForceCategory] = Force(); m_categories[AngleCategory] = Angle(); m_categories[FrequencyCategory] = Frequency(); m_categories[ThermalConductivityCategory] = ThermalConductivity(); m_categories[ThermalFluxCategory] = ThermalFlux(); m_categories[ThermalGenerationCategory] = ThermalGeneration(); m_categories[VoltageCategory] = Voltage(); m_categories[ElectricalCurrentCategory] = ElectricalCurrent(); m_categories[ElectricalResistanceCategory] = ElectricalResistance(); m_categories[PermeabilityCategory] = Permeability(); + m_categories[BinaryDataCategory] = BinaryData(); } virtual ~ConverterPrivate() { } ConverterPrivate *clone() { return new ConverterPrivate(*this); } bool operator==(const ConverterPrivate &other) const { return (m_categories == other.m_categories); } bool operator!=(const ConverterPrivate &other) const { return !(*this == other); } QMap m_categories; }; class QConverterSingleton { public: QConverterSingleton() : d(new ConverterPrivate()) {} QExplicitlySharedDataPointer d; }; Q_GLOBAL_STATIC(QConverterSingleton, global_converter) Converter::Converter() : d(global_converter->d) { } Converter::~Converter() { } Converter::Converter(const Converter &other) : d(other.d) { } Converter &Converter::operator=(const Converter &other) { d = other.d; return *this; } bool Converter::operator==(const Converter &other) const { if (d && other.d) return (*d == *other.d); else return (d == other.d); } bool Converter::operator!=(const Converter &other) const { if (d && other.d) return (*d != *other.d); else return (d != other.d); } Value Converter::convert(const Value &value, const QString &toUnit) const { if (d && value.unit().isValid()) { return value.unit().category().convert(value, toUnit); } return Value(); } Value Converter::convert(const Value &value, UnitId toUnit) const { if (d && value.unit().isValid()) { return value.unit().category().convert(value, toUnit); } return Value(); } Value Converter::convert(const Value &value, const Unit &toUnit) const { if (d && toUnit.isValid() && value.unit().isValid()) { return value.unit().category().convert(value, toUnit); } return Value(); } UnitCategory Converter::categoryForUnit(const QString &unit) const { const auto lstCategories = categories(); for (const UnitCategory &u : lstCategories) { if (u.hasUnit(unit)) { return u; } } return UnitCategory(); } Unit Converter::unit(const QString &unitString) const { const auto lstCategories = categories(); for (const UnitCategory &u : lstCategories) { Unit unitClass = u.unit(unitString); if (unitClass.isValid()) { return unitClass; } } return Unit(); } Unit Converter::unit(UnitId unitId) const { const auto lstCategories = categories(); for (const UnitCategory &u : lstCategories) { Unit unitClass = u.unit(unitId); if (unitClass.isValid()) { return unitClass; } } return Unit(); } UnitCategory Converter::category(const QString &category) const { const auto lstCategories = categories(); for (const UnitCategory &u : lstCategories) { if (u.name() == category) { return u; } } // not found return UnitCategory(); } UnitCategory Converter::category(CategoryId categoryId) const { if (d && d->m_categories.contains(categoryId)) { return d->m_categories[categoryId]; } // not found return UnitCategory(); } QList Converter::categories() const { if (d) return d->m_categories.values(); return QList(); } } diff --git a/src/unit.h b/src/unit.h index b5a1028..603897e 100644 --- a/src/unit.h +++ b/src/unit.h @@ -1,483 +1,554 @@ /* * Copyright (C) 2007-2009 Petri Damstén * Copyright (C) 2014 John Layt * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU Library General Public License as * published by the Free Software Foundation; either version 2, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details * * You should have received a copy of the GNU Library General Public * License along with this program; if not, write to the * Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #ifndef KUNITCONVERSION_UNIT_H #define KUNITCONVERSION_UNIT_H #include "kunitconversion/kunitconversion_export.h" #include #include class KLocalizedString; namespace KUnitConversion { enum CategoryId { InvalidCategory = -1, LengthCategory, AreaCategory, VolumeCategory, TemperatureCategory, VelocityCategory, MassCategory, PressureCategory, EnergyCategory, CurrencyCategory, PowerCategory, TimeCategory, FuelEfficiencyCategory, DensityCategory, AccelerationCategory, AngleCategory, FrequencyCategory, ForceCategory, /** @since 5.27 */ ThermalConductivityCategory, /** @since 5.27 */ ThermalFluxCategory, /** @since 5.27 */ ThermalGenerationCategory, /** @since 5.27 */ VoltageCategory, /** @since 5.27 */ ElectricalCurrentCategory, /** @since 5.27 */ ElectricalResistanceCategory, /** @since 5.53 */ - PermeabilityCategory + PermeabilityCategory, + /** @since 5.61 **/ + BinaryDataCategory }; enum UnitId { InvalidUnit = -1, NoUnit = 0, Percent = 1, // Area SquareYottameter = 1000, SquareZettameter, SquareExameter, SquarePetameter, SquareTerameter, SquareGigameter, SquareMegameter, SquareKilometer, SquareHectometer, SquareDecameter, SquareMeter, SquareDecimeter, SquareCentimeter, SquareMillimeter, SquareMicrometer, SquareNanometer, SquarePicometer, SquareFemtometer, SquareAttometer, SquareZeptometer, SquareYoctometer, Acre, SquareFoot, SquareInch, SquareMile, // Length Yottameter = 2000, Zettameter, Exameter, Petameter, Terameter, Gigameter, Megameter, Kilometer, Hectometer, Decameter, Meter, Decimeter, Centimeter, Millimeter, Micrometer, Nanometer, Picometer, Femtometer, Attometer, Zeptometer, Yoctometer, Inch, Foot, Yard, Mile, NauticalMile, LightYear, Parsec, AstronomicalUnit, Thou, Angstrom, // Volume CubicYottameter = 3000, CubicZettameter, CubicExameter, CubicPetameter, CubicTerameter, CubicGigameter, CubicMegameter, CubicKilometer, CubicHectometer, CubicDecameter, CubicMeter, CubicDecimeter, CubicCentimeter, CubicMillimeter, CubicMicrometer, CubicNanometer, CubicPicometer, CubicFemtometer, CubicAttometer, CubicZeptometer, CubicYoctometer, Yottaliter, Zettaliter, Exaliter, Petaliter, Teraliter, Gigaliter, Megaliter, Kiloliter, Hectoliter, Decaliter, Liter, Deciliter, Centiliter, Milliliter, Microliter, Nanoliter, Picoliter, Femtoliter, Attoliter, Zeptoliter, Yoctoliter, CubicFoot, CubicInch, CubicMile, FluidOunce, Cup, GallonUS, PintImperial, /** @since 5.53 */ OilBarrel, // Mass Yottagram = 4000, Zettagram, Exagram, Petagram, Teragram, Gigagram, Megagram, Kilogram, Hectogram, Decagram, Gram, Decigram, Centigram, Milligram, Microgram, Nanogram, Picogram, Femtogram, Attogram, Zeptogram, Yoctogram, Ton, Carat, Pound, Ounce, TroyOunce, MassNewton, Kilonewton, /** @since 5.26 */ Stone, // Pressure Yottapascal = 5000, Zettapascal, Exapascal, Petapascal, Terapascal, Gigapascal, Megapascal, Kilopascal, Hectopascal, Decapascal, Pascal, Decipascal, Centipascal, Millipascal, Micropascal, Nanopascal, Picopascal, Femtopascal, Attopascal, Zeptopascal, Yoctopascal, Bar, Millibar, Decibar, Torr, TechnicalAtmosphere, Atmosphere, PoundForcePerSquareInch, InchesOfMercury, MillimetersOfMercury, // Temperature Kelvin = 6000, Celsius, Fahrenheit, Rankine, Delisle, TemperatureNewton, Reaumur, Romer, // Energy Yottajoule = 7000, Zettajoule, Exajoule, Petajoule, Terajoule, Gigajoule, Megajoule, Kilojoule, Hectojoule, Decajoule, Joule, Decijoule, Centijoule, Millijoule, Microjoule, Nanojoule, Picojoule, Femtojoule, Attojoule, Zeptojoule, Yoctojoule, GuidelineDailyAmount, Electronvolt, Rydberg, Kilocalorie, PhotonWavelength, KiloJoulePerMole, JoulePerMole, /** @since 5.27 */ Btu, /** @since 5.27 */ Erg, // Currency Eur = 8000, Ats, Bef, Nlg, Fim, Frf, Dem, Iep, Itl, Luf, Pte, Esp, Grd, Sit, Cyp, Mtl, Skk, Usd, Jpy, Bgn, Czk, Dkk, Eek, Gbp, Huf, Ltl, Lvl, Pln, Ron, Sek, Chf, Nok, Hrk, Rub, Try, Aud, Brl, Cad, Cny, Hkd, Idr, Inr, Krw, Mxn, Myr, Nzd, Php, Sgd, Thb, Zar, Ils, // Velocity MeterPerSecond = 9000, KilometerPerHour, MilePerHour, FootPerSecond, InchPerSecond, Knot, Mach, SpeedOfLight, Beaufort, // Power Yottawatt = 10000, Zettawatt, Exawatt, Petawatt, Terawatt, Gigawatt, Megawatt, Kilowatt, Hectowatt, Decawatt, Watt, Deciwatt, Centiwatt, Milliwatt, Microwatt, Nanowatt, Picowatt, Femtowatt, Attowatt, Zeptowatt, Yoctowatt, Horsepower, // Time Yottasecond = 11000, Zettasecond, Exasecond, Petasecond, Terasecond, Gigasecond, Megasecond, Kilosecond, Hectosecond, Decasecond, Second, Decisecond, Centisecond, Millisecond, Microsecond, Nanosecond, Picosecond, Femtosecond, Attosecond, Zeptosecond, Yoctosecond, Minute, Hour, Day, Week, JulianYear, LeapYear, Year, // FuelEfficiency LitersPer100Kilometers = 12000, MilePerUsGallon, MilePerImperialGallon, KilometrePerLitre, // Density YottakilogramsPerCubicMeter = 13000, ZettakilogramPerCubicMeter, ExakilogramPerCubicMeter, PetakilogramPerCubicMeter, TerakilogramPerCubicMeter, GigakilogramPerCubicMeter, MegakilogramPerCubicMeter, KilokilogramPerCubicMeter, HectokilogramsPerCubicMeter, DecakilogramsPerCubicMeter, KilogramsPerCubicMeter, DecikilogramsPerCubicMeter, CentikilogramsPerCubicMeter, MillikilogramsPerCubicMeter, MicrokilogramsPerCubicMeter, NanokilogramsPerCubicMeter, PicokilogramsPerCubicMeter, FemtokilogramsPerCubicMeter, AttokilogramsPerCubicMeter, ZeptokilogramsPerCubicMeter, YoctokilogramsPerCubicMeter, KilogramPerLiter, GramPerLiter, GramPerMilliliter, OuncePerCubicInch, OuncePerCubicFoot, OuncePerCubicYard, PoundPerCubicInch, PoundPerCubicFoot, PoundPerCubicYard, // Acceleration MetresPerSecondSquared = 14000, FeetPerSecondSquared, StandardGravity, // Force Yottanewton = 15000, Zettanewton, Exanewton, Petanewton, Teranewton, Giganewton, Meganewton, KilonewtonForce, Hectonewton, Decanewton, Newton, Decinewton, Centinewton, Millinewton, Micronewton, Nanonewton, Piconewton, Femtonewton, Attonewton, Zeptonewton, Yoctonewton, Dyne, Kilopond, PoundForce, Poundal, // Angle Degree = 16000, Radian, Gradian, ArcMinute, ArcSecond, // Frequency Yottahertz = 17000, Zettahertz, Exahertz, Petahertz, Terahertz, Gigahertz, Megahertz, Kilohertz, Hectohertz, Decahertz, Hertz, Decihertz, Centihertz, Millihertz, Microhertz, Nanohertz, Picohertz, Femtohertz, Attohertz, Zeptohertz, Yoctohertz, RPM, // Thermal Conductivity /** @since 5.27 */ WattPerMeterKelvin = 18000, /** @since 5.27 */ BtuPerFootHourFahrenheit, /** @since 5.27 */ BtuPerSquareFootHourFahrenheitPerInch, // Thermal Flux Density /** @since 5.27 */ WattPerSquareMeter = 19000, /** @since 5.27 */ BtuPerHourPerSquareFoot, // Thermal Generation per volume /** @since 5.27 */ WattPerCubicMeter = 20000, /** @since 5.27 */ BtuPerHourPerCubicFoot, // Voltage /** @since 5.27 */ Yottavolts = 30000, /** @since 5.27 */ Zettavolts, /** @since 5.27 */ Exavolts, /** @since 5.27 */ Petavolts, /** @since 5.27 */ Teravolts, /** @since 5.27 */ Gigavolts, /** @since 5.27 */ Megavolts, /** @since 5.27 */ Kilovolts, /** @since 5.27 */ Hectovolts, /** @since 5.27 */ Decavolts, /** @since 5.27 */ Volts, /** @since 5.27 */ Decivolts, /** @since 5.27 */ Centivolts, /** @since 5.27 */ Millivolts, /** @since 5.27 */ Microvolts, /** @since 5.27 */ Nanovolts, /** @since 5.27 */ Picovolts, /** @since 5.27 */ Femtovolts, /** @since 5.27 */ Attovolts, /** @since 5.27 */ Zeptovolts, /** @since 5.27 */ Yoctovolts, /** @since 5.27 */ Statvolts, // Electrical Current /** @since 5.27 */ Yottaampere = 31000, /** @since 5.27 */ Zettaampere, /** @since 5.27 */ Exaampere, /** @since 5.27 */ Petaampere, /** @since 5.27 */ Teraampere, /** @since 5.27 */ Gigaampere, /** @since 5.27 */ Megaampere, /** @since 5.27 */ Kiloampere, /** @since 5.27 */ Hectoampere, /** @since 5.27 */ Decaampere, /** @since 5.27 */ Ampere, /** @since 5.27 */ Deciampere, /** @since 5.27 */ Centiampere, /** @since 5.27 */ Milliampere, /** @since 5.27 */ Microampere, /** @since 5.27 */ Nanoampere, /** @since 5.27 */ Picoampere, /** @since 5.27 */ Femtoampere, /** @since 5.27 */ Attoampere, /** @since 5.27 */ Zeptoampere, /** @since 5.27 */ Yoctoampere, // Electrical Resistance /** @since 5.27 */ Yottaohms = 32000, /** @since 5.27 */ Zettaohms, /** @since 5.27 */ Exaohms, /** @since 5.27 */ Petaohms, /** @since 5.27 */ Teraohms, /** @since 5.27 */ Gigaohms, /** @since 5.27 */ Megaohms, /** @since 5.27 */ Kiloohms, /** @since 5.27 */ Hectoohms, /** @since 5.27 */ Decaohms, /** @since 5.27 */ Ohms, /** @since 5.27 */ Deciohms, /** @since 5.27 */ Centiohms, /** @since 5.27 */ Milliohms, /** @since 5.27 */ Microohms, /** @since 5.27 */ Nanoohms, /** @since 5.27 */ Picoohms, /** @since 5.27 */ Femtoohms, /** @since 5.27 */ Attoohms, /** @since 5.27 */ Zeptoohms, /** @since 5.27 */ Yoctoohms, /** @since 5.53 */ Darcy = 33000, /** @since 5.53 */ MiliDarcy, /** @since 5.53 */ - PermeabilitySquareMicrometer + PermeabilitySquareMicrometer, + + /** @since 5.61 */ + Yobibyte = 34000, + /** @since 5.61 */ + Yobibit, + /** @since 5.61 */ + Yottabyte, + /** @since 5.61 */ + Yottabit, + /** @since 5.61 */ + Zebibyte, + /** @since 5.61 */ + Zebibit, + /** @since 5.61 */ + Zettabyte, + /** @since 5.61 */ + Zettabit, + /** @since 5.61 */ + Exbibyte, + /** @since 5.61 */ + Exbibit, + /** @since 5.61 */ + Exabyte, + /** @since 5.61 */ + Exabit, + /** @since 5.61 */ + Pebibyte, + /** @since 5.61 */ + Pebibit, + /** @since 5.61 */ + Petabyte, + /** @since 5.61 */ + Petabit, + /** @since 5.61 */ + Tebibyte, + /** @since 5.61 */ + Tebibit, + /** @since 5.61 */ + Terabyte, + /** @since 5.61 */ + Terabit, + /** @since 5.61 */ + Gibibyte, + /** @since 5.61 */ + Gibibit, + /** @since 5.61 */ + Gigabyte, + /** @since 5.61 */ + Gigabit, + /** @since 5.61 */ + Mebibyte, + /** @since 5.61 */ + Mebibit, + /** @since 5.61 */ + Megabyte, + /** @since 5.61 */ + Megabit, + /** @since 5.61 */ + Kibibyte, + /** @since 5.61 */ + Kibibit, + /** @since 5.61 */ + Kilobyte, + /** @since 5.61 */ + Kilobit, + /** @since 5.61 */ + Byte, + /** @since 5.61 */ + Bit }; class UnitCategory; class UnitPrivate; /** * @short Class to define a unit of measurement * * @since 4.4 * * This is a class to define a unit of measurement. * * @b license GNU-LGPL v.2 or later * * @see Converter, UnitCategory, Value * * @author Petri Damstén * @author John Layt */ class KUNITCONVERSION_EXPORT Unit { public: /** * Null constructor **/ Unit(); /** * Copy constructor, copy @p other to this. **/ Unit(const Unit &other); virtual ~Unit(); /** * Assignment operator, assign @p other to this. **/ Unit &operator=(const Unit &other); #ifdef Q_COMPILER_RVALUE_REFS /** * Move-assigns @p other to this Unit instance, transferring the * ownership of the managed pointer to this instance. **/ Unit &operator=(Unit &&other) { swap(other); return *this; } #endif /** * Swaps this Unit with @p other. This function is very fast and never fails. **/ void swap(Unit &other) { d.swap(other.d); } /** * @return @c true if this Unit is equal to the @p other Unit. **/ bool operator==(const Unit &other) const; /** * @return @c true if this Unit is not equal to the @p other Unit. **/ bool operator!=(const Unit &other) const; /** * @return returns true if this Unit is null **/ bool isNull() const; /** * @return if unit is valid. **/ bool isValid() const; /** * @return unit id. **/ UnitId id() const; /** * @return category id. **/ CategoryId categoryId() const; /** * @return unit category. **/ UnitCategory category() const; /** * @return translated name for unit. **/ QString description() const; /** * @return symbol for the unit. **/ QString symbol() const; /** * @param value number value * @param fieldWidth width of the formatted field, padded by spaces. * Positive value aligns right, negative aligns left * @param format type of floating point formatting, like in QString::arg * @param precision number of digits after the decimal separator * @param fillChar the character used to fill up the empty places when * field width is greater than argument width * @return value + unit string **/ QString toString(qreal value, int fieldWidth = 0, char format = 'g', int precision = -1, const QChar &fillChar = QLatin1Char(' ')) const; /** * @param value number value * @param fieldWidth width of the formatted field, padded by spaces. * Positive value aligns right, negative aligns left * @param format type of floating point formatting, like in QString::arg * @param precision number of digits after the decimal separator * @param fillChar the character used to fill up the empty places when * field width is greater than argument width * @return value + unit string **/ QString toSymbolString(qreal value, int fieldWidth = 0, char format = 'g', int precision = -1, const QChar &fillChar = QLatin1Char(' ')) const; protected: qreal toDefault(qreal value) const; qreal fromDefault(qreal value) const; private: friend class CustomUnit; friend class UnitCategory; friend class UnitCategoryPrivate; friend class CurrencyCategoryPrivate; Unit(UnitPrivate *dd); void setUnitMultiplier(qreal multiplier); QExplicitlySharedDataPointer d; }; } // KUnitConversion namespace #endif