Quantity.h

Go to the documentation of this file.

/* Copyright (C) 2002 - 2009, Bernd Speiser */
/* This file is part of Quantity.

Quantity is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

Quantity 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 General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
*/

#ifndef _Quantity_h
#define _Quantity_h

// Quantity includes
#include "version.h"
#include "Quantity/Unit.h"
#include "Quantity/Dimension.h"
#include "Quantity/QuantityError.h"

//BSUtilities includes
#include "BSUtilities/BSUtilities.h"
#include "BSUtilities/TypeToName.h"
#include "BSUtilities/Conversion.h"

// Loki includes
#include "loki/Singleton.h"

// STL includes
#include <iostream>
#include <string>
#include <cmath>

#include <typeinfo>

// BOOST includes
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/is_abstract.hpp>

namespace quantity {

//  the QuantityTraits template


template<typename Q> struct QuantityTraits;

//  end QuantityTraits template


//
//  Helper classes and structs which store and/or check 
//  specific units or lists of units.
//


template<typename UT, typename UL>
  class UnitPointerBySymbol
  {
    public:
      static unit::Unit<UT> *result (const std::string &symbol)
        {if (UL::Head::Symbol () == symbol)
           return new typename UL::Head;
         else
           return UnitPointerBySymbol<UT, typename UL::Tail>::result 
                                                               (symbol);
        }
  };


template<typename UT>
  class UnitPointerBySymbol<UT, Loki::NullType>
  {
    public:

      static unit::Unit<UT> *result (const std::string &)
        {throw UnitMismatch (); return 0;}
  };


template<typename UL>
  class UnitIndexBySymbol
  {
    public:
      static int index (const std::string &symbol)
        {if (UL::Head::Symbol () == symbol)
           return 0;
         else
           return 
             UnitIndexBySymbol<typename UL::Tail>::index (symbol) + 1;
        }
  };


template<>
  class UnitIndexBySymbol<Loki::NullType>
  {
    public:

      static int index (const std::string &)
        {throw UnitMismatch (); return -1;}
  };


template<typename UL>
  class ListUnitSymbols
  {
    public:

    static std::vector<std::string> & result 
                                (std::vector<std::string> &stringvector)
      {
       stringvector.push_back (UL::Head::Symbol ());
       return ListUnitSymbols<typename UL::Tail>::result (stringvector);
      }
  };


template<>
  class ListUnitSymbols<Loki::NullType>
  {
    public:
    static std::vector<std::string> & result 
                                (std::vector<std::string> &stringvector)
      {
        return stringvector;
      }
  };

template<typename UT, typename UL>
  class AllUnitsTemplate
  {
    private:

      typedef 
           typename unit::CheckUnits<unit::Unit<UT>, UL>::Check Check;

    public:
      typedef UL Units;


      static ::unit::Unit<UT> *unit (const std::string &unitstring)
        {return UnitPointerBySymbol<UT, UL>::result (unitstring);}


      static std::vector<std::string> allsymbols (void)
        {std::vector<std::string> stringvector;
         return ListUnitSymbols<UL>::result (stringvector);
        }
  };


template<typename UT, typename U>
  class DefaultUnitTemplate
  {
    private:

      typedef 
             typename unit::CheckUnit<unit::Unit<UT>, U>::Check Check;

    public:
      typedef U Unit;
  };

template<class U, class TL> struct CheckAgainstAllUnits;


template<typename U, typename Head, typename Tail> 
  struct CheckAgainstAllUnits<U, Loki::Typelist<Head, Tail> >
  {
    typedef 
      typename BSUtilities::IF<BSUtilities::SameType<U, Head>::sameType,
              U, typename CheckAgainstAllUnits<U, Tail>::RET >::RET RET;
  };


template<typename U>
  struct CheckAgainstAllUnits<U, Loki::NullType>
  {
    typedef unit::UnitError<true> RET;
  };
  
//
//  Helper structs which handle dimensions
//


template<bool>
  struct DimensionError;


template<>
  struct DimensionError<false>
    {

       static const bool RET = true;
    };


template<typename Q>
  struct CheckDimensionality
  {
    public: 

      static const bool RET =
        BSUtilities::IF<Q::Dim::IsDimensionless, DimensionError<false>, 
                                       DimensionError<true> >::RET::RET;
  };


template<typename Q1, typename Q2> struct SameDimensioned;

//
//  helper classes for input and output
//


template<bool P> class PrintName;

template<bool P> class PrintSymbol;

class PrintStatus
  {
    private:
      static bool _name;
      static bool _symbol;

    public:

      bool name (void) const {return _name;}

      bool symbol (void) const {return _symbol;}

      template<bool P> friend class PrintName;

      template<bool P> friend class PrintSymbol;
  };

typedef Loki::SingletonHolder<PrintStatus> PrintStatusHolder;

#define PS PrintStatusHolder::Instance()


template<bool P>
  class PrintName
  {

    void set (bool name) const {PrintStatus::_name = name;}


    friend std::ostream & operator<< 
                              (std::ostream &os, const PrintName &print)
           {print.set (P); return os;}
  };


template<bool P>
  class PrintSymbol
  {

    void set (bool symbol) const {PrintStatus::_symbol = symbol;}


    friend std::ostream & operator<< 
                           (std::ostream &os, const PrintSymbol &print)
           {print.set (P); return os;}

  };


template<bool P> class ReadName;


template<bool P> class ReadSymbol;


template<bool P> class ReadEqual;

class ReadStatus
  {
    private:
      static bool _name;

      static bool _symbol;

      static bool _equal;


      static std::string _unit;

    public:

      bool name (void) const {return _name;}


      bool symbol (void) const {return _symbol;}


      bool equal (void) const {return _equal;}


      std::string unit (void) const {return _unit;}

      template<bool P> friend class ReadName;

      template<bool P> friend class ReadSymbol;

      template<bool P> friend class ReadEqual;

      template<class U> friend class ReadUnit;
  };

typedef Loki::SingletonHolder<ReadStatus> ReadStatusHolder;

#define RS ReadStatusHolder::Instance()


template<bool P>
  class ReadName
  {

    void set (bool name) const {ReadStatus::_name = name;}


    friend std::istream & operator>> 
                              (std::istream &is, const ReadName &read)
           {read.set (P); return is;}
  };


template<bool P>
  class ReadSymbol
  {

    void set (bool symbol) const {ReadStatus::_symbol = symbol;}


    friend std::istream & operator>> 
                           (std::istream &is, const ReadSymbol &read)
           {read.set (P); return is;}

  };


template<bool P>
  class ReadEqual
  {

    void set (bool equal) const {ReadStatus::_equal = equal;}


    friend std::istream & operator>> 
                              (std::istream &is, const ReadEqual &read)
           {read.set (P); return is;}

  };


template<typename U>
  class ReadUnit
  {

    void set (std::string unit) const {ReadStatus::_unit = unit;}


    friend std::istream & operator>> 
                           (std::istream &is, const ReadUnit<U> &unit)
           {unit.set (U::Symbol ()); return is;}

  };

typedef Loki::NullType NoUnit;


template<>
  class ReadUnit<NoUnit>
  {

    void set (std::string unit) const {ReadStatus::_unit = unit;}


    friend std::istream & operator>> 
                      (std::istream &is, const ReadUnit<NoUnit> &unit)
           {unit.set (""); return is;}

  };


//
//  the Quantities base class
//


class Quantities
  {
    public:

      static std::string Version (void)
        {return QUANTITIES_VERSION;}


      static std::string version (void) {return Version ();}


      virtual std::string unitsymbol (void) const = 0;


      virtual std::string unitname (void) const = 0;


      virtual bool isDimensionless (void) const = 0;


      virtual ~Quantities (void) {}

  };

//
//  the Quantity base class with helpers
//


template<typename Q, typename ST = double> class Quantity;


  template<typename U, typename ST = double> struct Standard;


  template<typename UL, typename PL, typename ST = double> class CompStd;


  template<typename UT, typename U, typename CULTail, long N, long D, 
                                           typename PTail, typename ST>
    class CompStd<Loki::Typelist<unit::NonPrefixable<UT, U>, CULTail>,
                 Loki::Typelist<BSUtilities::Rational<N, D>, PTail>, ST>
  {
    public:
      static ST ratio (void)
        {return std::pow (Standard<unit::NonPrefixable<UT, U> >::ratio,
          static_cast<double>(N)/static_cast<double>(D)) 
                               * CompStd<CULTail, PTail, ST>::ratio ();}

      static bool exact (void)
        {return (Standard<unit::NonPrefixable<UT, U> >::exact
                             && CompStd<CULTail, PTail, ST>::exact ());}
  };


  template<typename UT, typename U, typename P, typename CULTail, 
                            long N, long D, typename PTail, typename ST>
    class CompStd<Loki::Typelist<unit::Prefixed<
      unit::Prefixable<UT, U>, P>, CULTail>, 
                 Loki::Typelist<BSUtilities::Rational<N, D>, PTail>, ST>
  {
    public:
      static ST ratio (void)
        {return std::pow ((Standard<unit::Prefixable<UT, U> >::ratio 
          * P::Factor), static_cast<double>(N)/static_cast<double>(D)) 
                               * CompStd<CULTail, PTail, ST>::ratio ();}

      static bool exact (void)
        {return (Standard<unit::Prefixable<UT, U> >::exact
                             && CompStd<CULTail, PTail, ST>::exact ());}
  };


  template<typename UT, typename CEL, typename UL, typename CULTail, 
                           long N, long D, typename PTail, typename ST>
    class CompStd<Loki::Typelist<unit::Composed<
      unit::ComposeBase<UT, CEL>, UL>, CULTail>, 
                 Loki::Typelist<BSUtilities::Rational<N, D>, PTail>, ST>
  {
    public:
      static ST ratio (void)
        {return std::pow 
          (Standard<unit::ComposeBase<UT, CEL> >::ratio, 
            static_cast<double>(N)/static_cast<double>(D)) 
                               * CompStd<CULTail, PTail, ST>::ratio ();}
      static bool exact (void)
        {return (Standard<unit::ComposeBase<UT, CEL> >::exact 
                             && CompStd<CULTail, PTail, ST>::exact ());}
  };


  template<typename UT, typename U, long N, long D, typename ST>
    class CompStd<Loki::Typelist<unit::NonPrefixable<UT, U>, 
      Loki::NullType>, Loki::Typelist<BSUtilities::Rational<N, D>, 
                                                    Loki::NullType>, ST>
  {
    public:
      static ST ratio (void) {return std::pow 
        (Standard<unit::NonPrefixable<UT, U> >::ratio, 
                        static_cast<double>(N)/static_cast<double>(D));}

      static bool exact (void)
                 {return Standard<unit::NonPrefixable<UT, U> >::exact;}
  };


  template<typename UT, typename U, typename P, 
                                            long N, long D, typename ST>
    class CompStd<Loki::Typelist<unit::Prefixed<
      unit::Prefixable<UT, U>, P>, Loki::NullType>, 
        Loki::Typelist<BSUtilities::Rational<N, D>, Loki::NullType>, ST>
  {
    public:
      static ST ratio (void) {return std::pow 
        ((Standard<unit::Prefixable<UT, U> >::ratio * P::Factor), 
                        static_cast<double>(N)/static_cast<double>(D));}

      static bool exact (void)
                    {return Standard<unit::Prefixable<UT, U> >::exact;}
  };


  template<typename UT, typename CEL, typename UL, 
                                           long N, long D, typename ST>
    class CompStd<Loki::Typelist<unit::Composed<
      unit::ComposeBase<UT, CEL>, UL>, Loki::NullType>, 
        Loki::Typelist<BSUtilities::Rational<N, D>, Loki::NullType>, ST>
  {
    public:
      static ST ratio (void) {return std::pow 
        (Standard<unit::ComposeBase<UT, CEL> >::ratio, 
                        static_cast<double>(N)/static_cast<double>(D));}

      static bool exact (void)
        {return Standard<unit::ComposeBase<UT, CEL> >::exact;}
  };


  template<typename U, typename ST = double> struct Standardize;


  template<typename UT, typename U, typename ST>
    struct Standardize<unit::NonPrefixable<UT, U>, ST>
    {
      static ST VAL (const ST &value)
        {return value * 
                      Standard<unit::NonPrefixable<UT, U>, ST>::ratio;}

      static bool Exact (void)
              {return Standard<unit::NonPrefixable<UT, U>, ST>::exact;}
    };


  template<typename UT, typename U, typename P, typename ST>
    struct Standardize<unit::Prefixed<unit::Prefixable<UT, U>, P>, ST>
    {
      static ST VAL (const ST &value)
        {return ST (value * P::Factor *
                        Standard<unit::Prefixable<UT, U>, ST>::ratio);}

      static bool Exact (void)
                 {return Standard<unit::Prefixable<UT, U>, ST>::exact;}
    };


  template<typename UT, typename CUL, typename CEL, typename ST>
    struct Standardize<unit::Composed<unit::ComposeBase<UT, CEL>, 
                                                               CUL>, ST>
    {
      static ST VAL (const ST &value)
        {return ST (value * CompStd<CUL, 
          typename unit::ComposeBase<UT, CEL>::Powers::Powers, ST>
            ::ratio () * 
                     Standard<unit::ComposeBase<UT, CEL>, ST>::ratio);}

      static bool Exact (void)
        {return CompStd<CUL, typename 
            unit::ComposeBase<UT, CEL>::Powers::Powers, ST>::exact ();}
    };


  template<typename U, typename ST = double> struct Reverse;


  template<typename UT, typename U, typename ST>
    struct Reverse<unit::NonPrefixable<UT, U>, ST>
    {
      static ST VAL (const ST &value)
          {return value / 
                  Standard<unit::NonPrefixable<UT, U>, ST>::ratio;}

      static bool Exact (void)
              {return Standard<unit::NonPrefixable<UT, U>, ST>::exact;}
    };


  template<typename UT, typename U, typename P, typename ST>
    struct Reverse<unit::Prefixed<unit::Prefixable<UT, U>, P>, ST>
    {
      static ST VAL (const ST &value)
          {return ST (value / (P::Factor *
                       Standard<unit::Prefixable<UT, U>, ST>::ratio));}

      static bool Exact (void)
                 {return Standard<unit::Prefixable<UT, U>, ST>::exact;}
    };


  template<typename UT, typename CUL, typename CEL, typename ST>
    struct Reverse<unit::Composed<unit::ComposeBase<UT, CEL>, CUL>, 
                                                                     ST>
    {
      static ST VAL (const ST &value)
          {return 
            ST (value / (CompStd<CUL, 
            typename unit::ComposeBase<UT, CEL>::Powers::Powers, 
              ST>::ratio () * 
                   Standard<unit::ComposeBase<UT, CEL>, ST>::ratio));}

      static bool Exact (void)
        {return CompStd<CUL, typename 
            unit::ComposeBase<UT, CEL>::Powers::Powers, ST>::exact ();}
    };


  template<typename UL> struct dynamic_standardize;


  template<typename Head, typename Tail>
    struct dynamic_standardize<Loki::Typelist<Head, Tail> >
    {
      template<class U, class ST>
        static ST VAL (const ST &value, const U &unit)
          {Head test = Head ();
           if (typeid(unit) == typeid(test))
             return Standardize<Head, ST>::VAL (value);
           else
             return dynamic_standardize<Tail>::VAL (value, unit);
          }
    };
         

  template<>
    struct dynamic_standardize<Loki::NullType>
    {
      template<class U, class ST>
        static ST VAL (const ST &, const U &)
                         {throw UnitMismatch (); return ST (0);}
    };


  template<typename UL> struct dynamic_reverse;
 

  template<typename Head, typename Tail> 
    struct dynamic_reverse<Loki::Typelist<Head, Tail> >
    {
      template<class U, class ST>
        static ST VAL (const ST &value, const U &unit)
          {Head test = Head ();
           if (typeid(unit) == typeid (test))
             return Reverse<Head, ST>::VAL (value);
           else
             return dynamic_reverse<Tail>::VAL (value, unit);
          }
    };
         

  template<>
    struct dynamic_reverse<Loki::NullType>
    {
      template<class U, class ST>
      static ST VAL (const ST &, const U &)
                          {throw UnitMismatch (); return ST (0);}
    };


template<typename QT, typename ST> class Quantity : public Quantities
  {
    public:
      typedef QT QuantityType;

      typedef typename QuantityTraits<QT>::Dimension Dim;
      typedef typename QuantityTraits<QT>::UnitType UT;
      typedef typename QuantityTraits<QT>::UnitList UL;
      typedef typename QuantityTraits<QT>::DefaultUnit DU;
      typedef typename QuantityTraits<QT>::DefaultDerivedQuantityType DDQ;

    private:
      static const bool Dimensionless = Dim::IsDimensionless;

      typedef Quantity<QT, ST> Q;

    protected:

      std::string namestring;

      std::string symbolstring;


      unit::Unit<UT> * findBySymbol (const std::string &unitsymbol)
         {return UnitPointerBySymbol<UT, UL>::result (unitsymbol);}


   template<typename U>
     static ST standard (const ST value, const U&)
       {return Standardize<typename CheckAgainstAllUnits<U, UL>::RET, 
                                                       ST> (value);}


   template<typename U>
     static ST reverse (const ST value, const U& unit)
       {return Reverse<typename CheckAgainstAllUnits<U, UL>::RET, ST> 
                                                            (value);}

    public:
      Quantity (void)  {}


      virtual ~Quantity (void) {}


      typedef AllUnitsTemplate<UT, UL> AllUnits;


      typedef DefaultUnitTemplate<UT, DU> DefaultUnit;

      typedef ST StorageType;


      virtual void name (const std::string &name) {namestring = name;}


      virtual void symbol (const std::string &symbol) {symbolstring = symbol;}


      virtual std::string name (void) const {return namestring;}


      virtual std::string symbol (void) const {return symbolstring;}


      virtual ST standard_value (void) const = 0;


      virtual ST value (void) const = 0;


      static bool IsDimensionless (void) {return Dimensionless;}


      bool isDimensionless (void) const {return IsDimensionless ();}


      friend std::ostream & operator<< 
                            (std::ostream &os, const Quantity &quantity)
             {return quantity.print (os);}


      std::ostream & print (std::ostream &os) const
        {
          std::string nameFragment (""); 
          std::string symbolFragment ("");
          std::string equal ("");

          if (PS.name ())
            nameFragment = name () + " ";

          if (PS.symbol ())
            symbolFragment = symbol () + " ";

          if (PS.name () || PS.symbol ())
            equal = "= ";

          os << nameFragment << symbolFragment << equal;

          return print_value (os);
        }


      virtual std::ostream & print_value (std::ostream &os) const = 0;

      friend void operator<< 
        (std::string &str, const Quantity &quantity) {quantity >> str;}

      virtual void operator>> (std::string &str) const = 0;


      operator std::string () const 
        {std::string string; *this >> string; return string;}


      virtual std::ostream & operator>> (std::ostream &os) const = 0;

//  serialization of Quantity

      friend class boost::serialization::access;


  private:
    template<typename Archive>
      void serialize (Archive &ar, const unsigned int )
      {
        ar & BOOST_SERIALIZATION_NVP(namestring);
        ar & BOOST_SERIALIZATION_NVP(symbolstring);
      }

  };

//  end serialization of Quantity

//  helper structures, classes, and functions which use the 
//  Quantity template


template<typename QT1, typename ST1, typename QT2, typename ST2>
  struct SameDimensioned<Quantity<QT1, ST1>, Quantity<QT2, ST2> >
  {
    enum {EQ = QuantityTraits<QT1>::Dimension::template Equal<
                            typename QuantityTraits<QT2>::Dimension>::EQ};
  };

//  end helper structures, classes, and functions which use the 
//  Quantity template

//  the DerivedQuantityTraits template


template<typename Q, typename DQ> struct DerivedQuantityTraits;

//  end DerivedQuantityTraits template

template<typename QT, typename SU = typename QuantityTraits<QT>::DefaultUnit,
  typename DQT = typename QuantityTraits<QT>::DefaultDerivedQuantityType>
struct DerivedQuantity
{
   static const bool OverwriteName = DerivedQuantityTraits<QT, DQT>::OverwriteName;
   static const bool OverwriteSymbol = DerivedQuantityTraits<QT, DQT>::OverwriteSymbol;
};

//
//  forward declarations
//


template<typename Q1, typename Q2> struct convertValue;


}

#endif /* _Quantity_h */

---