Unit.h

Go to the documentation of this file.

/* Unit is an abstract base class for units according to the SI, see
   Mills et al., 1993 */

/* Copyright (C) 2002 - 2005, 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 _Unit_h
#define _Unit_h

#include <vector>
#include <string>

#include "Quantity/Prefix.h"

#include "NullType.h"
#include "EmptyType.h"
#include "TypeManip.h"
#include "Typelist.h"

#include "BSUtilities.h"
#include "TemplateTools.h"
#include "Conversion.h"

#include "xmlwriter.h"

#include <tinyxml/tinyxml.h>


namespace unit {

//
//  Helper classes and structs which check that units are derived
//  from certain base classes 
//


template<bool> 
  struct UnitError;


template<class BU, class TU>
  struct CheckUnit
  {

    typedef typename
      BSUtilities::IF<Loki::SuperSubclass<BU, TU>::value, 
                                       TU, UnitError<true> >::RET Check;
  };


template<class BU, class TUL>
  struct CheckUnits
  {
    private: 
      typedef 
            typename CheckUnit<BU, typename TUL::Head>::Check UnitCheck;

    public: 
       typedef typename CheckUnits<BU, typename TUL::Tail>::Check Check;
  };


template<class BU>
  struct CheckUnits<BU, Loki::NullType>
  {
    typedef Loki::EmptyType Check;
  };

//
//  the Units and Unit base class templates
//

class Units
  {
    public:

      static const std::string Version (void)
        {static const std::string v_string ("Units version 1.2");
                                                       return v_string;}


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


  static const std::string TAG;


  static const std::string TYPETAG;

  };


template<class BT> class Unit : public Units
  {
    public:

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


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


      virtual const bool isSI (void) const = 0;

      virtual ~Unit () {}

  };

//
//  the NonPrefixable units
//


template<class BT, class U> 
  class NonPrefixable : public Unit<BT>
  {
    private:
      static const bool SI;


      static const std::string Namestring;


      static const std::string Symbolstring;

    public:

      static const bool IsSI (void) {return SI;}


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

/*  direct static access to be used if type of unit is known at 
    compile time; returns the namestring;
    must not be a static const data member, since similar functions
    in other cases of units require access to possibly not yet defined
    static data.
*/
      static const std::string Name (void) {return Namestring;}


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

/*  direct static access to be used if type of unit is known at 
    compile time; 
    must not be a static const data member, since similar functions
    in other cases of units require access to possibly not yet defined
    static data.
*/
      static const std::string Symbol (void) {return Symbolstring;}


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

  };

//
//  the Prefixable and Prefixed units
//

// forward declaration
template<class BT, class U> class Prefixable;


template<class BP, class UP = No> class Prefixed;


template<class BT, class U, class UP> 
  class Prefixed<Prefixable<BT, U>, UP> : public Prefixable<BT, U>
  {
    public:
/*  direct static access to be used if type of unit is known at 
    compile time; 
    get name from prefix and prepend to basename which is inherited
    from Prefixable<BT, U>;
    must not be a static const data member, since similar functions
    in other cases of units require access to possibly not yet defined
    static data.
*/
      static const std::string Name (void) 
                      {return UP::Name + Prefixable<BT, U>::Basename;}


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

/*  direct static access to be used if type of unit is known at 
    compile time; 
    get symbol from prefix and prepend to basesymbol which is inherited
    from Prefixable<BT, U>
    must not be a static const data member, since similar functions
    in other cases of units require access to possibly not yet defined
    static data.
*/
      static const std::string Symbol (void) 
                  {return UP::Symbol + Prefixable<BT, U>::Basesymbol;}


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

  };


template<class BT, class U> class Prefixable : public Unit<BT>
  {
    private:

      static const bool SI;

    public:
      typedef Loki::Typelist<Prefixed<Prefixable<BT, U>, Yotta>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Zetta>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Exa>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Peta>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Tera>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Giga>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Mega>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Kilo>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Hecto>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Deca>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, No>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Deci>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Centi>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Milli>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Micro>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Nano>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Pico>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Femto>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Atto>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Zepto>, 
              Loki::Typelist<Prefixed<Prefixable<BT, U>, Yocto>, 
              Loki::NullType> > > > > > > > > > > > > > > > > > > > > 
                                                                  Units;


      static const bool IsSI (void) {return SI;}


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

    protected:
/*  direct static access to be used if type of unit is known at 
    compile time 
*/
      static const std::string Basename;

/*  direct static access to be used if type of unit is known at 
    compile time 
*/
      static const std::string Basesymbol;

  };

//
//  the ComposeBase and Composed units with helper classes and structs
//  ComposeElement, ComposedSI, ComposedStrings
//

template<class BT, class CEL> class ComposeBase;


template<class BC, class CUL> class Composed;


template<class BT, class UL, class R> struct ComposeElement;


template<class BT, class BT1, class U, class UTail, long N, long D>
  struct 
    ComposeElement<BT, Loki::Typelist<NonPrefixable<BT1, U>, UTail>,
                                           BSUtilities::Rational<N, D> >
  {
    private:
      typedef typename CheckUnits<Unit<BT1>, 
            Loki::Typelist<NonPrefixable<BT1, U>, UTail> >::Check Check;

    public:
      typedef Loki::Typelist<NonPrefixable<BT1, U>, UTail> Units;
      typedef BSUtilities::Rational<N, D> Power;
  };


template<class BT, class BT1, class U, class UP, class UTail, 
                                                         long N, long D>
  struct ComposeElement<BT,
    Loki::Typelist<Prefixed<Prefixable<BT1, U>, UP>, UTail>, 
                                           BSUtilities::Rational<N, D> >
  {
    private:
      typedef typename CheckUnits<Unit<BT1>, 
            Loki::Typelist<Prefixed<Prefixable<BT1, U>, UP>, UTail> >
                                                          ::Check Check;

    public:
      typedef Loki::Typelist<Prefixed<Prefixable<BT1, U>, UP>, UTail>
                                                                  Units;
      typedef BSUtilities::Rational<N, D> Power;
  };


template<class BT, class BT1, class CEL, class CUL, 
                                            class UTail, long N, long D>
  struct ComposeElement<BT,
    Loki::Typelist<Composed<ComposeBase<BT1, CEL>, CUL>, UTail>, 
                                           BSUtilities::Rational<N, D> >
  {
    private:
      typedef typename CheckUnits<Unit<BT1>, 
        Loki::Typelist<Composed<ComposeBase<BT1, CEL>, CUL>, UTail> >
                                                          ::Check Check;

    public:
      typedef Loki::Typelist<Composed<ComposeBase<BT1, CEL>, CUL>, 
                                                           UTail> Units;
      typedef BSUtilities::Rational<N, D> Power;
  };


template<class UL> struct ComposedSI;


template<class U, class UTail>
  struct ComposedSI<Loki::Typelist<U, UTail> >
  {
    static const bool isSI (void) 
        {return ((U::IsSI () && ComposedSI<UTail>::isSI ()) ? 1 : 0);}

  };
  
template<>
  struct ComposedSI<Loki::NullType>
  {
    static const bool isSI (void) {return true;}
  };


template<class UL, class RL> struct ComposedStrings;


template<class U, class UTail, long N, long D, class RTail>
  struct ComposedStrings<Loki::Typelist<U, UTail>, 
                    Loki::Typelist<BSUtilities::Rational<N, D>, RTail> >
  {
      static const std::string Name (void)
        {return U::Name ()
          + "^(" + BSUtilities::Conversion<long>::to_string(N) 
              + "/" + BSUtilities::Conversion<long>::to_string(D) + ")"
                              + ComposedStrings<UTail, RTail>::Name ();}

      static const std::string Symbol (void)
        {return U::Symbol ()
          + "^(" + BSUtilities::Conversion<long>::to_string(N) 
              + "/" + BSUtilities::Conversion<long>::to_string(D) + ")"
                            + ComposedStrings<UTail, RTail>::Symbol ();}
  };


template<class U, class UTail, long N, class RTail>
  struct ComposedStrings<Loki::Typelist<U, UTail>, 
                   Loki::Typelist<BSUtilities::Rational<N, 1L>, RTail> >
  {
      static const std::string Name (void)
        {return U::Name ()
          + "^" + BSUtilities::Conversion<long>::to_string(N) 
                              + ComposedStrings<UTail, RTail>::Name ();}

      static const std::string Symbol (void)
        {return U::Symbol ()
          + "^" + BSUtilities::Conversion<long>::to_string(N) + " "
                            + ComposedStrings<UTail, RTail>::Symbol ();}
  };


template<class U, class UTail, class RTail>
  struct ComposedStrings<Loki::Typelist<U, UTail>, 
                  Loki::Typelist<BSUtilities::Rational<1L, 1L>, RTail> >
  {
      static const std::string Name (void)
        {return U::Name () + ComposedStrings<UTail, RTail>::Name ();}

      static const std::string Symbol (void)
        {return U::Symbol () + " "
                            + ComposedStrings<UTail, RTail>::Symbol ();}
  };


template<class U, long N, long D>
  struct ComposedStrings<Loki::Typelist<U, Loki::NullType>, 
           Loki::Typelist<BSUtilities::Rational<N, D>, Loki::NullType> >
  {
      static const std::string Name (void)
       {return U::Name ()
         + "^(" + BSUtilities::Conversion<long>::to_string(N) 
             + "/" + BSUtilities::Conversion<long>::to_string(D) + ")";}

      static const std::string Symbol (void)
       {return U::Symbol ()
         + "^(" + BSUtilities::Conversion<long>::to_string(N) 
             + "/" + BSUtilities::Conversion<long>::to_string(D) + ")";}
  };


template<class U, long N>
  struct ComposedStrings<Loki::Typelist<U, Loki::NullType>, 
              Loki::Typelist<BSUtilities::Rational<N>, Loki::NullType> >
  {
      static const std::string Name (void)
       {return U::Name ()
         + "^" + BSUtilities::Conversion<long>::to_string(N);}

      static const std::string Symbol (void)
       {return U::Symbol ()
         + "^" + BSUtilities::Conversion<long>::to_string(N);}
  };


template<class BT, class CEL, class UL>
  class Composed<ComposeBase<BT, CEL>, UL> : public ComposeBase<BT, CEL>
  {
    private:
      typedef Composed<ComposeBase<BT, CEL>, UL> Unit;
      typedef typename ComposeBase<BT, CEL>::Powers::Powers Powers;

    public:
/*  static access
*/
      static const bool IsSI (void) {return ComposedSI<UL>::isSI ();}


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

/*  direct static access to be used if type of unit is known at 
    compile time;
    must not be a static const data member, since it requires access
    to the name values of the individual elementary units; they may 
    not be available yet when they are needed here.
*/
        static const std::string Name (void)
                          {return ComposedStrings<UL, Powers>::Name ();}


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

/*  direct static access to be used if type of unit is known at 
    compile time;
    must not be a static const data member, since it requires access
    to the symbol values of the individual elementary units; they may 
    not be available yet when they are needed here.
*/
        static const std::string Symbol (void)
                        {return ComposedStrings<UL, Powers>::Symbol ();}


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

  };


template<class UL, class CUL> struct GenComposedList;


template<class U, class UTail>
  struct GenComposedList<Loki::Typelist<U, UTail>, Loki::NullType>
  {
      typedef 
        Loki::Typelist<Loki::Typelist<U, Loki::NullType>,
            typename GenComposedList<UTail, Loki::NullType>::List> List;
  };


template<>
  struct GenComposedList<Loki::NullType, Loki::NullType>
  {
    typedef Loki::NullType List;
  };


template<class U1, class U, class UTail, class CULTail>
  struct GenComposedList<U1, 
                     Loki::Typelist<Loki::Typelist<U, UTail>, CULTail> >
  {
     typedef Loki::Typelist<Loki::Typelist<U1, 
        Loki::Typelist<U, UTail> >, 
                      typename GenComposedList<U1, CULTail>::List> List;
  };


template<class U>
  struct GenComposedList<U, Loki::NullType>
  {
      typedef Loki::NullType List;
  };


template<class U1, class U, class UTail, class U1Tail, class CULTail>
  struct GenComposedList<Loki::Typelist<U1, U1Tail>,
                     Loki::Typelist<Loki::Typelist<U, UTail>, CULTail> >
  {
      typedef typename BSUtilities::Concatenate<typename 
        GenComposedList<U1, 
          Loki::Typelist<Loki::Typelist<U, UTail>, CULTail> >::List,
            typename GenComposedList<U1Tail, 
              Loki::Typelist<Loki::Typelist<U, UTail>, CULTail> 
                                                  >::List>::Result List;
  };


template<class U, class UTail, class CULTail>
  struct GenComposedList<Loki::NullType, 
                     Loki::Typelist<Loki::Typelist<U, UTail>, CULTail> >
  {
      typedef Loki::NullType List;
  };


template<class CEL> struct ExpandComposeElementList;


template<class CELHead, class CELTail>
  struct ExpandComposeElementList<Loki::Typelist<CELHead, CELTail> >
  {
      typedef typename GenComposedList<typename CELHead::Units,
           typename ExpandComposeElementList<CELTail>::List>::List List;
  };


template<>
  struct ExpandComposeElementList<Loki::NullType>
  {
      typedef Loki::NullType List;
  };


template<class BC, class CUL> struct GenComposedUnits;


template<class BT, class CEL, class CULHead, class CULTail>
  struct GenComposedUnits<ComposeBase<BT, CEL>, 
                                    Loki::Typelist<CULHead, CULTail> >
  {
      typedef Loki::Typelist<Composed<ComposeBase<BT, CEL>, CULHead>,
        typename GenComposedUnits<ComposeBase<BT, CEL>, 
                                                   CULTail>::List> List;
  };
          

template<class BT, class CEL>
  struct GenComposedUnits<ComposeBase<BT, CEL>, Loki::NullType>
  {
      typedef Loki::NullType List;
  };


template<class CEL> struct GenPowers;


template<class CELHead, class CELTail>
  struct GenPowers<Loki::Typelist<CELHead, CELTail> >
  {
    typedef Loki::Typelist<typename CELHead::Power, 
                            typename GenPowers<CELTail>::Powers> Powers;
  };


template<class CE>
  struct GenPowers<Loki::Typelist<CE, Loki::NullType> >
  {
    typedef Loki::Typelist<typename CE::Power, Loki::NullType> Powers;
  };

          
//
//  template ComposeBase
//  a unit compounded from one or more base units
//


template<class BT, class UHead, class UTail, 
                                 long N, long D, class ELTail>
  class ComposeBase<BT, Loki::Typelist<ComposeElement<BT, 
        Loki::Typelist<UHead, UTail>, BSUtilities::Rational<N, D> >, 
                                             ELTail> > : public Unit<BT>
  {
    private:
      typedef 
        Loki::Typelist<ComposeElement<BT, Loki::Typelist<UHead, UTail>,
                     BSUtilities::Rational<N, D> >, ELTail> ElementList;

    public:
      typedef GenPowers<ElementList> Powers;

      typedef typename 
        GenComposedUnits<ComposeBase<BT, ElementList>, typename
               ExpandComposeElementList<ElementList>::List>::List Units;
  };

}

#endif /* _Unit_h */

---