Generic.h

Go to the documentation of this file.

/* Copyright (C) 2002 - 2004, 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

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

namespace Quantities {

/* the Generic quantity */


template<class GT> 
  struct GenericClass 
  {

    typedef typename GT::DimTL DimTL;
  };

}

namespace Units {

class GenericUnit;

//
//  the Generic Unit
//


template<class GT, class ST> 
  class NonPrefixable<Quantities::GenericClass<GT>, GenericUnit, ST> 
                            : public Unit<Quantities::GenericClass<GT> >
  {
    public:
      static const bool is_SI;

      static const bool is_exact;

      static ST Standard (const ST &value);

      ST standard (const ST &value) {return Standard (value);}

      static ST Reverse (const ST &value);

      ST reverse (const ST &value) {return Reverse (value);}

      static const std::string Namestring;

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

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

      static const std::string Symbolstring;

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

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

template<class GT, class ST> inline ST 
  NonPrefixable<Quantities::GenericClass<GT>, GenericUnit, ST>::Standard
                                       (const ST &value) {return value;}

template<class GT, class ST> inline ST 
  NonPrefixable<Quantities::GenericClass<GT>, GenericUnit, ST>::Reverse 
                                       (const ST &value) {return value;}

template<class GT, class ST> const bool 
  NonPrefixable<Quantities::GenericClass<GT>, GenericUnit, 
                                                   ST>::is_exact = true;

template<class GT, class ST> const bool 
  NonPrefixable<Quantities::GenericClass<GT>, GenericUnit, 
                                                     ST>::is_SI = false;

template<class GT, class ST> const 
  std::string 
    NonPrefixable<Quantities::GenericClass<GT>, GenericUnit, 
                                                   ST>::Namestring = "";

template<class GT, class ST> const 
  std::string 
    NonPrefixable<Quantities::GenericClass<GT>, GenericUnit, 
                                   ST>::Symbolstring = "(unknown unit)";
}

namespace Quantities {

//
//  the Generic Quantity
//

template<class GT, class Head, class Tail, class DU, class ST>
  struct Name<Quantity<GenericClass<GT>, Loki::Typelist<Head, Tail>, 
                                                               DU, ST> >
  {
    static const std::string String;
  };

template<class GT, class Head, class Tail, class DU, class ST>
  const std::string 
    Name<Quantity<GenericClass<GT>, Loki::Typelist<Head, Tail>, DU, ST> 
                                                         >::String = "";

template<class GT, class Head, class Tail, class DU, class ST>
  struct Symbol<Quantity<GenericClass<GT>, Loki::Typelist<Head, Tail>, 
                                                               DU, ST> >
  {
    static const std::string String;
  };

template<class GT, class Head, class Tail, class DU, class ST>
  const std::string 
    Symbol<Quantity<GenericClass<GT>, Loki::Typelist<Head, Tail>, DU, 
                                                     ST> >::String = "";
}

#endif /* _Generic_h */

---