UnitSystemsManager.h

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Math Library
 * Module     : UnitSystemsManager
 * Package    : Zeus.ZeusMath.System
 * Author     : Martin Abbuehl
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 of the License, or (at your option) any later version.              *
 *                                                                           *
 *   This library 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 Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef UnitSystemsManagerH
#define UnitSystemsManagerH

#include <zeusmath/Config/PlatformDefines.hpp>
#include <zeusmath/System/Interfaces/IUnitSystemsManager.hpp>
#include <zeusbase/System/ZObject.h>

// Managersyntax.
#define UnitSystemsManager NAMESPACE_Zeus::TUnitSystemsManager::getInstance()

enum EUnit
{
  etNoUnit                         =  0, // Nummerieren für Javascripts.
  etDistance_mm                    =  1,
  etSpeed_m_per_s                  =  2,
  etSpeed_mm_per_min               =  3,
  etRevolutions_per_min            =  4,
  etTime_s                         =  5,
  etTime_min                       =  6,
  etDegrees360                     =  7,
  etDegrees360_per_min             =  8,
  etVolumePerLength_mm3_per_mm     =  9,
  etVolume_mm3                     = 10,
  etVolumePerTime_mm3_per_s        = 11,
  etForce_Newton                   = 12,
  etTime_h                         = 13,
  etSpeed_mm_per_revolutions       = 14,
  etVolumePerTime_mm3_per_h        = 15,
  etQsw_mm3_per_mm_per_s           = 16,
  etAcceleration_mm_per_s2         = 17, //covert to foot
  etAcceleration_m_per_s2          = 18, //covert to foot
  etPercent                        = 19,
  etAcceleration_Degrees360_per_s2 = 20,
  etAcceleration_mm_per_s2_to_inch = 21, //covert to inch
  etNumberOfUnits
};

BEGIN_NAMESPACE_Zeus

/******************************************************************************/
/******************************************************************************/
zeusmath_class TUnitSystemsManager : public TZObject, public IUnitSystemsManager
{
  public:
    static inline TUnitSystemsManager& getInstance() { return m_Instance; }
    void setDelegationInterface(IUnitSystemsManager& rManager);
    void releaseDelegationInterface();

    /*************************************************************************/
    /*************************************************************************/
    inline EUnitSystem MQUALIFIER getUnitSystem() const
    {
      EUnitSystem eRetval = m_eUnitSystem;

      if (m_ptrDelegation != NULL)
      {
        eRetval = m_ptrDelegation->getUnitSystem();
      } // m_ptrDelegation != NULL.

      return eRetval;
    }

    /*************************************************************************/
    /*************************************************************************/
    inline void MQUALIFIER setUnitSystem(EUnitSystem eUnitSystem)
    {
      m_eUnitSystem = eUnitSystem;
      if (m_ptrDelegation != NULL)
      {
        m_ptrDelegation->setUnitSystem(eUnitSystem);
      }
    }

    //Methods of IZUnknown
    MEMORY_MANAGER_DECL

    TString getUnitText(EUnit eUnit) const;

    static TString getUnitTextMetric(EUnit eUnit);

    static TString getUnitTextInch(EUnit eUnit);

    Float getConversionFactorToMetric(EUnit eUnit) const;

    Float getConversionFactorFromMetric(EUnit eUnit) const;

    void convertToMetric(Float& fValue, EUnit eUnit,
                         bool bRound, bool bExcludeZero = false) const;

    void convertFromMetric(Float& fValue, EUnit eUnit,
                           bool bRound, bool bExcludeZero = false) const;

    Float getConversionToMetric(const Float& fValue, EUnit eUnit,
                                bool bRound, bool bExcludeZero = false) const;

    Float getConversionFromMetric(const Float& fValue, EUnit eUnit,
                                  bool bRound, bool bExcludeZero = false) const;

    static void round(Float& fValue, const Float& fRoundingStep, bool bExcludeZero);

    void round(Float& rfValue, bool bExcludeZero = false);

    static Int getStandardRoundingDigits(EUnitSystem eUnitSystem);
    
    inline Int getStandardRoundingDigits() const { return getStandardRoundingDigits(getUnitSystem()); }

    static Float getStandardRoundingStep(EUnitSystem eUnitSystem);

    inline Float getStandardRoundingStep() const { return getStandardRoundingStep(getUnitSystem()); }

    static TString getStandardRoundingFormat(EUnitSystem eUnitSystem);

    inline TString getStandardRoundingFormat() const { return getStandardRoundingFormat(getUnitSystem()); }

    #define INVERSE(Method) Float(1) / Method()

    // Length.    
    static inline Float mm_per_m()         { return 1000; }
    static inline Float m_per_mm()         { return INVERSE(mm_per_m); }
    static inline Float um_per_mm()        { return 1000; }
    static inline Float mm_per_um()        { return INVERSE(um_per_mm); }
    static inline Float mm_per_inch()      { return 25.4; }
    static inline Float inch_per_mm()      { return INVERSE(mm_per_inch); }
    static inline Float inch_per_foot()    { return 12; }
    static inline Float foot_per_inch()    { return INVERSE(inch_per_foot); }
    static inline Float mm_per_foot()      { return mm_per_inch() * inch_per_foot(); }
    static inline Float foot_per_mm()      { return INVERSE(mm_per_foot); }
    static inline Float m_per_foot()       { return m_per_mm() * mm_per_foot(); }
    static inline Float foot_per_m()       { return INVERSE(m_per_foot); }
    // Area.
    static inline Float mm2_per_inch2()    { return TMath::pow(mm_per_inch(), 2); }
    static inline Float inch2_per_mm2()    { return INVERSE(mm2_per_inch2); }
    // Volume.
    static inline Float mm3_per_inch3()    { return TMath::pow(mm_per_inch(), 3); }
    static inline Float inch3_per_mm3()    { return INVERSE(mm3_per_inch3); }
    // Time.
    static inline Float s_per_min()        { return 60; }
    static inline Float min_per_s()        { return INVERSE(s_per_min); }
    // Mass.
    static inline Float gram_per_kilo()    { return 1000; }
    static inline Float kilo_per_gram()    { return INVERSE(gram_per_kilo); }
    static inline Float gram_per_ounce()   { return 28.349523125; } // From: http://de.wikipedia.org/wiki/Unze#Definition_und_Umrechnung.
    static inline Float ounce_per_gram()   { return INVERSE(gram_per_ounce); }
    static inline Float ounce_per_pound()  { return 16; } // From http://de.wikipedia.org/wiki/Pfund#Umrechnung.
    static inline Float pound_per_ounce()  { return INVERSE(ounce_per_pound); }
    static inline Float gram_per_pound()   { return gram_per_ounce() * ounce_per_pound(); }
    static inline Float pound_per_gram()   { return INVERSE(gram_per_pound); }
    static inline Float kilo_per_pound()   { return kilo_per_gram() * gram_per_pound(); }
    static inline Float pound_per_kilo()   { return INVERSE(kilo_per_pound); }
    // Force.
    static inline Float earthGravity_ms2() { return 9.80665; }
    static inline Float newton_per_kilo()  { return earthGravity_ms2(); }
    static inline Float kilo_per_newton()  { return INVERSE(newton_per_kilo); }
    static inline Float newton_per_pound() { return newton_per_kilo() * kilo_per_pound(); }
    static inline Float pound_per_newton() { return INVERSE(newton_per_pound); }

  private:
    TUnitSystemsManager();

  private:
    static TUnitSystemsManager m_Instance;
    TAutoPtr<IUnitSystemsManager> m_ptrDelegation;

    EUnitSystem m_eUnitSystem;
};

//INLINES
/****************************************************************************/
/****************************************************************************/
inline TUnitSystemsManager::TUnitSystemsManager()
{
  m_eUnitSystem = etUndefinedUnitSystem;
}

/****************************************************************************/
/****************************************************************************/
inline void TUnitSystemsManager::releaseDelegationInterface()
{
  m_ptrDelegation.release();
}

/****************************************************************************/
/****************************************************************************/
inline Float TUnitSystemsManager::getConversionFactorFromMetric(EUnit eUnit) const
{
  return Float(1) / getConversionFactorToMetric(eUnit);
}

/****************************************************************************/
/****************************************************************************/
inline Float TUnitSystemsManager::getConversionToMetric(const Float& fValue, EUnit eUnit,
                                                        bool bRound, bool bExcludeZero /* = false */) const
{
  Float fRetval = fValue;
  convertToMetric(fRetval, eUnit, bRound, bExcludeZero);
  return fRetval;
}

/****************************************************************************/
/****************************************************************************/
inline Float TUnitSystemsManager::getConversionFromMetric(const Float& fValue, EUnit eUnit,
                                                          bool bRound, bool bExcludeZero /* = false */) const
{
  Float fRetval = fValue;
  convertFromMetric(fRetval, eUnit, bRound, bExcludeZero);
  return fRetval;
}

END_NAMESPACE_Zeus

#endif