unitConversions.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2013 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/

#pragma once

#include "simulationObjectEditorImpl/simulationObjectEditorImplDefines.h"
#include "tdbutil/tdbUnits.h"      
#include <vrvUtil/DtVirtualBaseClass.h>

#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QHash>
#include <QtCore/QList>

static const char* DtUnitTimeDay = "day";
static const char* DtUnitPercent = "percent";
static const char* DtUnitRounds = "rounds";
static const char* DtUnitRatio = "ratio";
static const char* DtUnitMils = "mils"; 


class DtConverter;

typedef DtConverter* (*DtConverterFcn)(bool);


class DT_DLL_simulationObjectEditorimpl DtUnitConverter
{

public:

   DtUnitConverter()
   {
   };

   virtual ~DtUnitConverter()
   {
   };

   DtUnitConverter(const DtUnitConverter& orig)
   {
   };

   DtUnitConverter& operator=(const DtUnitConverter& rhs)
   {
      if (this == &rhs)
      {
         return *this;
      }

      return *this;
   };

   virtual bool init()
   {
      return true;
   }

   virtual double metersToLocal(double meters) = 0;

   virtual double localToMeters(double local) = 0;
};


class DT_DLL_simulationObjectEditorimpl DtMeterConverter : public DtUnitConverter
{

public:

   DtMeterConverter()
   {
   };

   virtual ~DtMeterConverter() override {
   };

   DtMeterConverter(const DtMeterConverter& orig):
      DtUnitConverter(orig)
   {
   };

   DtMeterConverter& operator=(const DtMeterConverter& rhs)
   {
      if (this == &rhs)
      {
         return *this;
      }

      DtUnitConverter::operator=(rhs);

      return *this;
   };

   virtual double metersToLocal(double meters) override;

   virtual double localToMeters(double local) override;
};

class DT_DLL_simulationObjectEditorimpl DtKilometerConverter : public DtUnitConverter
{

public:

   DtKilometerConverter()
   {
   };

   virtual ~DtKilometerConverter() override {
   };

   DtKilometerConverter(const DtKilometerConverter& orig):
      DtUnitConverter(orig)
   {
   };

   DtKilometerConverter& operator=(const DtKilometerConverter& rhs)
   {
      if (this == &rhs)
      {
         return *this;
      }

      DtUnitConverter::operator=(rhs);

      return *this;
   };

   virtual double metersToLocal(double meters) override;

   virtual double localToMeters(double local) override;
};

class DT_DLL_simulationObjectEditorimpl DtFeetConverter : public DtUnitConverter
{

public:

   DtFeetConverter()
   {
   };

   virtual ~DtFeetConverter() override {
   };

   DtFeetConverter(const DtFeetConverter& orig):
      DtUnitConverter(orig)
   {
   };

   DtFeetConverter& operator=(const DtFeetConverter& rhs)
   {
      if (this == &rhs)
      {
         return *this;
      }

      DtUnitConverter::operator=(rhs);

      return *this;
   };

   virtual double metersToLocal(double meters) override;

   virtual double localToMeters(double local) override;
};

class DT_DLL_simulationObjectEditorimpl DtMileConverter : public DtUnitConverter
{

public:

   DtMileConverter()
   {
   };

   virtual ~DtMileConverter() override {
   };

   DtMileConverter(const DtMileConverter& orig):
      DtUnitConverter(orig)
   {
   };

   DtMileConverter& operator=(const DtMileConverter& rhs)
   {
      if (this == &rhs)
      {
         return *this;
      }

      DtUnitConverter::operator=(rhs);

      return *this;
   };

   virtual double metersToLocal(double meters) override;

   virtual double localToMeters(double local) override;
};

class DT_DLL_simulationObjectEditorimpl DtNauticalMileConverter : public DtUnitConverter
{

public:

   DtNauticalMileConverter()
   {
   };

   virtual ~DtNauticalMileConverter() override {
   };

   DtNauticalMileConverter(const DtNauticalMileConverter& orig):
      DtUnitConverter(orig)
   {
   };

   DtNauticalMileConverter& operator=(const DtNauticalMileConverter& rhs)
   {
      if (this == &rhs)
      {
         return *this;
      }

      DtUnitConverter::operator=(rhs);

      return *this;
   };

   virtual double metersToLocal(double meters) override;

   virtual double localToMeters(double local) override;
};

class DT_DLL_simulationObjectEditorimpl DtConverterClass
{
public:
   DtConverterClass() : myFcn(0), myReverse(false) {};
   DtConverterClass(DtConverterFcn fcn, bool reverse) :
      myFcn(fcn), myReverse(reverse) {};
   DtConverterClass(const DtConverterClass& orig) :
      myFcn(orig.myFcn), myReverse(orig.myReverse) {};

   DtConverterFcn myFcn;
   bool myReverse;
};

class DT_DLL_simulationObjectEditorimpl DtUnit
{
public:
   DtUnit();
   DtUnit(const QString& m, const QString& t);
   DtUnit(const DtUnit&);
   DtUnit& operator=(const DtUnit&);

   virtual QString stringRep() const;

   bool operator==(const DtUnit& rhs) const { return ((myMeasurement == rhs.myMeasurement) && (myTime == rhs.myTime)); };
   bool operator!=(const DtUnit& rhs) const { return !(*this == rhs); };

   const QString& measurement() const { return myMeasurement; };
   const QString& time() const { return myTime; };

   bool isValid() const { return (myMeasurement.length() || myTime.length()); };

public:
   static QString measurementTitle(const DtUnit& u);
   static void registerMeasurementTitle(const QString& m, const QString& t, const QString& v);

   static QString unitDisplayTitle(const QString& u);
   static void registerUnitDisplayTitle(const QString& m, const QString& t);

   static QString unitForDisplayTitle(const QString&);

   static const QHash<QString, QString>& unitDisplayTitles();

protected:
   QString     myMeasurement;
   QString     myTime;
   static QHash<QString, QHash<QString, QString> > theMeasurementTitles;
   static QHash<QString, QString> theUnitTitles;
};

class DT_DLL_simulationObjectEditorimpl DtConverter
{
public:
   DtConverter(bool reverse);

   virtual double convert(double, bool reverse = false) const { return 0; };

   bool reverse() const { return myReverse; };

protected:
   bool myReverse;
};

class DT_DLL_simulationObjectEditorimpl DtMetersToMiles : public DtConverter
{
public:
   DtMetersToMiles(bool);
   virtual double convert(double, bool reverse = false) const override;

   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtLitersToGallons : public DtConverter
{
public:
   DtLitersToGallons(bool);
   virtual double convert(double, bool reverse = false) const override;

   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtLitersToQuarts : public DtConverter
{
public:
   DtLitersToQuarts(bool);
   virtual double convert(double, bool reverse = false) const override;

   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtLitersToCubicMeters : public DtConverter
{
public:
   DtLitersToCubicMeters(bool);
   virtual double convert(double, bool reverse = false) const override;

   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtRatioToPercent : public DtConverter
{
public:
   DtRatioToPercent(bool);
   virtual double convert(double, bool reverse = false) const override;

   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtMetersToFeet : public DtConverter
{
public:
   DtMetersToFeet(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtMetersToKilometers : public DtConverter
{
public:
   DtMetersToKilometers(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtMetersToNauticalMiles: public DtConverter
{
public:
   DtMetersToNauticalMiles(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtRadiansToDegrees : public DtConverter
{
public:
   DtRadiansToDegrees(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtRadiansToMils : public DtConverter
{
public:
   DtRadiansToMils(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtMinutesToHours : public DtConverter
{
public:
   DtMinutesToHours(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtSecondsToMinutes : public DtConverter
{
public:
   DtSecondsToMinutes(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtHoursToDays : public DtConverter
{
public:
   DtHoursToDays(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};


class DT_DLL_simulationObjectEditorimpl DtOneToOneConverter : public DtConverter
{
public:
   DtOneToOneConverter(bool);
   virtual double convert(double, bool reverse = false) const override;
   static DtConverter* create(bool);
};

class DT_DLL_simulationObjectEditorimpl DtUnitConverterFactory : public makVrv::DtVirtualBaseClass
{
public:
   enum DtConversionType
   {
       DtConvertMeasurement,
       DtConvertTime
   };

public:
   DtUnitConverterFactory(makVrv::DtDe&);
   
   virtual ~DtUnitConverterFactory() override;

public:
   virtual void registerUnitConversion(const QString& from, const QString& to, DtConverterFcn fcn,
               const QString& title = "", const QString& unitTitle = "", bool addTimeUnits = false);

public:
   static DtUnitConverterFactory& instance(makVrv::DtDe&);
   static void registerInstance(makVrv::DtDe&, DtUnitConverterFactory*);

   virtual void registerConversion(const QString& from, const QString& to, DtConverterFcn);

   virtual bool init();

   virtual DtUnit parse(const QString&) const;
   virtual bool canConvert(const DtUnit&, const DtUnit&) const;
   virtual double convert(const DtUnit& from, const DtUnit& to, double val, bool& valid, bool reverse = false) const;
   virtual double convert(DtConversionType, const DtUnit& from, const DtUnit& to, double val, bool& valid,
      bool reverse = false) const;
   virtual double convertReverse(const DtUnit& from, const DtUnit& to, double val, bool& valid) const;
   virtual QList<DtConverter*> conversion(DtConversionType type, const DtUnit& from, const DtUnit& to) const;
   virtual void findPath(DtConversionType type, const DtUnit& from, const DtUnit& to, const QHash<QString, DtConverterClass>&,
      QList<DtConverter*>& path) const;

   virtual double convertSourceToDestination(double val, const QString& source, const QString& destination) const;

   virtual double convertDestinationToSource(double val, const QString& source, const QString& destination) const;

   virtual QString unitTitle(const QString& u) const;

protected:
   virtual void registerConverters();
   virtual void registerConversion(const QString& from, const QString& to, DtConverterFcn, bool);

protected:
   QHash<QString, QHash<QString, DtConverterClass> > myConverters;
   mutable QHash<QString, QList<DtConverter*> > myConversions;
   makVrv::DtDe& myDe;
};