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

// Quantity includes
#include "Quantities/Quantity/Unit.h"
#include "Quantities/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;

      static const bool Exact;

      static const double StandardFactor;

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

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

      static bool IsExact (void) {return Exact;}

      bool isExact (void) const {return IsExact ();}

      static double Factor (void) {return StandardFactor;}

      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 bool 
  NonPrefixable<GenericUnitBase<DIM>, GenericUnit>::Exact = true;

template<typename DIM> const double 
  NonPrefixable<GenericUnitBase<DIM>, GenericUnit>::StandardFactor = 1.0;

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> >
  {
    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 (void) {return "";}


    static const std::string SymbolString (void) {return "";}

  };


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

      typedef typename QuantityTraits<GenericClass<DIM> >::Dimension Dim;
      typedef typename QuantityTraits<GenericClass<DIM> >::UnitType UT;
      typedef typename QuantityTraits<GenericClass<DIM> >::UnitList UL;


      typedef typename unit::ValidUnit<typename 
               QuantityTraits<GenericClass<DIM> >::DefaultUnit, UL>::RET 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;

    public:
      Quantity (void) 
        : namestring (QuantityTraits<GenericClass<Dim> >::NameString ()), 
          symbolstring (QuantityTraits<GenericClass<Dim> 
                                                      >::SymbolString ()) {}

      virtual ~Quantity (void) {}

      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 unit::Reverse<SU>::VAL 
                            (unit::Standard<SSU>::VAL (quantity.value ()));}
  };

} // end namespace quantity

#endif /* _Generic_h */

---