Quantity.h

Go to the documentation of this file.

/* Copyright (C) 2002 - 2010, 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 "Quantities/version.h"
#include "Quantities/Quantity/Unit.h"
#include "Quantities/Quantity/Dimension.h"
#include "Quantities/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 {

//
//  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;
  };

//
//  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 QuantityTraits template
//


template<typename T> struct QuantityTraits;

//
//  the Quantity base class
//


template<typename T, typename ST = double> class Quantity
  {
    public:
      typedef T QT;

      typedef typename QuantityTraits<QT>::Dimension Dim;

      typedef typename QuantityTraits<QT>::UnitType UT;

      typedef typename QuantityTraits<QT>::UnitList UL;


      typedef typename unit::ValidUnit<typename 
                         QuantityTraits<QT>::DefaultUnit, UL>::RET DU;

      typedef typename QuantityTraits<QT>::DefaultDerivedQuantityType DDQ;

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

      typedef Quantity<T, ST> Q;

    protected:

      std::string namestring;

      std::string symbolstring;

    public:
      Quantity (void)  {}


      virtual ~Quantity (void) {}


      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 ();}


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


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


      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);
      }

  };

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


template<typename Q1, typename Q2> struct SameDimensioned;


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 */

---