File indexing completed on 2024-04-14 03:56:10

 /*
  *   SPDX-FileCopyrightText: 2008-2009 Petri Damstén <damu@iki.fi>
  *   SPDX-FileCopyrightText: 2014 John Layt <jlayt@kde.org>
  *
  *   SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #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 "weight_per_area_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_flux_p.h"
 #include "thermal_generation_p.h"
 #include "timeunit_p.h"
 #include "unit.h"
 #include "velocity_p.h"
 #include "voltage_p.h"
 #include "volume_p.h"
 
 #include <KLocalizedString>
 
 namespace KUnitConversion
 {
 class ConverterPrivate : public QSharedData
 {
 public:
     ConverterPrivate()
     {
         m_categories[LengthCategory] = Length::makeCategory();
         m_categories[AreaCategory] = Area::makeCategory();
         m_categories[VolumeCategory] = Volume::makeCategory();
         m_categories[TemperatureCategory] = Temperature::makeCategory();
         m_categories[VelocityCategory] = Velocity::makeCategory();
         m_categories[MassCategory] = Mass::makeCategory();
         m_categories[PressureCategory] = Pressure::makeCategory();
         m_categories[EnergyCategory] = Energy::makeCategory();
         m_categories[CurrencyCategory] = Currency::makeCategory();
         m_categories[PowerCategory] = Power::makeCategory();
         m_categories[TimeCategory] = Time::makeCategory();
         m_categories[FuelEfficiencyCategory] = FuelEfficiency::makeCategory();
         m_categories[DensityCategory] = Density::makeCategory();
         m_categories[WeightPerAreaCategory] = WeightPerArea::makeCategory();
         m_categories[AccelerationCategory] = Acceleration::makeCategory();
         m_categories[ForceCategory] = Force::makeCategory();
         m_categories[AngleCategory] = Angle::makeCategory();
         m_categories[FrequencyCategory] = Frequency::makeCategory();
         m_categories[ThermalConductivityCategory] = ThermalConductivity::makeCategory();
         m_categories[ThermalFluxCategory] = ThermalFlux::makeCategory();
         m_categories[ThermalGenerationCategory] = ThermalGeneration::makeCategory();
         m_categories[VoltageCategory] = Voltage::makeCategory();
         m_categories[ElectricalCurrentCategory] = ElectricalCurrent::makeCategory();
         m_categories[ElectricalResistanceCategory] = ElectricalResistance::makeCategory();
         m_categories[PermeabilityCategory] = Permeability::makeCategory();
         m_categories[BinaryDataCategory] = BinaryData::makeCategory();
     }
 
     QMap<CategoryId, UnitCategory> m_categories;
 };
 
 class QConverterSingleton
 {
 public:
     QConverterSingleton()
         : d(new ConverterPrivate())
     {
     }
     QExplicitlySharedDataPointer<ConverterPrivate> 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;
 }
 
 Converter &Converter::operator=(Converter &&other)
 {
     d.swap(other.d);
     return *this;
 }
 
 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<UnitCategory> Converter::categories() const
 {
     if (d) {
         return d->m_categories.values();
     }
     return QList<UnitCategory>();
 }
 
 }