Generic.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 _Generic_h
#define _Generic_h

// Quantity includes
#include "Quantity/Unit.h"
#include "Quantity/Quantity.h"

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

// STL includes
#include <string>

namespace quantity {

/* the Generic quantity */


template<typename DIM> struct GenericClass;

template<typename DIM> struct DerivedGenericClass;

} // end namespace quantity

namespace unit {


template<typename DIM> struct GenericUnitBase;

class GenericUnit;

//
//  the Generic Unit
//


template<typename DIM> 
  class NonPrefixable<GenericUnitBase<DIM>, GenericUnit> 
                           : public Unit<GenericUnitBase<DIM> >
  {
    private:
      static const bool SI;

   public:
      static bool IsSI (void) {return SI;}

      bool isSI (void) const {return IsSI ();}

      static const std::string Namestring;

      static std::string Name (void) {return Namestring;}

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

      static const std::string Symbolstring;

      static std::string Symbol (void) {return Symbolstring;}

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

  };

template<typename DIM> const bool 
  NonPrefixable<GenericUnitBase<DIM>, GenericUnit>::SI = false;

template<typename DIM> const 
  std::string 
    NonPrefixable<GenericUnitBase<DIM>, GenericUnit> ::Namestring = "";

template<typename DIM> const 
  std::string 
    NonPrefixable<GenericUnitBase<DIM>, GenericUnit>
                                      ::Symbolstring = "(unknown unit)";

} // end namespace unit

namespace quantity {

//
//  the Generic Quantity
// 

template<typename DIM, typename ST>
  struct Standard<unit::NonPrefixable<unit::GenericUnitBase<DIM>, 
                                                 unit::GenericUnit>, ST>
  {
    static const ST ratio;
    static const bool exact;
  };

template<typename DIM, typename ST>
  const ST
    Standard<unit::NonPrefixable<unit::GenericUnitBase<DIM>, 
                               unit::GenericUnit>, ST>::ratio = ST(1.0);

template<typename DIM, typename ST>
  const bool
    Standard<unit::NonPrefixable<unit::GenericUnitBase<DIM>, 
                                  unit::GenericUnit>, ST>::exact = true;

template<typename DIM>
  struct DerivedQuantityTraits<GenericClass<DIM>, DerivedGenericClass<DIM> >
  {
    typedef unit::NonPrefixable<unit::GenericUnitBase<DIM>, unit::GenericUnit> StorageUnit;

    static const bool OverwriteName = false;
    static const bool OverwriteSymbol = false;

    static const std::string NameString;
    static const std::string SymbolString;

  };


template<typename DIM> struct QuantityTraits<GenericClass<DIM> > 
  {
    typedef DIM Dimension;
    typedef unit::GenericUnitBase<DIM> UnitType;
    typedef Loki::Typelist<unit::NonPrefixable<unit::GenericUnitBase<DIM>, 
                                   unit::GenericUnit>, Loki::NullType> UnitList;
    typedef unit::NonPrefixable<unit::GenericUnitBase<DIM>, unit::GenericUnit> DefaultUnit;

    typedef DerivedGenericClass<DIM> DefaultDerivedQuantityType;

    static const std::string NameString;
    static const std::string SymbolString;
  };

template<typename DIM> const std::string QuantityTraits<GenericClass<DIM> >::NameString = "";
template<typename DIM> const std::string QuantityTraits<GenericClass<DIM> >::SymbolString = "";


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

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

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

      typedef Quantity<GenericClass<DIM>, ST> Q;

    protected:
      std::string namestring;
      std::string symbolstring;

      unit::Unit<GenericClass<Dim> > * 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) 
        : namestring (QuantityTraits<GenericClass<Dim> >::NameString), 
          symbolstring (QuantityTraits<GenericClass<Dim> >::SymbolString) 
                                                                              {}

      virtual ~Quantity (void) {}

      typedef AllUnitsTemplate<GenericClass<Dim>, UL> AllUnits;

      typedef DefaultUnitTemplate<GenericClass<Dim>, DU> DefaultUnit;

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

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

      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 name (""); 
          std::string symbol ("");
          std::string equal ("");

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

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

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

          os << name << symbol << 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;


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

  };


template<template<typename, typename> class M, typename DIM, typename ST, typename SU, typename DQT,
     template<typename, typename> class SM, typename SQT, typename SST, typename SSU, typename SDQT>
  struct convertValue<M<Quantity<GenericClass<DIM>, ST>, DerivedQuantity<GenericClass<DIM>, SU, DQT> >, 
                     SM<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > >
  {
    static ST exec (const typename BSUtilities::IF<SameDimensioned<M<Quantity<GenericClass<DIM>, ST>, 
      DerivedQuantity<GenericClass<DIM>, SU, DQT> >,
        SM<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > >::EQ, 
          SM<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> >, DimensionError<true> >::RET 
                                                                                    & quantity)
      {return Reverse<SU, ST>::VAL (Standardize<SSU, SST>::VAL (quantity.value ()));}
  };

} // end namespace quantity

#endif /* _Generic_h */

---