QuantityCluster.h

Go to the documentation of this file.

/* Copyright (C) 2003 - 2009, 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

// Quantity includes
#include "Quantity/Quantity.h"

// Loki includes
#include "loki/HierarchyGenerators.h"

// STL includes
#include <vector>

// BOOST includes
#include <boost/serialization/vector.hpp>
#include <boost/serialization/base_object.hpp>

namespace quantity {

//
//  the Vector base class
//


template<typename Q> class Vector;


template<typename QT, typename ST> class Vector<Quantity<QT, ST> >
  {
    private:
      typedef Quantity<QT, ST> BQ;

    public:
      virtual int size (void) const = 0;

      virtual ~Vector (void) {}

      friend class boost::serialization::access;


  private:
      template<typename Archive>
        void serialize (Archive &ar, const unsigned int ) 
        {
        }

  };

//
//  the QuantityVector 
//


template<template<typename, typename> class M, typename BQ, 
  typename DQ = DerivedQuantity<typename BQ::QuantityType, typename BQ::DU, typename BQ::DDQ> > 
    class QuantityVector;


template<template<typename, typename> class M, typename QT, typename ST, typename SU, typename DQT> 
  class QuantityVector<M, Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > 
    : public Vector<Quantity<QT, ST> >
  {
      private:
//  typedef M<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > Q;


        typedef typename QuantityTraits<QT>::Dimension DIM;


      typedef typename QuantityTraits<QT>::UnitType UT;


      typedef typename QuantityTraits<QT>::UnitList UL;


      typedef typename QuantityTraits<QT>::DefaultUnit DU;


        typedef Quantity<QT, ST> BQ;

      typedef Vector<Quantity<QT, ST> > VEC;

    public:

      typedef M<BQ, DerivedQuantity<QT, SU, DQT> > V;


  typedef QuantityVector<M, BQ, DerivedQuantity<QT, SU, DQT> > QV;


      typedef ST StorageType;

      typedef typename unit::CheckUnit<unit::Unit<UT>, SU>::Check StorageUnit;

    private:
      std::vector<ST> _values;

    public:
      QuantityVector (void) {}


/*
    template<class NU>
      QuantityVector (const QuantityVector<M, BQ, NU> &new_vector) 
      {
        typename DerivedQuantityTraits<QT, DQT>::StorageUnit unit;
        int size = new_vector.size ();
        _values.reserve (size);

        for (int i = 0; i < size; i++)
          _values.push_back (new_vector[i].value (unit));
      }
*/


      QuantityVector & operator= (const QuantityVector &new_vector)
      {
        if (this != &new_vector)
        {
          VEC::operator= (new_vector);
          _values = new_vector._values;
        }       

        return *this;
      }


    template<typename SSU, typename SDQT>
      QuantityVector & operator= (const QuantityVector<M, BQ, DerivedQuantity<QT, SSU, SDQT> > &new_vector)
      {
        VEC::operator= (new_vector);

        int size = new_vector.size ();

        _values.empty ();

        _values.reserve (size);

        for (int i = 0; i < size; i++)
          _values.push_back(Reverse<StorageUnit, typename BQ::StorageType>::VAL 
           (Standardize<SSU, typename BQ::StorageType>::VAL (new_vector[i].value ())));

        return *this;
      }


      bool operator== (const QV &vector) const
      {
        return ((size () == vector.size ()) 
                                          && (_values == vector._values));
      }


      int size (void) const {return _values.size ();}


      template<template<typename, typename> class Q1, typename QT1, 
                                             typename ST1, typename SSU, typename SDQT> 
        void push_back (const Q1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SSU, SDQT> > &new_quantity)
          {_values.push_back (Reverse<StorageUnit, ST>::VAL
            (Standardize<typename
              CheckAgainstAllUnits<typename Q1<Quantity<QT1, ST1>, 
                DerivedQuantity<QT1, SSU, SDQT> >::StorageUnit, typename Loki::TL::Append<UL, 
                  unit::NonPrefixable<unit::GenericUnitBase<DIM>, unit::GenericUnit> 
                     >::Result >::RET, ST>::VAL (new_quantity.value ())));}


      template<template<typename, typename> class Q1, typename QT1, 
                                                typename ST1, typename SSU, typename SDQT> 
        void insert (const Q1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SSU, SDQT> > &new_quantity, 
                                                         const int index)
          {if (index >= 0 && index < size ())
            {typename std::vector<ST>::iterator pos 
                                             = _values.begin () + index;
              _values.insert (pos, Reverse<StorageUnit, ST>::VAL
                (Standardize<typename
                   CheckAgainstAllUnits<typename Q1<Quantity<QT1, ST1>, 
                     DerivedQuantity<QT1, SSU, SDQT> >::StorageUnit,
                  typename Loki::TL::Append<UL,
                    unit::NonPrefixable<unit::GenericUnitBase<DIM>, 
                        unit::GenericUnit> >::Result >::RET, ST>::VAL
                                              (new_quantity.value ())));
            }
          else
            {throw VectorOutOfBounds();}
        }                                                    


      template<template<typename, typename> class Q1, typename QT1, 
                                            typename ST1, typename SSU, typename SDQT>
        void replace 
          (const Q1<Quantity<QT1, ST1>, DerivedQuantity<QT1, SSU, SDQT> > &new_quantity, 
                                                                        const int index)
          {if (index >= 0 && index < size ())
            {_values[index] = Reverse<StorageUnit, ST>::VAL
              (Standardize<typename
                CheckAgainstAllUnits<typename Q1<Quantity<QT1, ST1>, 
                  DerivedQuantity<QT1, SSU, SDQT> >::StorageUnit,
                typename Loki::TL::Append<UL,
                  unit::NonPrefixable<unit::GenericUnitBase<DIM>,
                      unit::GenericUnit> >::Result >::RET, ST>::VAL
                                               (new_quantity.value ()));
            }
          else
            {throw VectorOutOfBounds();}
        }                                                    


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

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


    std::vector<ST> values (void) {return _values;}   


      V value (const int index) const
        {if (index >= 0 && index < size ())
          {return V (_values[index]);}
         else
          {throw VectorOutOfBounds();}
        }                                                    


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


      template<typename NU>
        M<Quantity<QT, ST>, DerivedQuantity<QT, NU, DQT> > 
          value (const int index, const NU &) const
            {return M<Quantity<QT, ST>, DerivedQuantity<QT, NU, DQT> > (value (index));}


      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<typename NU>
        M<Quantity<QT, ST>, DQT1> 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>
        M<Quantity<QT, ST>, NU> min (const NU &unit) const 
                                            {return (min ()) (unit);}
*/

 private:
      friend class boost::serialization::access;


      template<typename Archive>
        void serialize (Archive &ar, const unsigned int )
        {
          ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(VEC);
          ar & BOOST_SERIALIZATION_NVP(_values);
        }

  };


template<class L> class QuantityVectorTuple;

//
//  helper classes and structs for the QuantityVector 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 (QuantityVectorTuple<L> &tuple, 
        const typename QuantityVectorTuple<L>::QTuple &new_values)
        {Loki::Field<N-1>(tuple.vectors).push_back 
                                         (Loki::Field<N-1>(new_values));
         AddVal<N-1, L>::addval (tuple, new_values);
        }

      static void addval (QuantityVectorTuple<L> &tuple, 
        const typename QuantityVectorTuple<L>::QTuple 
                                     &new_values, const int index)
        {Loki::Field<N-1>(tuple.vectors).insert 
                                  (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 (QuantityVectorTuple<L> &,
             const typename QuantityVectorTuple<L>::QTuple &) {};

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


template<int N, class L>
  class EraVal
  {
    public:
      static void eraval (QuantityVectorTuple<L> &tuple, 
                                                        const int index)
        {Loki::Field<N-1>(tuple.vectors).erase (index);
         EraVal<N-1, L>::eraval (tuple, index);
        }
  };


template<class L>
  class EraVal<0, L>
  {
    public:
      static void eraval (QuantityVectorTuple<L> &, const int) {};
  };


template<int N, class L>
  class GetVal
  {
    public:
      static typename QuantityVectorTuple<L>::QTuple getval 
        (const QuantityVectorTuple<L> &tuple,
          typename QuantityVectorTuple<L>::QTuple 
                                               &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 QuantityVectorTuple<L>::QTuple getval 
        (const QuantityVectorTuple<L> &,
          typename QuantityVectorTuple<L>::QTuple 
                              &values, const int) {return values;}
  };


template<int N, class L>
  class CmpVec
  {
    public:
      static bool cmpVec
        (const QuantityVectorTuple<L> &tuple1, 
                                   const QuantityVectorTuple<L> &tuple2)
      {
        if (Loki::Field<N-1>(tuple1.vectors) 
                                    == Loki::Field<N-1>(tuple2.vectors))
          return CmpVec<N-1, L>::cmpVec (tuple1, tuple2);

        else
          return false;
      }
  };


template<class L>
  class CmpVec<0, L>
  {
    public:
      static bool cmpVec 
        (const QuantityVectorTuple<L> &, const QuantityVectorTuple<L> &)
                                                          {return true;}
  };


template<int N, class L, typename Archive>
  class SaveVec
  {
    public:
      static void saveVec
        (const QuantityVectorTuple<L> &tuple, Archive &ar) 
      {
        SaveVec<N-1,L,Archive>::saveVec (tuple, ar);
        typename Loki::TL::TypeAt<L, N-1>::Result 
                              vec = Loki::Field<N-1>(tuple.vectors);
        ar << BOOST_SERIALIZATION_NVP(vec);
      }
  };


template<class L, typename Archive>
  class SaveVec<0, L, Archive>
  {
    public:
      static void saveVec (const QuantityVectorTuple<L> &, Archive &) {}
  };


template<int N, class L, typename Archive>
  class LoadVec
  {
    public:
      static void loadVec
        (QuantityVectorTuple<L> &tuple, Archive &ar, int &_size) 
      {
        LoadVec<N-1,L,Archive>::loadVec (tuple, ar, _size);
        typename Loki::TL::TypeAt<L, N-1>::Result 
                              vec;
        ar >> BOOST_SERIALIZATION_NVP(vec);
        if (vec.size () == _size)
          Loki::Field<N-1>(tuple.vectors) = vec;
        else
          {throw VectorSizeError("vector has wrong size!");}
      }
  };


template<class L, typename Archive>
  class LoadVec<0, L, Archive>
  {
    public:
      static void loadVec (QuantityVectorTuple<L> &, Archive &, int &) {}
  };

/* primary template
*/
template <class V, class QVT> struct CheckVariableInVectorTuple;


template<template<typename, typename> class T, typename V, typename QT, 
                                typename ST, typename SU, typename LTail>
  struct CheckVariableInVectorTuple<V,
    Loki::Typelist<QuantityVector<T, Quantity <QT, ST>, SU>, LTail> >
  {
    private:
      typedef typename BSUtilities::IF<BSUtilities::SameType<V,
        typename QuantityVector<T, Quantity<QT, ST>, SU>::V>::sameType,
          QuantityVector<T, Quantity<QT, ST>, SU>,
           typename CheckVariableInVectorTuple<V, LTail>::RET>::RET RET;
  };


template<typename V>
  struct CheckVariableInVectorTuple<V, Loki::NullType>
  {
    typedef VariableError<true> RET;
  };

//
//  the QuantityVector tuple
//


template<template<typename, typename> class T, typename QT,
                             typename ST, typename SU, typename LTail>
  class QuantityVectorTuple<Loki::Typelist<
      QuantityVector<T, Quantity<QT, ST>, SU>, LTail> >
  {
  private:
    typedef Loki::Typelist<QuantityVector<T, Quantity<QT, ST>, SU>, LTail> L;

    typedef QuantityVectorTuple<L> QVT;

    Loki::Tuple<L> vectors;

  public:

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


      bool operator== (const QuantityVectorTuple &tuple) const
        {return CmpVec<Loki::TL::Length<L>::value, L>::cmpVec 
                                                        (*this, tuple);}

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

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


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

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


    void erase (const int index)
    {
      EraVal<Loki::TL::Length<L>::value, L>::eraval (*this, index);
    }


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


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


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


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

    template<int I>
      QuantityVector<T, typename Loki::TL::TypeAt<L, I>::Result::V::BQ,
        typename Loki::TL::TypeAt<L, I>::Result::V::Unit> 
                                     getVector (Loki::Int2Type<I>) const
      {return QuantityVector<T, 
        typename Loki::TL::TypeAt<L, I>::Result::V::BQ,
          typename Loki::TL::TypeAt<L, I>::Result::V::Unit> 
                                     (Loki::Field<I>((*this).vectors));}

    template<int N, class L1> friend class AddVal;
     
    template<int N, class L1> friend class GetVal;
     
    template<int N, class L1> friend class EraVal;
     
    template<int N, class L1> friend class CmpVec;
     
    template<int N, class L1> friend class Copy;
     
    template<int N, class L1> friend class Assign;

    template<int N, class L1, typename Archive> friend class SaveVec;
    template<int N, class L1, typename Archive> friend class LoadVec;

 private:
      friend class boost::serialization::access;


      template<typename Archive>
        void save (Archive &ar, const unsigned int ) const
        {
          int _size = size ();
          ar << BOOST_SERIALIZATION_NVP (_size);
          SaveVec<Loki::TL::Length<L>::value, L, Archive>
                                         ::saveVec (*this, ar);
        }


      template<typename Archive>
        void load (Archive &ar, const unsigned int )
        {
          int _size;
          ar >> BOOST_SERIALIZATION_NVP (_size);
          LoadVec<Loki::TL::Length<L>::value, L, Archive>
                                         ::loadVec (*this, ar, _size);
        }

BOOST_SERIALIZATION_SPLIT_MEMBER()

  };

}

#endif /* _QuantityCluster */

---