ReferencedVariable.h

Go to the documentation of this file.

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

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

namespace quantity {

//
//  the ReferencedVariable classes
//


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


template<class BT, class DIM, class UL, class DU, class SU, class ST>
  class ReferencedVariable<Quantity<DIM, BT, UL, DU, ST>, SU>
                    : public Variable<Quantity<DIM, BT, UL, DU, ST>, SU>

    {
      private:
        typedef Variable<Quantity<DIM, BT, UL, DU, ST>, SU> V;

        typedef Quantity<DIM, BT, UL, 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 = Reverse<typename V::Unit>::VAL
                (Standardize<typename
                  CheckAgainstAllUnits<NU, UL>
                               ::RET>::VAL (new_value - new_reference));
              reference_value 
                = Reverse<typename V::Unit>::VAL (Standardize<NU>::VAL
                                                       (new_reference));
            }


       template<template<class, class> class QR, class BTR, class DIMR,
                           class ULR, class DUR, class SUR, class STR>
         ReferencedVariable (const ST new_value, 
           const QR<Quantity<DIMR, BTR, ULR, DUR, STR>, SUR> 
                                                        & new_reference)
           {
             typedef 
               QR<Quantity<DIMR, BTR, ULR, DUR, STR>, SUR> Q;
             reference_value 
               = Reverse<typename V::Unit>::VAL 
                 (Standardize<typename CheckAgainstAllUnits<typename 
                   CheckSecondDimension<ReferencedVariable, Q>
                                                            ::RET::Unit,
                     typename 
                       Loki::TL::Append<UL, unit::NonPrefixable<BTR, 
                         unit::GenericUnit> >::Result>::RET>::VAL
                                              (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 = Reverse<typename V::Unit>::VAL
               (Standardize<typename
                 CheckAgainstAllUnits<NU, UL>::RET>::VAL 
                                                       (new_reference));
             variable_value -= reference_value;
            }


        ST reference (void) {return reference_value;}


        template<class NU>
          ST reference (const NU &) 
            {return Reverse<typename
              CheckAgainstAllUnits<NU, UL>::RET>::VAL 
                (Standardize<typename V::Unit>::VAL (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 BT1, class DIM1,
                             class UL1, class DU1, class SU1, class ST1>
            ReferencedVariable & operator=
              (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST1>, SU1> 
                                                          &new_variable)
             {
               void *this_pointer = this;
               const void *new_pointer = &new_variable;

               if (this_pointer != new_pointer)
               {
                 typedef Q1<Quantity<DIM1, BT1, UL1, DU1, ST1>, SU1> Q;
                 variable_value = Reverse<typename V::Unit>::VAL
                   (Standardize<typename CheckAgainstAllUnits<typename
                       CheckSecondDimension<ReferencedVariable, Q>
                                                            ::RET::Unit,
                         typename Loki::TL::Append<UL,
                             unit::NonPrefixable<BT1, 
                               unit::GenericUnit> >::Result>::RET>::VAL
                                 (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 
              Reverse<typename CheckAgainstAllUnits<NU, UL>::RET>::VAL
                 (Standardize<typename V::Unit>::VAL (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 */

---