Generic.h

Go to the documentation of this file.

/* 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 _Generic_h
#define _Generic_h

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

namespace quantity {

/* the Generic quantity */


template<class DIM> struct GenericClass {};

}

namespace unit {

class GenericUnit;

//
//  the Generic Unit
//


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

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

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

      static const std::string Namestring;

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

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

      static const std::string Symbolstring;

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

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

      void save (BSUtilities::xmlw::XmlStream &os) const
      {
        os << BSUtilities::xmlw::tag (Units::TAG)
           << BSUtilities::xmlw::attr (Units::TYPETAG) << TYPE
// to be added ...
        << BSUtilities::xmlw::endtag (Units::TAG);
      }


      static const std::string TYPE;

  };

template<class DIM> const bool 
  NonPrefixable<quantity::GenericClass<DIM>, GenericUnit>::SI = false;

template<class DIM> const 
  std::string 
    NonPrefixable<quantity::GenericClass<DIM>, GenericUnit>
                                                      ::Namestring = "";

template<class DIM> const 
  std::string 
    NonPrefixable<quantity::GenericClass<DIM>, GenericUnit>
                                      ::Symbolstring = "(unknown unit)";

template<class DIM>
  const std::string NonPrefixable<quantity::GenericClass<DIM>, 
                                         GenericUnit>::TYPE = "generic";

}

namespace quantity {

//
//  the Generic Quantity
//

template<class DIM, class UL, class DU, class ST>
              struct Name<Quantity<DIM, GenericClass<DIM>, UL, DU, ST> >
  {
    static const std::string String;
  };

template<class DIM, class UL, class DU, class ST>
  const std::string 
       Name<Quantity<DIM, GenericClass<DIM>, UL, DU, ST> >::String = "";

template<class DIM, class UL, class DU, class ST>
            struct Symbol<Quantity<DIM, GenericClass<DIM>, UL, DU, ST> >
  {
    static const std::string String;
  };

template<class DIM, class UL, class DU, class ST>
  const std::string 
     Symbol<Quantity<DIM, GenericClass<DIM>, UL, DU, ST> >::String = "";

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

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

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

}

#endif /* _Generic_h */

---