ReferencedVariable.h

Go to the documentation of this file.

/* Copyright (C) 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 _ReferencedVariable_h
#define _ReferencedVariable_h

#include "Quantity/Quantity.h"
#include "Quantity/Generic.h"

namespace Quantities {

//
//  the ReferencedVariable classes
//


template<class PQ, class SU = typename PQ::DefaultUnit::Unit>
  class ReferencedVariable;


template<class GT, class Head, class Tail, class DU, class SU, class ST>
  class ReferencedVariable<Quantity<GT, Loki::Typelist<Head, Tail>, 
                                                            DU, ST>, SU>
    : public 
          Variable<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>, SU>

    {
      private:
        typedef 
          Variable<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>, 
                                                                  SU> V;

        typedef Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> Q;

        ST reference_value;

      public:

        ReferencedVariable (void) 
          : V (ST(0.0)), reference_value (ST(0.0)) {}


        ReferencedVariable (const ST new_value) : V (new_value) {}


        ReferencedVariable (const ST new_value, const ST new_reference)
          : V (new_value - new_reference), 
                                      reference_value (new_reference) {}


        template<class NU>
          ReferencedVariable 
                (const ST new_value, const ST new_reference, const NU &)
            {
              variable_value = V::Unit::Reverse 
                (CheckAgainstAllUnits<NU, Loki::Typelist<Head, Tail> >
                           ::RET::Standard (new_value - new_reference));
              reference_value 
                      = V::Unit::Reverse (NU::Standard (new_reference));
            }


       template<template<class, class> class QR, class GTR, class HeadR,
                           class TailR, class DUR, class SUR, class STR>
         ReferencedVariable (const ST new_value, 
           const QR<Quantity<GTR, Loki::Typelist<HeadR, TailR>, 
                                        DUR, STR>, SUR> & new_reference)
           {
             typedef 
               QR<Quantity<GTR, Loki::Typelist<HeadR, TailR>, DUR, STR>,
                                                                 SUR> Q;
cout << "in constructor" << endl;
             reference_value 
               = V::Unit::Reverse (CheckAgainstAllUnits<typename 
                 CheckSecondDimension<ReferencedVariable, Q>::RET::Unit,
                   typename Loki::TL::Append<Loki::Typelist<Head, Tail>,
                     Units::NonPrefixable<typename Q::Type, 
                       Units::GenericUnit, ST> >::Result>::RET::Standard
                                          (new_reference.value ()));
             variable_value = new_value - reference_value;
           }

// other constructors?
// e.g., with two units NVU, NRU for variable and reference values


        ReferencedVariable (const ReferencedVariable &new_variable)
          : V (new_variable.variable_value), 
                          reference_value (new_variable.reference_value)
            {
              namestring = new_variable.namestring;
              symbolstring = new_variable.symbolstring;
            };

// conversion ?


        void reference (const ST new_reference)
          {variable_value 
            = variable_value + reference_value - new_reference; 
                                        reference_value = new_reference;
          }


        template<class NU>
          void reference (const ST new_reference, const NU &)
            {variable_value = variable_value + reference_value;
             reference_value = V::Unit::Reverse 
               (CheckAgainstAllUnits<NU, Loki::Typelist<Head, Tail> >
                                       ::RET::Standard (new_reference));
             variable_value -= reference_value;
            }


        ST reference (void) {return reference_value;}


        template<class NU>
          ST reference (const NU &) 
            {return CheckAgainstAllUnits<NU, Loki::Typelist<Head, Tail>
                 >::RET::Reverse (V::Unit::Standard (reference_value));}

/*  assignment is to an already existing referenced variable, thus
    the value which is assigned to the existing object is referenced
    after the assignment is done to the reference value of the object
    assigned to; other explanations, see Variable.h.
*/
        template<template<class, class> class Q1, class GT1, 
          class Head1, class Tail1, class DU1, class SU1, class ST1>
            ReferencedVariable & operator=
              (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, 
                                          DU1, ST1>, SU1> &new_variable)
             {
               void *this_pointer = this;
               const void *new_pointer = &new_variable;

               if (this_pointer != new_pointer)
               {
                 typedef Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>,
                                                      DU1, ST1>, SU1> Q;
                 variable_value = V::Unit::Reverse
                   (CheckAgainstAllUnits<typename
                     CheckSecondDimension<ReferencedVariable, Q>
                                                            ::RET::Unit,
                       typename Loki::TL::Append<
                         Loki::Typelist<Head, Tail>,
                           Units::NonPrefixable<typename Q::Type, 
                             Units::GenericUnit, ST> >::Result 
                               >::RET::Standard
                                 (new_variable.value ())) 
                                                      - reference_value;
               }
               return *this;
             }

/*  assignment is to an already existing referenced variable, thus
    the value which is assigned to the existing object is referenced
    after the assignment is done to the reference value of the object
    assigned to; other explanations, see Variable.h
*/
        ReferencedVariable & operator=
                                (const ReferencedVariable &new_variable)
        {
          if (this != &new_variable)
            {variable_value = 
                            new_variable.value () - reference_value;
            }
          return *this;
        }


        ST value (void) const 
                              {return variable_value + reference_value;}


        ST refvalue (void) const {return variable_value;}


        template<class NU>
          ST value (const NU &) const
            {return CheckAgainstAllUnits<NU,
              Loki::Typelist<Head, Tail> >::RET::Reverse
                                  (V::Unit::Standard (variable_value));}


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


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


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


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

    };

}

#endif /* _ReferencedVariable_h */

---