QuantityCluster.h

Go to the documentation of this file.

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

#include "Quantity/Quantity.h"

#include "HierarchyGenerators.h"

#include <vector>

namespace Quantities {

//
//  Helper classes and structs for vectors
//


class QuantityVectorOutOfBounds {};

//
//  the QuantityVector abstract base class
//


template<class Q> class QuantityVector;


template<class GT, class Head, class Tail, class DU, class ST>
  class 
       QuantityVector<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> >
  {
    private:
      typedef Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST> Q;
  };

//
//  the VariableVector 
//


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


template<class GT, class Head, class Tail, class DU, class SU, class ST>
  class 
    VariableVector<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>, SU>
      : public 
        QuantityVector<Quantity<GT, 
                                   Loki::Typelist<Head, Tail>, DU, ST> >
  {
    private:
      typedef typename 
               Units::CheckUnit<Units::Unit<GT, ST>, SU>::Check Checked;

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

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

      typedef SU Unit;

    protected:
      std::vector<ST> values;

    public:
      VariableVector (void) {}


    template<class NU>
      VariableVector (const VariableVector<PQ, NU> &new_vector) 
      {
        SU unit;
        int length = new_vector.length ();
        values.reserve (length);

        for (int i = 0; i < length; i++)
          values.push_back (new_vector[i].value (unit));
      }


      int length (void) const {return values.size ();}


      template<template<class, class> class Q1, class GT1, class Head1, 
                           class Tail1, class DU1, class SU1, class ST1>
        void add (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, 
                                          DU1, ST1>, SU1> &new_quantity)
          {values.push_back (SU::Reverse
            (CheckAgainstAllUnits<typename Q1<Quantity<GT1,
                    Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1>::Unit,
              typename Loki::TL::Append<Loki::Typelist<Head, Tail>,
                Units::NonPrefixable<typename Q1<Quantity<GT1,
                  Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1>::Type,
                    Units::GenericUnit, ST> >::Result >::RET::Standard 
                                         (new_quantity.value ())));}


      template<template<class, class> class Q1, class GT1, class Head1, 
                           class Tail1, class DU1, class SU1, class ST1>
        void add (const Q1<Quantity<GT1, Loki::Typelist<Head1, Tail1>, 
                         DU1, ST1>, SU1> &new_quantity, const int index)
          {if (index >= 0 && index < length ())
            {typename std::vector<ST>::iterator pos 
                                              = values.begin () + index;
              values.insert (pos, SU::Reverse
                (CheckAgainstAllUnits<typename Q1<Quantity<GT1,
                    Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1>::Unit,
                typename Loki::TL::Append<Loki::Typelist<Head, Tail>,
                  Units::NonPrefixable<typename Q1<Quantity<GT1,
                    Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1>::Type,
                      Units::GenericUnit, ST> >::Result >::RET::Standard
                                         (new_quantity.value ())));
            }
          else
            {throw QuantityVectorOutOfBounds();}
        }                                                    


      template<template<class, class> class Q1, class GT1, class Head1, 
                           class Tail1, class DU1, class SU1, class ST1>
        void replace (const Q1<Quantity<GT1, 
          Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1> 
                                         &new_quantity, const int index)
          {if (index >= 0 && index < length ())
            {values[index] = SU::Reverse
                (CheckAgainstAllUnits<typename Q1<Quantity<GT1,
                    Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1>::Unit,
                typename Loki::TL::Append<Loki::Typelist<Head, Tail>,
                  Units::NonPrefixable<typename Q1<Quantity<GT1,
                    Loki::Typelist<Head1, Tail1>, DU1, ST1>, SU1>::Type,
                      Units::GenericUnit, ST> >::Result >::RET::Standard
                                           (new_quantity.value ()));
            }
          else
            {throw QuantityVectorOutOfBounds();}
        }                                                    


    void remove (const int index)
    {
      if (index >= 0 && index < length ())
      {
        typename std::vector<ST>::iterator pos 
                                              = values.begin () + index;
        values.erase (pos);
      }
      else
      {throw QuantityVectorOutOfBounds();}
    }                                                    

    void clear (void) {values.clear ();}


      V value (const int index) const
        {if (index >= 0 && index < length ())
          {return V (values[index]);}
         else
          {throw QuantityVectorOutOfBounds();}
        }                                                    


      V operator[] (const int index) const {return value (index);}


      template<class NU>
        Variable<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>, NU> 
          value (const int index, const NU &unit) const
                                        {return (value (index))(unit);}


      V max (void) const
        {
          ST max_val = values[0];
          typename std::vector<ST>::const_iterator index;

          for (index = values.begin (); index < values.end (); index++)
            max_val = ((max_val < *index) ? *index : max_val);
          
          return V (max_val);
        }


      template<class NU>
        Variable<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>, NU> 
                    max (const NU &unit) const {return (max ()) (unit);}


      V min (void) const
        {
          ST min_val = values[0];
          typename std::vector<ST>::const_iterator index;

          for (index = values.begin (); index < values.end (); index++)
            min_val = ((min_val < *index) ? min_val : *index);
          
          return V (min_val);
        }


      template<class NU>
        Variable<Quantity<GT, Loki::Typelist<Head, Tail>, DU, ST>, NU> 
                    min (const NU &unit) const {return (min ()) (unit);}

  };


template<class L> class VariableVectorTuple;

//
//  helper classes and structs for the VariableVector tuples
//


template<class TL> struct GetVar;


template<class Head, class Tail>
  struct GetVar<Loki::Typelist<Head, Tail> >
{
  private:
    typedef typename GetVar<Tail>::Result L1;

  public:
    typedef Loki::Typelist<typename Head::V, L1> Result;
};


template<>
  struct GetVar<Loki::NullType>
{
  typedef Loki::NullType Result;
};


template<int N, class L>
  class AddVal
  {
    public:
      static void addval (VariableVectorTuple<L> &tuple, 
        const typename VariableVectorTuple<L>::VariableTuple 
                                                            &new_values)
        {Loki::Field<N-1>(tuple.vectors).add 
                                         (Loki::Field<N-1>(new_values));
         AddVal<N-1, L>::addval (tuple, new_values);
        }

      static void addval (VariableVectorTuple<L> &tuple, 
        const typename VariableVectorTuple<L>::VariableTuple 
                                     &new_values, const int index)
        {Loki::Field<N-1>(tuple.vectors).add 
                                  (Loki::Field<N-1>(new_values), index);
         AddVal<N-1, L>::addval (tuple, new_values, index);
        }
  };


template<class L>
  class AddVal<0, L>
  {
    public:
      static void addval (VariableVectorTuple<L> &,
             const typename VariableVectorTuple<L>::VariableTuple &) {};

      static void addval (VariableVectorTuple<L> &,
        const typename VariableVectorTuple<L>::VariableTuple &, 
                                                          const int) {};
  };


template<int N, class L>
  class RemVal
  {
    public:
      static void remval (VariableVectorTuple<L> &tuple, 
                                                        const int index)
        {Loki::Field<N-1>(tuple.vectors).remove (index);
         RemVal<N-1, L>::remval (tuple, index);
        }
  };


template<class L>
  class RemVal<0, L>
  {
    public:
      static void remval (VariableVectorTuple<L> &, const int) {};
  };


template<int N, class L>
  class GetVal
  {
    public:
      static typename VariableVectorTuple<L>::VariableTuple getval 
        (const VariableVectorTuple<L> &tuple,
          typename VariableVectorTuple<L>::VariableTuple 
                                               &values, const int index)
        {Loki::Field<N-1>(values) 
                               = Loki::Field<N-1>(tuple.vectors)[index];
         return GetVal<N-1, L>::getval (tuple, values, index);
        }
  };


template<class L>
  class GetVal<0, L>
  {
    public:
      static typename VariableVectorTuple<L>::VariableTuple getval 
        (const VariableVectorTuple<L> &,
          typename VariableVectorTuple<L>::VariableTuple 
                              &values, const int) {return values;}
  };

//
//  the VariableVector tuple
//


template<class LHead, class LTail>
  class VariableVectorTuple<Loki::Typelist<LHead, LTail> >
  {
  private:
    typedef Loki::Typelist<LHead, LTail> L;

    Loki::Tuple<L> vectors;

  public:

    typedef Loki::Tuple<typename GetVar<L>::Result> VariableTuple;

    int number (void) {return Loki::TL::Length<L>::value;}

/*  all vectors have the same length, return value determined from
    first vector.
*/
    int length (void) {return Loki::Field<0>(vectors).length ();}


/*  uses data from a VariableTuple; uses helper class AddVal.
*/
    void add (const VariableTuple &new_values)
    {
      AddVal<Loki::TL::Length<L>::value, L>::addval (*this, new_values);
    }

/*  uses data from a VariableTuple; uses helper class AddVal.
*/
    void add (const VariableTuple &new_values, const int index)
    {
      AddVal<Loki::TL::Length<L>::value, L>::addval 
                                             (*this, new_values, index);
    }


    void remove (const int index)
    {
      RemVal<Loki::TL::Length<L>::value, L>::remval (*this, index);
    }


    template<int I>
      typename Loki::TL::TypeAt<L, I>::Result::V 
                                           value (const int index) const
                      {return (Loki::Field<I>((*this).vectors))[index];}


    template<int I, class NU>
      Variable<typename Loki::TL::TypeAt<L, I>::Result::V::PQ, NU> 
        value (const int index, const NU &unit) const
          {return 
               ((Loki::Field<I>((*this).vectors)).value (index))(unit);}


    VariableTuple operator[] (const int index) const
    {
      VariableTuple values;
      return GetVal<Loki::TL::Length<L>::value, L>::getval 
                                                 (*this, values, index);
    }


    VariableTuple values (const int index) const
                                                {return (*this)[index];}

    template<int N, class L1> friend class AddVal;
     
    template<int N, class L1> friend class GetVal;
     
    template<int N, class L1> friend class RemVal;
     
    template<int N, class L1> friend class Copy;
     
    template<int N, class L1> friend class Assign;
     
  };

}

#endif /* _QuantityCluster */

---