Quantities: QuantityAggregates.h Source File

00001 
00005 /* Copyright (C) 2003 - 2011, Bernd Speiser */
00006 /* This file is part of Quantity.
00007 
00008 Quantity is free software; you can redistribute it and/or
00009 modify it under the terms of the GNU General Public License
00010 as published by the Free Software Foundation; either version 2
00011 of the License, or (at your option) any later version.
00012 
00013 Quantity is distributed in the hope that it will be useful,
00014 but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 GNU General Public License for more details.
00017   
00018 You should have received a copy of the GNU General Public License
00019 along with this program; if not, write to the Free Software
00020 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
00021 02111-1307, USA.
00022 */
00023 
00024 #ifndef _QuantityAggregates_h
00025 #define _QuantityAggregates_h
00026 
00027 // Quantity includes
00028 #include "Quantities/Quantity/Quantity.h"
00029 #include "Quantities/Quantity/Variable.h"
00030 
00031 // Loki includes
00032 #include "loki/HierarchyGenerators.h"
00033 
00034 // STL includes
00035 #include <vector>
00036 
00037 // BOOST includes
00038 #include <boost/serialization/vector.hpp>
00039 #include <boost/serialization/base_object.hpp>
00040 
00041 namespace quantity {
00042 
00044 //
00045 // the base QuantityVector
00046 //
00048 
00049 template<typename T, typename ST = double> 
00050   class QuantityVector : public std::vector<ST>
00051 {
00052   public:
00053     typedef T QT;
00054 
00055     typedef typename QuantityTraits<QT>::UnitList UL;
00056 
00057     typedef typename unit::ValidUnit<typename
00058                          QuantityTraits<QT>::DefaultUnit, UL>::RET DU;
00059 
00060     typedef typename QuantityTraits<QT>::DefaultDerivedQuantityType DDQ;
00061 
00062 //    typedef typename std::vector<ST>::size_type size_type;
00063     typedef std::size_t size_type;
00064 
00065     virtual ~QuantityVector (void) {};
00066 
00067     size_type size (void) const {return std::vector<ST>::size ();}
00068     bool empty (void) const {return std::vector<ST>::empty ();}
00069     size_type max_size (void) const {return std::vector<ST>::max_size ();}
00070     size_type capacity (void) const {return std::vector<ST>::capacity ();}
00071     void reserve (size_type n) {return std::vector<ST>::reserve (n);}
00072 
00074 // serialization
00076   private:
00078     friend class boost::serialization::access;
00079 
00081 
00084     template<typename Archive>
00085       void serialize (Archive &ar, const unsigned int )
00086       {
00087         typedef std::vector<ST> STDVEC;
00088         ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(STDVEC);
00089       }
00090 
00091 };
00092 
00093 // forward declaration
00094 template<typename BQV, typename DQ = DerivedQuantity<typename BQV::QT,
00095           typename BQV::DU, typename BQV::DDQ> > class VariableVector;
00096 
00098 //
00099 // the VariableVectorIterator
00100 //
00102 
00103 template<typename IT, typename BQV, 
00104   typename DQ = DerivedQuantity<typename BQV::QT,
00105     typename BQV::DU, typename BQV::DDQ> > class VariableVectorIterator;
00106 
00108 
00111 template<typename IT, typename QT, typename ST, 
00112                                             typename DQSU, typename DQT>
00113   class VariableVectorIterator<IT, QuantityVector<QT, ST>,
00114                             DerivedQuantity<QT, DQSU, DQT> > : public IT
00115 {
00117   friend class VariableVector<QuantityVector<QT, ST>, 
00118                                          DerivedQuantity<QT, DQSU, DQT> >;
00119 
00120   public:
00122     typedef VariableVector<QuantityVector<QT, ST>,
00123                                      DerivedQuantity<QT, DQSU, DQT> > VV;
00124 
00126     typedef Variable<Quantity<QT, ST>, DerivedQuantity<QT, DQSU, DQT> > V;
00127 
00128   protected:
00130 
00133     V var;
00134 
00135   public:
00137     typedef V* pointer;
00138 
00140     typedef V& reference;
00141 
00143 
00145     VariableVectorIterator (void) : IT () {}
00146 
00148 
00151     VariableVectorIterator (const VariableVectorIterator &it) : IT
00152       (*(dynamic_cast<const IT *>(&it))) {}
00153 
00154   protected:
00156 
00158     VariableVectorIterator (const IT &it) : IT (it) {}
00159 
00160   private:
00162 
00167     template<typename SQT, typename SST, typename SSU, typename SDQT>
00168       VariableVectorIterator 
00169         (const VariableVectorIterator<IT, QuantityVector<SQT, SST>,
00170                                 DerivedQuantity<SQT, SSU, SDQT> > &);
00171 
00172   public:
00174 
00178     const reference operator* (void) 
00179     {var = V (**(dynamic_cast<IT *>(this)));
00180      return var;
00181     }
00182 
00184 
00187     pointer operator-> (void) {var = **this; return &var;}
00188 
00190 
00192     const reference operator[] (typename VV::difference_type n) 
00193     {var = V(*(*this + n));
00194      return var;
00195     }
00196 
00198     typename VV::difference_type operator- 
00199                                   (const VariableVectorIterator &it) const
00200     {return *this - it;}
00201 };
00202 
00204 //
00205 // the VariableVectorNormalIterator
00206 //
00208 
00209 template<typename BQV, typename DQ = DerivedQuantity<typename BQV::QT,
00210   typename BQV::DU, typename BQV::DDQ> > 
00211                                    class VariableVectorNormalIterator;
00212 
00213 template<typename QT, typename ST, typename DQSU, typename DQT>
00214   class VariableVectorNormalIterator<QuantityVector<QT, ST>,
00215     DerivedQuantity<QT, DQSU, DQT> > 
00216       : public VariableVectorIterator<typename 
00217         std::vector<ST>::iterator, QuantityVector<QT, ST>,
00218                                           DerivedQuantity<QT, DQSU, DQT> >
00219 {
00221   friend class VariableVector<QuantityVector<QT, ST>, 
00222                                          DerivedQuantity<QT, DQSU, DQT> >;
00223 
00225   typedef typename VariableVector<QuantityVector<QT, ST>,
00226                             DerivedQuantity<QT, DQSU, DQT> >::iterator IT;
00227 
00229   typedef VariableVectorIterator<typename std::vector<ST>::iterator, 
00230      QuantityVector<QT, ST>, DerivedQuantity<QT, DQSU, DQT> > BIT;
00231 
00232   public:
00234 
00236     VariableVectorNormalIterator (void) : BIT () {}
00237 
00239 
00242     VariableVectorNormalIterator (const VariableVectorNormalIterator &it) 
00243       : BIT (*(dynamic_cast<const BIT *>(&it))) {}
00244 
00245   private:
00247 
00252     VariableVectorNormalIterator 
00253       (const typename std::vector<ST>::iterator &it) : BIT (it) {}
00254 
00256 
00261     template<typename SQT, typename SST, typename SSU, typename SDQT>
00262       VariableVectorNormalIterator 
00263         (const VariableVectorNormalIterator<QuantityVector<SQT, SST>,
00264                                 DerivedQuantity<SQT, SSU, SDQT> >);
00265 
00266   public:
00268     VariableVectorNormalIterator & operator= 
00269                                      (const VariableVectorNormalIterator &it)
00270     {if (this != &it)
00271       {typename std::vector<ST>::iterator *this_it 
00272            = dynamic_cast<typename std::vector<ST>::iterator *>(this);
00273        const typename std::vector<ST>::iterator *new_it 
00274            = dynamic_cast<const typename std::vector<ST>::iterator *>(&it);
00275        *this_it = *new_it;
00276       }
00277      return *this;
00278     }
00279 
00280   private:
00282 
00287     VariableVectorNormalIterator operator= 
00288                           (const typename std::vector<ST>::iterator &it) 
00289         {return VariableVectorNormalIterator (it);}
00290 
00291   public:
00293 
00296     VariableVectorNormalIterator & operator++ (void)
00297     {typename std::vector<ST>::iterator *it
00298                = dynamic_cast<typename std::vector<ST>::iterator *>(this);
00299      ++(*it);
00300      return *this;
00301     }
00302 
00304 
00307     VariableVectorNormalIterator operator++ (int)
00308     {VariableVectorNormalIterator temp (*this);
00309      ++(*this);
00310      return temp;
00311     }
00312 
00314 
00317     VariableVectorNormalIterator & operator-- (void)
00318     {typename std::vector<ST>::iterator *it
00319                = dynamic_cast<typename std::vector<ST>::iterator *>(this);
00320     --(*it);
00321      return *this;
00322     }
00323 
00325 
00328     VariableVectorNormalIterator operator-- (int)
00329     {VariableVectorNormalIterator temp (*this);
00330      --(*this);
00331      return temp;
00332     }
00333 
00335 
00337     VariableVectorNormalIterator operator+= (typename BIT::VV::difference_type n)
00338       {for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00339          ++(*this);
00340 
00341        return *this;
00342       }
00343 
00345 
00347     VariableVectorNormalIterator operator-= (typename BIT::VV::difference_type n)
00348       {for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00349          --(*this);
00350 
00351        return *this;
00352       }
00353 
00355 
00357     VariableVectorNormalIterator operator+ 
00358                                (typename BIT::VV::difference_type n) const
00359       {VariableVectorNormalIterator temp = *this;
00360        for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00361          ++temp;
00362 
00363        return temp;
00364       }
00365 
00367 
00369     VariableVectorNormalIterator operator- 
00370                                (typename BIT::VV::difference_type n) const
00371       {VariableVectorNormalIterator temp = *this;
00372        for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00373          --temp;
00374 
00375        return temp;
00376       }
00377 
00379 // comparisons
00382 
00384 #define VARIABLEVECTORNORMALITERATOR_COMPARISON_OPERATORS(mode, opName, opType) \
00385     bool opName (const VariableVectorNormalIterator &rhs) const \
00386     {return \
00387        (*dynamic_cast<const typename std::vector<ST>::iterator *>(this)) \
00388          opType \
00389         (*dynamic_cast<const typename std::vector<ST>::iterator *>(&rhs));}
00390 
00391 VARIABLEVECTORNORMALITERATOR_COMPARISON_OPERATORS(VariableVector, operator==, ==)
00392 VARIABLEVECTORNORMALITERATOR_COMPARISON_OPERATORS(VariableVector, operator!=, !=)
00393 VARIABLEVECTORNORMALITERATOR_COMPARISON_OPERATORS(VariableVector, operator>, >)
00394 VARIABLEVECTORNORMALITERATOR_COMPARISON_OPERATORS(VariableVector, operator<, <)
00395 VARIABLEVECTORNORMALITERATOR_COMPARISON_OPERATORS(VariableVector, operator>=, >=)
00396 VARIABLEVECTORNORMALITERATOR_COMPARISON_OPERATORS(VariableVector, operator<=, <=)
00397 
00398 };
00399 
00401 
00403 template<typename QT, typename ST, typename DQSU, typename DQT>
00404   VariableVectorNormalIterator<QuantityVector<QT, ST>,
00405     DerivedQuantity<QT, DQSU, DQT> > operator+ 
00406       (const typename VariableVector<QuantityVector<QT, ST>,
00407          DerivedQuantity<QT, DQSU, DQT> >::difference_type n, 
00408            VariableVectorNormalIterator<QuantityVector<QT, ST>,
00409                                    DerivedQuantity<QT, DQSU, DQT> > it)
00410    {return (it + n);}
00411 
00413 //
00414 // the VariableVectorReverseIterator
00415 //
00417 
00418 template<typename BQV, typename DQ = DerivedQuantity<typename BQV::QT,
00419   typename BQV::DU, typename BQV::DDQ> > 
00420                                  class VariableVectorReverseIterator;
00421 
00422 template<typename QT, typename ST, typename DQSU, typename DQT>
00423   class VariableVectorReverseIterator<QuantityVector<QT, ST>,
00424     DerivedQuantity<QT, DQSU, DQT> > 
00425       : public VariableVectorIterator<typename
00426         std::vector<ST>::reverse_iterator, QuantityVector<QT, ST>,
00427                                           DerivedQuantity<QT, DQSU, DQT> >
00428 
00429 {
00431   friend class VariableVector<QuantityVector<QT, ST>, 
00432                                          DerivedQuantity<QT, DQSU, DQT> >;
00433 
00435   typedef typename VariableVector<QuantityVector<QT, ST>,
00436                      DerivedQuantity<QT, DQSU, DQT> >::reverse_iterator IT;
00437 
00439   typedef VariableVectorIterator<typename std::vector<ST>::reverse_iterator,
00440      QuantityVector<QT, ST>, DerivedQuantity<QT, DQSU, DQT> > BIT;
00441 
00442   public:
00444 
00446     VariableVectorReverseIterator (void) : BIT () {}
00447 
00449 
00452     VariableVectorReverseIterator (const VariableVectorReverseIterator &it) 
00453       : BIT (*(dynamic_cast<const BIT *>(&it))) {}
00454 
00455   private:
00457 
00462     VariableVectorReverseIterator 
00463       (const typename std::vector<ST>::reverse_iterator &it) : BIT (it) {}
00464 
00466 
00471     template<typename SQT, typename SST, typename SSU, typename SDQT>
00472       VariableVectorReverseIterator 
00473         (const VariableVectorReverseIterator<QuantityVector<SQT, SST>,
00474                                 DerivedQuantity<SQT, SSU, SDQT> >);
00475 
00476   public:
00478     VariableVectorReverseIterator & operator= 
00479                                   (const VariableVectorReverseIterator &it)
00480     {if (this != &it)
00481       {typename std::vector<ST>::reverse_iterator *this_it 
00482          = dynamic_cast<typename std::vector<ST>::reverse_iterator *>
00483                                                               (this);
00484        const typename std::vector<ST>::reverse_iterator *new_it 
00485          = dynamic_cast<const typename std::vector<ST>::reverse_iterator *>
00486                                                                (&it);
00487        *this_it = *new_it;
00488       }
00489      return *this;
00490     }
00491 
00492   private:
00494 
00499     VariableVectorReverseIterator operator= 
00500              (const typename std::vector<ST>::reverse_iterator &it) 
00501       {return VariableVectorReverseIterator (it);}
00502 
00503   public:
00505 
00508     VariableVectorReverseIterator & operator++ (void) 
00509     {typename std::vector<ST>::reverse_iterator *it
00510       = dynamic_cast<typename std::vector<ST>::reverse_iterator *>
00511                                                               (this);
00512      ++(*it);
00513      return *this;
00514     }
00515 
00517 
00520     VariableVectorReverseIterator operator++ (int)
00521     {VariableVectorReverseIterator temp (*this);
00522      ++(*this);
00523      return temp;
00524     }
00525 
00527 
00530     VariableVectorReverseIterator & operator-- (void)
00531     {typename std::vector<ST>::reverse_iterator *it
00532       = dynamic_cast<typename std::vector<ST>::reverse_iterator *>
00533                                                              (this);
00534     --(*it);
00535      return *this;
00536     }
00537 
00539 
00543     VariableVectorReverseIterator operator-- (int)
00544     {VariableVectorReverseIterator temp (*this);
00545      --(*this);
00546      return temp;
00547     }
00548 
00550 
00552     VariableVectorReverseIterator 
00553                  operator+= (typename BIT::VV::difference_type n) 
00554       {for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00555          ++(*this);
00556 
00557        return *this;
00558       }
00559 
00561 
00563     VariableVectorReverseIterator operator-= 
00564                              (typename BIT::VV::difference_type n) 
00565       {for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00566          --(*this);
00567 
00568        return *this;
00569       }
00570 
00572 
00575     VariableVectorReverseIterator operator+ 
00576                              (typename BIT::VV::difference_type n) const
00577       {VariableVectorReverseIterator temp = *this;
00578        for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00579          ++temp;
00580 
00581        return temp;
00582       }
00583 
00585 
00587     VariableVectorReverseIterator operator- 
00588                           (typename BIT::VV::difference_type n) const
00589       {VariableVectorReverseIterator temp = *this;
00590        for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00591          --temp;
00592 
00593        return temp;
00594       }
00595 
00596 };
00597 
00599 
00601 template<typename QT, typename ST, typename DQSU, typename DQT>
00602   VariableVectorReverseIterator<QuantityVector<QT, ST>,
00603     DerivedQuantity<QT, DQSU, DQT> > operator+ 
00604       (const typename VariableVector<QuantityVector<QT, ST>,
00605          DerivedQuantity<QT, DQSU, DQT> >::difference_type n, 
00606            VariableVectorReverseIterator<QuantityVector<QT, ST>,
00607                                    DerivedQuantity<QT, DQSU, DQT> > it)
00608    {return (it + n);}
00609 
00611 //
00612 // the VariableVectorConstIterator
00613 //
00615 
00616 template<typename BQV, typename DQ = DerivedQuantity<typename BQV::QT,
00617   typename BQV::DU, typename BQV::DDQ> > class VariableVectorConstIterator;
00618 
00619 template<typename QT, typename ST, typename DQSU, typename DQT>
00620   class VariableVectorConstIterator<QuantityVector<QT, ST>,
00621     DerivedQuantity<QT, DQSU, DQT> > 
00622       : public VariableVectorIterator<typename
00623         std::vector<ST>::const_iterator, QuantityVector<QT, ST>,
00624                                           DerivedQuantity<QT, DQSU, DQT> >
00625 {
00627   friend class VariableVector<QuantityVector<QT, ST>, 
00628                                          DerivedQuantity<QT, DQSU, DQT> >;
00629 
00631   typedef typename VariableVector<QuantityVector<QT, ST>,
00632                      DerivedQuantity<QT, DQSU, DQT> >::const_iterator IT;
00633 
00635   typedef VariableVectorIterator<typename std::vector<ST>::const_iterator,
00636      QuantityVector<QT, ST>, DerivedQuantity<QT, DQSU, DQT> > BIT;
00637 
00638   public:
00640 
00642     VariableVectorConstIterator (void) : BIT () {}
00643 
00645 
00648     VariableVectorConstIterator (const VariableVectorConstIterator &it) 
00649       : BIT (*(dynamic_cast<const BIT *>(&it))) {}
00650 
00651   private:
00653 
00658     VariableVectorConstIterator 
00659       (const typename std::vector<ST>::const_iterator &it) : BIT (it) {}
00660 
00662 
00667     template<typename SQT, typename SST, typename SSU, typename SDQT>
00668       VariableVectorConstIterator
00669         (const VariableVectorConstIterator<QuantityVector<SQT, SST>,
00670                                 DerivedQuantity<SQT, SSU, SDQT> >);
00671 
00672   public:
00674     VariableVectorConstIterator & operator= 
00675                                        (const VariableVectorConstIterator &it)
00676     {if (this != &it)
00677       {typename std::vector<ST>::const_iterator *this_it 
00678          = dynamic_cast<typename std::vector<ST>::const_iterator *>(this);
00679        const typename std::vector<ST>::const_iterator *new_it 
00680          = dynamic_cast<const typename std::vector<ST>::const_iterator *>(&it);
00681        *this_it = *new_it;
00682       }
00683      return *this;
00684     }
00685 
00686   private:
00688 
00693     VariableVectorConstIterator operator= 
00694                        (const typename std::vector<ST>::const_iterator &it) 
00695     {return VariableVectorConstIterator (it);}
00696 
00697   public:
00699 
00702     VariableVectorConstIterator & operator++ (void)
00703     {typename std::vector<ST>::const_iterator *it
00704           = dynamic_cast<typename std::vector<ST>::const_iterator *>(this);
00705      ++(*it);
00706      return *this;
00707     }
00708 
00710 
00713     VariableVectorConstIterator operator++ (int)
00714     {VariableVectorConstIterator temp (*this);
00715      ++(*this);
00716      return temp;
00717     }
00718 
00720 
00723     VariableVectorConstIterator & operator-- (void)
00724     {typename std::vector<ST>::const_iterator *it
00725          = dynamic_cast<typename std::vector<ST>::const_iterator *>(this);
00726      --(*it);
00727      return *this;
00728     }
00729 
00731 
00734     VariableVectorConstIterator operator-- (int)
00735     {VariableVectorConstIterator temp (*this);
00736      --(*this);
00737      return temp;
00738     }
00739 
00741 
00743     VariableVectorConstIterator operator+= 
00744                                         (typename BIT::VV::difference_type n) 
00745       {for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00746          ++(*this);
00747 
00748        return *this;
00749       }
00750 
00752 
00754     VariableVectorConstIterator operator-= 
00755                                          (typename BIT::VV::difference_type n) 
00756       {for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00757          --(*this);
00758 
00759        return *this;
00760       }
00761 
00763 
00766     VariableVectorConstIterator operator+ 
00767                              (typename BIT::VV::difference_type n) const
00768       {VariableVectorConstIterator temp = *this;
00769        for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00770          ++temp;
00771 
00772        return temp;
00773       }
00774 
00776 
00778     VariableVectorConstIterator operator- 
00779                           (typename BIT::VV::difference_type n) const
00780       {VariableVectorConstIterator temp = *this;
00781        for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00782          --temp;
00783 
00784        return temp;
00785       }
00786 
00787 };
00788 
00790 
00792 template<typename QT, typename ST, typename DQSU, typename DQT>
00793   VariableVectorConstIterator<QuantityVector<QT, ST>,
00794     DerivedQuantity<QT, DQSU, DQT> > operator+ 
00795       (const typename VariableVector<QuantityVector<QT, ST>,
00796          DerivedQuantity<QT, DQSU, DQT> >::difference_type n, 
00797            VariableVectorConstIterator<QuantityVector<QT, ST>,
00798                                    DerivedQuantity<QT, DQSU, DQT> > it)
00799    {return (it + n);}
00800 
00802 //
00803 // the VariableVectorConstReverseIterator
00804 //
00806 
00807 template<typename BQV, typename DQ = DerivedQuantity<typename BQV::QT,
00808   typename BQV::DU, typename BQV::DDQ> > 
00809                                  class VariableVectorConstReverseIterator;
00810 
00811 template<typename QT, typename ST, typename DQSU, typename DQT>
00812   class VariableVectorConstReverseIterator<QuantityVector<QT, ST>,
00813     DerivedQuantity<QT, DQSU, DQT> > 
00814       : public VariableVectorIterator<typename
00815         std::vector<ST>::const_reverse_iterator, QuantityVector<QT, ST>,
00816                                           DerivedQuantity<QT, DQSU, DQT> >
00817 
00818 {
00820   friend class VariableVector<QuantityVector<QT, ST>, 
00821                                          DerivedQuantity<QT, DQSU, DQT> >;
00822 
00824   typedef typename VariableVector<QuantityVector<QT, ST>,
00825                 DerivedQuantity<QT, DQSU, DQT> >::const_reverse_iterator IT;
00826 
00828   typedef VariableVectorIterator<typename 
00829     std::vector<ST>::const_reverse_iterator, QuantityVector<QT, ST>, 
00830                                           DerivedQuantity<QT, DQSU, DQT> > BIT;
00831 
00832   public:
00834 
00836     VariableVectorConstReverseIterator (void) : BIT () {}
00837 
00839 
00842     VariableVectorConstReverseIterator 
00843                             (const VariableVectorConstReverseIterator &it) 
00844       : BIT (*(dynamic_cast<const BIT *>(&it))) {}
00845 
00846   private:
00848 
00854     VariableVectorConstReverseIterator 
00855       (const typename std::vector<ST>::const_reverse_iterator &it) 
00856         : BIT (it) {}
00857 
00859 
00864     template<typename SQT, typename SST, typename SSU, typename SDQT>
00865       VariableVectorConstReverseIterator 
00866         (const VariableVectorConstReverseIterator<QuantityVector<SQT, SST>,
00867                                 DerivedQuantity<SQT, SSU, SDQT> >);
00868 
00869   public:
00871     VariableVectorConstReverseIterator & operator= 
00872                                (const VariableVectorConstReverseIterator &it)
00873     {if (this != &it)
00874       {typename std::vector<ST>::const_reverse_iterator *this_it 
00875          = dynamic_cast<typename std::vector<ST>::const_reverse_iterator *>
00876                                                               (this);
00877        const typename std::vector<ST>::const_reverse_iterator *new_it 
00878          = dynamic_cast<const typename 
00879                     std::vector<ST>::const_reverse_iterator *> (&it);
00880        *this_it = *new_it;
00881       }
00882      return *this;
00883     }
00884 
00885   private:
00887 
00892     VariableVectorConstReverseIterator operator= 
00893              (const typename std::vector<ST>::const_reverse_iterator &it) 
00894       {return VariableVectorConstReverseIterator (it);}
00895 
00896   public:
00898 
00901     VariableVectorConstReverseIterator & operator++ (void)
00902     {typename std::vector<ST>::const_reverse_iterator *it
00903       = dynamic_cast<typename std::vector<ST>::const_reverse_iterator *>
00904                                                               (this);
00905      ++(*it);
00906      return *this;
00907     }
00908 
00910 
00913     VariableVectorConstReverseIterator operator++ (int)
00914     {VariableVectorConstReverseIterator temp (*this);
00915      ++(*this);
00916      return temp;
00917     }
00918 
00920 
00923     VariableVectorConstReverseIterator & operator-- (void)
00924     {typename std::vector<ST>::const_reverse_iterator *it
00925       = dynamic_cast<typename std::vector<ST>::const_reverse_iterator *>
00926                                                              (this);
00927     --(*it);
00928      return *this;
00929     }
00930 
00932 
00936     VariableVectorConstReverseIterator operator-- (int)
00937     {VariableVectorConstReverseIterator temp (*this);
00938      --(*this);
00939      return temp;
00940     }
00941 
00943 
00945     VariableVectorConstReverseIterator 
00946                  operator+= (typename BIT::VV::difference_type n) 
00947       {for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00948          ++(*this);
00949 
00950        return *this;
00951       }
00952 
00954 
00956     VariableVectorConstReverseIterator operator-= 
00957                              (typename BIT::VV::difference_type n) 
00958       {for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00959          --(*this);
00960 
00961        return *this;
00962       }
00963 
00965 
00968     VariableVectorConstReverseIterator operator+ 
00969                              (typename BIT::VV::difference_type n) const
00970       {VariableVectorConstReverseIterator temp = *this;
00971        for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00972          ++temp;
00973 
00974        return temp;
00975       }
00976 
00978 
00980     VariableVectorConstReverseIterator operator- 
00981                           (typename BIT::VV::difference_type n) const
00982       {VariableVectorConstReverseIterator temp = *this;
00983        for (typename BIT::VV::difference_type i = 0; i < n; ++i)
00984          --temp;
00985 
00986        return temp;
00987       }
00988 
00989 };
00990 
00992 
00994 template<typename QT, typename ST, typename DQSU, typename DQT>
00995   VariableVectorConstReverseIterator<QuantityVector<QT, ST>,
00996     DerivedQuantity<QT, DQSU, DQT> > operator+ 
00997       (const typename VariableVector<QuantityVector<QT, ST>,
00998          DerivedQuantity<QT, DQSU, DQT> >::difference_type n, 
00999            VariableVectorConstReverseIterator<QuantityVector<QT, ST>,
01000                                    DerivedQuantity<QT, DQSU, DQT> > it)
01001    {return (it + n);}
01002 
01004 //
01005 // the VariableVector
01006 //
01008 
01009 template<typename QT, typename ST, typename DQSU, typename DQT>
01010   class VariableVector<QuantityVector<QT, ST>, 
01011     DerivedQuantity<QT, DQSU, DQT> > : public QuantityVector<QT, ST>
01012 {
01013   protected:
01015     typedef QuantityVector<QT, ST> BV;
01016 
01018 
01020     typedef typename unit::ValidUnit<DQSU, typename BV::UL>::RET SU;
01021 
01022   public:
01024 
01026     typedef Variable<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > V;
01027 
01029     typedef V value_type;
01030     typedef value_type & reference;
01031     typedef const value_type & const_reference;
01032 
01034 
01036     typedef VariableVectorNormalIterator<QuantityVector<QT, ST>,
01037                    DerivedQuantity<QT, SU, DQT> > iterator;
01039 
01042     typedef VariableVectorReverseIterator<QuantityVector<QT, ST>,
01043                    DerivedQuantity<QT, SU, DQT> > reverse_iterator;
01044 
01046 
01048     typedef VariableVectorConstIterator<QuantityVector<QT, ST>,
01049                        DerivedQuantity<QT, SU, DQT> > const_iterator;
01050 
01052 
01055     typedef VariableVectorConstReverseIterator<QuantityVector<QT, ST>,
01056                DerivedQuantity<QT, SU, DQT> > const_reverse_iterator;
01057 
01058 // difference_type not defined and taken from std::vector<ST>
01059 // allocator_type not defined 
01060 
01062 // iterator support
01064 
01066 
01068     iterator begin (void) {return iterator (std::vector<ST>::begin());}
01069 
01071 
01073     reverse_iterator rbegin (void) 
01074                 {return reverse_iterator (std::vector<ST>::rbegin());}
01075 
01077 
01079     const_iterator begin (void) const 
01080                     {return const_iterator (std::vector<ST>::begin());}
01081 
01083 
01085     const_reverse_iterator rbegin (void) const
01086           {return const_reverse_iterator (std::vector<ST>::rbegin());}
01087 
01089 
01091     iterator end (void) {return iterator (std::vector<ST>::end());}
01092 
01094 
01096     reverse_iterator rend (void) 
01097                {return reverse_iterator (std::vector<ST>::rend());}
01098 
01100 
01102     const_iterator end (void) const 
01103                      {return const_iterator (std::vector<ST>::end());}
01104 
01106 
01108     const_reverse_iterator rend (void) const
01109            {return const_reverse_iterator (std::vector<ST>::rend());}
01110 
01112 // construction
01114 public:
01116     VariableVector (void) {}
01117 
01119 
01121     VariableVector (const typename BV::size_type n) 
01122     {for (typename BV::size_type i = 0; i < n; ++i)
01123        push_back (V());
01124     }
01125 
01127 
01130     template <template<typename, typename> class M, typename SQT, 
01131       typename SST, typename SSU, typename SDQT>
01132         VariableVector (typename BV::size_type n,
01133           const M<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > 
01134                                                                 &element)
01135       {for (typename BV::size_type i = 0; i < n; ++i)
01136         push_back (element);
01137       }
01138 
01140 // copy construction
01142 public:
01144 
01148     template<typename SQT, typename SST, typename SSU, typename SDQT>
01149       VariableVector (const VariableVector<QuantityVector<SQT, SST>, 
01150                                 DerivedQuantity<SQT, SSU, SDQT> > &vector)
01151       {for (VariableVectorConstIterator<QuantityVector<SQT, SST>, 
01152         DerivedQuantity<SQT, SSU, SDQT> > it = vector.begin(); 
01153                                            it < vector.end (); ++it)
01154          push_back (*it);
01155       }
01156 
01158 
01162     template<typename IT, typename SQT, typename SST, typename SSU, 
01163                                                               typename SDQT>
01164       VariableVector (const VariableVectorIterator<IT, QuantityVector
01165         <SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > beg, 
01166           const VariableVectorIterator<IT, QuantityVector<SQT, SST>,
01167                               DerivedQuantity<SQT, SSU, SDQT> > end)
01168       {for (VariableVectorIterator<IT, QuantityVector <SQT, SST>, 
01169           DerivedQuantity<SQT, SSU, SDQT> > it = beg; it < end; ++it)
01170          push_back (*it);
01171       }
01172 
01174 // comparisons
01176 
01177   public:
01179 
01185 #define VARIABLEVECTOR_COMPARISON_OPERATORS(mode, opName, opType) \
01186   bool opName (const std::vector<ST> &) const; \
01187   bool opName (const mode &rhs) const \
01188     {return (*(dynamic_cast<const std::vector<ST> *>(this))) \
01189            opType (*(dynamic_cast<const std::vector<ST> *>(&rhs)));} \
01190   template<typename RQT, typename RST, typename RSU, typename RDQT> \
01191     bool opName (const mode<QuantityVector<RQT,RST>, \
01192       DerivedQuantity<RQT, RSU, RDQT> > &rhs) const \
01193     {VariableVector<QuantityVector<QT, ST>, \
01194                       DerivedQuantity<QT, SU, DQT> > vector (rhs); \
01195       return (*(dynamic_cast<const std::vector<ST> *>(this))) \
01196            opType (*(dynamic_cast<const std::vector<ST> *>(&vector))); \
01197     }
01198 
01199 VARIABLEVECTOR_COMPARISON_OPERATORS(VariableVector, operator==, ==)
01200 VARIABLEVECTOR_COMPARISON_OPERATORS(VariableVector, operator!=, !=)
01201 VARIABLEVECTOR_COMPARISON_OPERATORS(VariableVector, operator>, >)
01202 VARIABLEVECTOR_COMPARISON_OPERATORS(VariableVector, operator<, <)
01203 VARIABLEVECTOR_COMPARISON_OPERATORS(VariableVector, operator>=, >=)
01204 VARIABLEVECTOR_COMPARISON_OPERATORS(VariableVector, operator<=, <=)
01205 
01207 // assignment
01209 public:
01211 
01220     template<typename SQT, typename SST, typename SSU, typename SDQT>
01221       VariableVector & operator= 
01222         (const VariableVector<QuantityVector<SQT, SST>, 
01223                                 DerivedQuantity<SQT, SSU, SDQT> > &vector)
01224       {
01225         std::vector<ST>::clear ();
01226 
01227         for (VariableVectorConstIterator<QuantityVector<SQT, SST>, 
01228           DerivedQuantity<SQT, SSU, SDQT> > it = vector.begin(); 
01229                                                    it < vector.end(); ++it)
01230           push_back (*it);
01231 
01232         return *this;
01233       }
01234 
01236 
01239     template<template<typename, typename> class M, typename SQT,
01240                                  typename SST, typename SSU, typename SDQT>
01241       void assign (typename BV::size_type n, 
01242           const M<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > 
01243                                                                 & quantity)
01244       {std::vector<ST>::clear ();
01245        for (typename BV::size_type i = 0; i < n; ++i)
01246          push_back (quantity);
01247       }
01248 
01250 
01253     template<typename IT, typename SQT, typename SST, typename SSU, 
01254                                                         typename SDQT>
01255       void assign (VariableVectorIterator<IT, QuantityVector<SQT, SST>,
01256                             DerivedQuantity<SQT, SSU, SDQT> > beg,
01257         VariableVectorIterator<IT, QuantityVector<SQT, SST>,
01258                             DerivedQuantity<SQT, SSU, SDQT> > end)
01259      {VariableVector temp (beg, end); (*this).operator= (temp);}
01260 
01262 
01265     template<typename SQT, typename SST, typename SSU, typename SDQT>
01266       void swap (VariableVector<QuantityVector<SQT, SST>, 
01267                                  DerivedQuantity<SQT, SSU, SDQT> > &vector)
01268     {VariableVector vec1 (vector);
01269      VariableVector<QuantityVector<SQT, SST>, 
01270                              DerivedQuantity<SQT, SSU, SDQT> > vec2 (*this);
01271      std::vector<ST>::swap (*(dynamic_cast<std::vector<ST> *>(&vec1)));
01272      (*(dynamic_cast<std::vector<ST> *>(&vector))).swap 
01273                                 (*(dynamic_cast<std::vector<ST> *>(&vec2)));
01274     }
01275 
01277 // element access
01280 
01286     V at (typename BV::size_type index) const
01287                                   {return V(std::vector<ST>::at (index));}
01288 
01290 
01295     V operator[] (typename BV::size_type index) const 
01296                     {return V(std::vector<ST>::operator[] (index));}
01297 
01299 
01305     V front (void) {return V(std::vector<ST>::front ());}
01306 
01308 
01314     V back (void) {return V(std::vector<ST>::back ());}
01315 
01317 // inserting quantity values 
01319   public:
01321 
01324     template <typename IT>
01325       VariableVectorIterator<IT, QuantityVector
01326         <QT, ST>, DerivedQuantity<QT, SU, DQT> > 
01327           insert (VariableVectorIterator<IT, QuantityVector
01328              <QT, ST>, DerivedQuantity<QT, SU, DQT> > pos, const ST &);
01329 
01331 
01335     template <template<typename, typename> class M, typename IT>
01336       VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01337                                              DerivedQuantity<QT, SU, DQT> > 
01338         insert (VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01339                                           DerivedQuantity<QT, SU, DQT> > pos, 
01340         const M<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > &quantity) 
01341           {return  VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01342              DerivedQuantity<QT, SU, DQT> >(std::vector<ST>::insert 
01343                                                   (pos, quantity.value()));}
01344 
01346 
01349     template <template<typename, typename> class M, typename IT, typename SST, 
01350                                        typename SSU, typename SDQT>
01351       VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01352                                             DerivedQuantity<QT, SU, DQT> > 
01353         insert (VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01354                                           DerivedQuantity<QT, SU, DQT> > pos, 
01355           const M<Quantity<QT, SST>, DerivedQuantity<QT, SSU, SDQT> > 
01356                                                              &quantity)
01357       {return  VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01358         DerivedQuantity<QT, SU, DQT> >(std::vector<ST>::insert 
01359           (pos, unit::Reverse<SU>::VAL (unit::Standard<typename 
01360             unit::ValidUnit<SSU, typename BV::UL>::RET>::VAL 
01361                                                       (quantity.value()))));}
01362 
01364 
01367     template <template<typename, typename> class M, typename IT, typename SQT,
01368                                typename SST, typename SSU, typename SDQT>
01369       VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01370                                           DerivedQuantity<QT, SU, DQT> > 
01371         insert (VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01372                                            DerivedQuantity<QT, SU, DQT> > pos, 
01373           const M<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > 
01374                                                              &quantity)
01375       {return std::vector<ST>::insert (pos, convertValue<V, 
01376          M<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > >
01377                                                 ::exec (quantity.value()));}
01378 
01380 
01383     template<typename IT>
01384       void insert (VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01385                                     DerivedQuantity<QT, SU, DQT> > pos, 
01386           typename BV::size_type n, const ST &);
01387 
01389 
01393     template <template<typename, typename> class M, typename IT>
01394       void insert (VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01395                                       DerivedQuantity<QT, SU, DQT> > pos, 
01396         typename BV::size_type n, const M<Quantity<QT, ST>, 
01397                                 DerivedQuantity<QT, SU, DQT> > &quantity) 
01398         {std::vector<ST>::insert (pos, n, quantity.value());}
01399 
01401 
01405     template <template<typename, typename> class M, typename IT, typename SST, 
01406                                        typename SSU, typename SDQT>
01407       void insert (VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01408         DerivedQuantity<QT, SU, DQT> > pos, 
01409           typename BV::size_type n,
01410             const M<Quantity<QT, SST>, DerivedQuantity<QT, SSU, SDQT> > 
01411                                                              &quantity)
01412       {std::vector<ST>::insert (pos, n, unit::Reverse<SU>::VAL
01413          (unit::Standard<typename unit::ValidUnit<SSU,
01414                      typename BV::UL>::RET>::VAL (quantity.value())));}
01415 
01417 
01420     template <template<typename, typename> class M, typename IT, typename SQT,
01421                                typename SST, typename SSU, typename SDQT>
01422       void  insert ( VariableVectorIterator<IT, QuantityVector <QT, ST>, 
01423         DerivedQuantity<QT, SU, DQT> > pos, 
01424           typename BV::size_type n,
01425             const M<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > 
01426                                                              &quantity)
01427       {std::vector<ST>::insert (pos, n, convertValue<V, 
01428          M<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > >
01429                                                 ::exec (quantity.value()));}
01430 
01432 
01435     template<typename IT>
01436       void insert (VariableVectorIterator<IT, QuantityVector<QT, ST>, 
01437         DerivedQuantity<QT, SU, DQT> > pos, VariableVectorIterator<IT, 
01438           QuantityVector<QT, ST>, DerivedQuantity<QT, SU, DQT> > beg, 
01439             VariableVectorIterator<IT, QuantityVector<QT, ST>, 
01440                                      DerivedQuantity<QT, SU, DQT> > end)
01441     {std::vector<ST>::insert (*(dynamic_cast<IT *>(&pos)), 
01442           *(dynamic_cast<IT *>(&beg)), *(dynamic_cast<IT *>(&end)));}
01443 
01445 
01448     template<typename IT, typename SST, typename SSU, typename SDQT>
01449     void insert (VariableVectorIterator<IT, 
01450       QuantityVector<QT, ST>, DerivedQuantity<QT, SU, DQT> > pos, 
01451       VariableVectorIterator<IT, QuantityVector<QT, SST>, 
01452         DerivedQuantity<QT, SSU, SDQT> > beg, VariableVectorIterator<IT, 
01453           QuantityVector<QT, SST>, DerivedQuantity<QT, SSU, SDQT> > end)
01454     {VariableVector vec(beg, end);
01455      insert (pos, vec.begin(), vec.end());
01456     }
01457 
01459 
01463     template<typename IT, typename SQT, typename SST, typename SSU, typename SDQT>
01464     void insert (VariableVectorIterator<IT, QuantityVector<QT, ST>, 
01465       DerivedQuantity<QT, SU, DQT> > pos, VariableVectorIterator<IT, 
01466         QuantityVector<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > beg, 
01467         VariableVectorIterator<IT, QuantityVector<SQT, SST>, 
01468                           DerivedQuantity<SQT, SSU, SDQT> > end)
01469     {VariableVector vec(beg, end);
01470      insert (pos, vec.begin(), vec.end());
01471     }
01472 
01474 
01477    void push_back (const ST &value);
01478 
01480 
01484     template <template<typename, typename> class M>
01485       void push_back (const M<Quantity<QT, ST>, DerivedQuantity<QT, SU, DQT> > 
01486                                                             &quantity)
01487       {std::vector<ST>::push_back (quantity.value());}
01488 
01490 
01495     template <template<typename, typename> class M, typename SST, 
01496                                                  typename SSU, typename SDQT>
01497       void push_back (const M<Quantity<QT, SST>, 
01498                                    DerivedQuantity<QT, SSU, SDQT> > &quantity)
01499       {std::vector<ST>::push_back (unit::Reverse<SU>::VAL
01500          (unit::Standard<typename unit::ValidUnit<SSU,
01501                             typename BV::UL>::RET>::VAL (quantity.value())));}
01502 
01504 
01507     template <template<typename, typename> class M, typename SQT,
01508                              typename SST, typename SSU, typename SDQT>
01509       void push_back (const M<Quantity<SQT, SST>, 
01510                                 DerivedQuantity<SQT, SSU, SDQT> > &quantity)
01511       {std::vector<ST>::push_back (convertValue<V, 
01512          Variable<Quantity<SQT, SST>, DerivedQuantity<SQT, SSU, SDQT> > >
01513                                                 ::exec (quantity.value()));}
01514 
01516 // removing quantity values 
01518 
01520 
01522   template<typename IT>
01523     VariableVectorIterator<IT, QuantityVector<QT, ST>,
01524       DerivedQuantity<QT, SU, DQT> > erase (VariableVectorIterator<IT, 
01525         QuantityVector<QT, ST>, DerivedQuantity<QT, SU, DQT> > pos) 
01526       {return VariableVectorIterator<IT, QuantityVector<QT, ST>,
01527          DerivedQuantity<QT, SU, DQT> > (std::vector<ST>::erase
01528                                           (*(dynamic_cast<IT *>(&pos))));}
01529 
01531 
01533   template<typename IT>
01534     VariableVectorIterator<IT, QuantityVector<QT, ST>,
01535       DerivedQuantity<QT, SU, DQT> > erase 
01536         (VariableVectorIterator<IT, QuantityVector<QT, ST>,
01537           DerivedQuantity<QT, SU, DQT> > beg, 
01538          VariableVectorIterator<IT, QuantityVector<QT, ST>,
01539           DerivedQuantity<QT, SU, DQT> > end) 
01540     {return VariableVectorIterator<IT, QuantityVector<QT, ST>,
01541       DerivedQuantity<QT, SU, DQT> >(std::vector<ST>::erase
01542       (*(dynamic_cast<IT *>(&beg)),
01543        *(dynamic_cast<IT *>(&end))));}
01544 
01546 
01548   void pop_back (void) {std::vector<ST>::pop_back ();}
01549 
01551 
01553   void clear (void) {std::vector<ST>::clear ();}
01554 
01556 // serialization
01558  private:
01560    friend class boost::serialization::access;
01561 
01563 
01566    template<typename Archive>
01567      void serialize (Archive &ar, const unsigned int )
01568      {
01569        typedef QuantityVector<QT, ST> VEC;
01570        ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(VEC);
01571      }
01572 };
01573 
01574 
01575 // forward declaration
01577 
01580 template<class L> class VariableVectorTuple;
01581 
01583 //
01584 //  helper classes and structs for the QuantityVector tuples
01585 //
01587 
01590 //    recursive template
01591 //*/
01592 //template<int N, class L>
01593 //  class EraVal
01594 //  {
01595 //    public:
01597 //      static void eraval (QuantityVectorTuple<L> &tuple, 
01598 //                                                        const int index)
01599 //        {Loki::Field<N-1>(tuple.vectors).erase (index);
01600 //         EraVal<N-1, L>::eraval (tuple, index);
01601 //        }
01602 //  };
01603 //
01606 //    for N = 0
01607 //*/
01608 //template<class L>
01609 //  class EraVal<0, L>
01610 //  {
01611 //    public:
01612 //      static void eraval (QuantityVectorTuple<L> &, const int) {};
01613 //  };
01614 //
01617 //*/
01618 //template<int N, class L>
01619 //  class CmpVec
01620 //  {
01621 //    public:
01622 //      static bool cmpVec
01623 //        (const QuantityVectorTuple<L> &tuple1, 
01624 //                                   const QuantityVectorTuple<L> &tuple2)
01625 //      {
01626 //        if (Loki::Field<N-1>(tuple1.vectors) 
01627 //                                    == Loki::Field<N-1>(tuple2.vectors))
01628 //          return CmpVec<N-1, L>::cmpVec (tuple1, tuple2);
01629 //
01630 //        else
01631 //          return false;
01632 //      }
01633 //  };
01634 //
01637 //    always returns true.
01638 //*/
01639 //template<class L>
01640 //  class CmpVec<0, L>
01641 //  {
01642 //    public:
01643 //      static bool cmpVec 
01644 //        (const QuantityVectorTuple<L> &, const QuantityVectorTuple<L> &)
01645 //                                                          {return true;}
01646 //  };
01647 //
01650 //    each one.
01651 //*/
01652 //template<int N, class L, typename Archive>
01653 //  class SaveVec
01654 //  {
01655 //    public:
01656 //      static void saveVec
01657 //        (const QuantityVectorTuple<L> &tuple, Archive &ar) 
01658 //      {
01659 //        SaveVec<N-1,L,Archive>::saveVec (tuple, ar);
01660 //        typename Loki::TL::TypeAt<L, N-1>::Result 
01661 //                              vec = Loki::Field<N-1>(tuple.vectors);
01662 //        ar << BOOST_SERIALIZATION_NVP(vec);
01663 //      }
01664 //  };
01665 //
01668 //    does nothing else.
01669 //*/
01670 //template<class L, typename Archive>
01671 //  class SaveVec<0, L, Archive>
01672 //  {
01673 //    public:
01674 //      static void saveVec (const QuantityVectorTuple<L> &, Archive &) {}
01675 //  };
01676 //
01679 //    each one;
01680 //    must check the size of the retrieved vector in order to assure that
01681 //    all vectors in the tuple have the same number of elements; _size is 
01682 //    provided by the calling code; if the size of one of the vectors is
01683 //    different from _size, a VectorSizeError exception is thrown.
01684 //*/
01685 //template<int N, class L, typename Archive>
01686 //  class LoadVec
01687 //  {
01688 //    public:
01689 //      static void loadVec
01690 //        (QuantityVectorTuple<L> &tuple, Archive &ar, int &_size) 
01691 //      {
01692 //        LoadVec<N-1,L,Archive>::loadVec (tuple, ar, _size);
01693 //        typename Loki::TL::TypeAt<L, N-1>::Result 
01694 //                              vec;
01695 //        ar >> BOOST_SERIALIZATION_NVP(vec);
01696 //        if (vec.size () == _size)
01697 //          Loki::Field<N-1>(tuple.vectors) = vec;
01698 //        else
01699 //          {throw VectorSizeError("vector has wrong size!");}
01700 //      }
01701 //  };
01702 //
01705 //    does nothing else.
01706 //*/
01707 //template<class L, typename Archive>
01708 //  class LoadVec<0, L, Archive>
01709 //  {
01710 //    public:
01711 //      static void loadVec (QuantityVectorTuple<L> &, Archive &, int &) {}
01712 //  };
01713 //
01716 //*/
01717 //template <class V, class QVT> struct CheckVariableInVectorTuple;
01718 //
01721 //*/
01722 //template<template<typename, typename> class T, typename V, typename QT, 
01723 //                                typename ST, typename SU, typename LTail>
01724 //  struct CheckVariableInVectorTuple<V,
01725 //    Loki::Typelist<QuantityVector<T, Quantity <QT, ST>, SU>, LTail> >
01726 //  {
01727 //    private:
01728 //      typedef typename BSUtilities::IF<BSUtilities::SameType<V,
01729 //        typename QuantityVector<T, Quantity<QT, ST>, SU>::V>::sameType,
01730 //          QuantityVector<T, Quantity<QT, ST>, SU>,
01731 //           typename CheckVariableInVectorTuple<V, LTail>::RET>::RET RET;
01732 //  };
01733 //
01736 //    ends recursion; this means that V has not been found in
01737 //    the list of QuantityVectors in the tuple, and an error message
01738 //    should be given by the compiler, since no definition of
01739 //    VariableError exists
01740 //*/
01741 //template<typename V>
01742 //  struct CheckVariableInVectorTuple<V, Loki::NullType>
01743 //  {
01744 //    typedef VariableError<true> RET;
01745 //  };
01746 //
01747 
01749 //
01750 //  the VariableVector tuple
01751 //
01753 
01755 
01763 template<typename QT, typename ST, typename DQSU, typename DQT, typename LTail>
01764   class VariableVectorTuple<Loki::Typelist<
01765     VariableVector<QuantityVector<QT, ST>, 
01766                                      DerivedQuantity<QT, DQSU, DQT> >, LTail> >
01767       : public Loki::Tuple<Loki::Typelist<
01768         VariableVector<QuantityVector<QT, ST>, 
01769                                      DerivedQuantity<QT, DQSU, DQT> >, LTail> >
01770   {
01771   private:
01773 //  check the elements in a variable vector typelist
01776 
01778     template<typename VV, typename L>
01779       struct CheckVariableVectorList;
01780 
01782 
01785     template<typename CQT, typename CST, typename CDQSU, typename CDQT, 
01786                                                           typename CLTail>
01787       struct CheckVariableVectorList<VariableVector<QuantityVector<CQT, CST>, 
01788                                   DerivedQuantity<CQT, CDQSU, CDQT> >, CLTail>
01789     {
01790       private:
01791         typedef VariableVector<QuantityVector<CQT, CST>, 
01792                                   DerivedQuantity<CQT, CDQSU, CDQT> > VV;
01793       public:
01794         typedef typename Loki::Typelist<VV, 
01795           typename CheckVariableVectorList<typename CLTail::Head, 
01796                                      typename CLTail::Tail>::Result> Result;
01797     };
01798 
01800 
01803     template<typename CQT, typename CST, typename CDQSU, typename CDQT>
01804       struct  CheckVariableVectorList<VariableVector<QuantityVector<CQT, CST>, 
01805                     DerivedQuantity<CQT, CDQSU, CDQT> >, Loki::NullType>
01806     {
01807       typedef Loki::Typelist<VariableVector<QuantityVector<CQT, CST>,
01808                     DerivedQuantity<CQT, CDQSU, CDQT> >, Loki::NullType> Result;
01809     };
01810 
01812 //  determine the variables in a variable vector type list
01815 
01820     template<class TL> struct GetVar;
01821 
01823 
01829     template<class Head, class Tail> struct GetVar<Loki::Typelist<Head, Tail> >
01830     {
01831       private:
01832         typedef typename GetVar<Tail>::Result L1;
01833 
01834       public:
01835         typedef Loki::Typelist<typename Head::V, L1> Result;
01836     };
01837 
01839 
01841     template<class Head>
01842       struct GetVar<Loki::Typelist<Head, Loki::NullType> >
01843     {
01844       typedef Loki::Typelist<typename Head::V, Loki::NullType> Result;
01845     };
01846 
01848 class UnequalElementNumber;
01849 
01851 // store values at end of vectors
01854 
01861 template<int N, typename L, typename L1>
01862   struct PushBack
01863   {static void pushBack 
01864     (VariableVectorTuple<typename BSUtilities::IF<
01865       (int(Loki::TL::Length<L>::value) == int(Loki::TL::Length<L1>::value)), 
01866         L, UnequalElementNumber>::RET> &tuple, 
01867                                            const Loki::Tuple<L1> &new_values)
01868      {Loki::Field<N-1>((dynamic_cast<const Loki::Tuple<L> &>(tuple))).push_back 
01869                                          (Loki::Field<N-1>(new_values));
01870        PushBack<N-1, L, L1>::pushBack (tuple, new_values);
01871      }
01872   };
01873 
01875 
01878 template<typename L, typename L1>
01879   struct PushBack<0, L, L1>
01880   {static void pushBack (VariableVectorTuple<L> &,
01881            const Loki::Tuple<L1> &) {};
01882   };
01883 
01885 // insert values into vectors
01888 
01891 template<int N, typename L, typename L1>
01892   struct Insert
01893   {
01894     public:
01895       static void insert (VariableVectorTuple<typename BSUtilities::IF<
01896       (int(Loki::TL::Length<L>::value) == int(Loki::TL::Length<L1>::value)), 
01897         L, UnequalElementNumber>::RET>  &tuple, 
01898         const Loki::Tuple<L> 
01899           &new_values, const typename VariableVectorTuple<L>::size_type index)
01900         {Loki::Field<N-1>(tuple.vectors).insert 
01901           (Loki::Field<N-1>(dynamic_cast<const Loki::Tuple<L> &>(tuple)), 
01902                                                           index);
01903          Insert<N-1, L, L1>::insert (tuple, new_values, index);
01904         }
01905   };
01906 
01908 
01911 template<typename L, typename L1>
01912   struct Insert<0, L, L1>
01913   {static void insert (VariableVectorTuple<L> &, const Loki::Tuple<L1> &, 
01914                        const typename VariableVectorTuple<L>::size_type) {};
01915   };
01916 
01918 
01922 template<int N, typename L>
01923   struct GetVal
01924   {
01926     static void getval (const VariableVectorTuple<L> &tuple, 
01927       typename VariableVectorTuple<L>::QuantityTuple *values, 
01928                  const typename VariableVectorTuple<L>::size_type index)
01929     {Loki::Field<N-1>(*values) 
01930            = Loki::Field<N-1>(dynamic_cast<const Loki::Tuple<L> &>(tuple))
01931                                                                   [index];
01932      GetVal<N-1, L>::getval (tuple, values, index);
01933     }
01934   };
01935 
01937 
01940 template<typename L>
01941   struct GetVal<0, L>
01942   {
01943     static void getval (const VariableVectorTuple<L> &, 
01944       typename VariableVectorTuple<L>::QuantityTuple *, 
01945                            const typename VariableVectorTuple<L>::size_type) {}
01946   };
01947 
01949 
01953 template<int N, typename L>
01954   struct GetValAt
01955   {
01957     static void getval (const VariableVectorTuple<L> &tuple, 
01958       typename VariableVectorTuple<L>::QuantityTuple *values, 
01959               const typename VariableVectorTuple<L>::size_type index)
01960     {Loki::Field<N-1>(*values) 
01961       = Loki::Field<N-1>(dynamic_cast<const Loki::Tuple<L> &>
01962                                                     (tuple)).at(index);
01963      GetValAt<N-1, L>::getval (tuple, values, index);
01964     }
01965   };
01966 
01968 
01971 template<typename L>
01972   struct GetValAt<0, L>
01973   {
01974     static void getval (const VariableVectorTuple<L> &, 
01975       typename VariableVectorTuple<L>::QuantityTuple 
01976           *values, const typename VariableVectorTuple<L>::size_type) {}
01977   };
01978 
01980 
01983 template<int N, typename L, typename SL>
01984   struct Assign
01985   {
01986     static void assign (VariableVectorTuple<typename BSUtilities::IF< 
01987     (int(Loki::TL::Length<L>::value) == int(Loki::TL::Length<SL>::value)), 
01988                     L, UnequalElementNumber>::RET> &target, 
01989                      const VariableVectorTuple<SL> &source)
01990     {
01991       Loki::Field<N-1>(dynamic_cast<VariableVectorTuple<L> &>(target))
01992         = Loki::Field<N-1>(dynamic_cast<const 
01993                                          VariableVectorTuple<SL> &>(source));
01994       Assign<N-1, L, SL>::assign (target, source);
01995     }
01996   };
01997 
01998 
02000 
02002 template<typename L, typename SL>
02003   struct Assign<0, L, SL>
02004     {static void assign (VariableVectorTuple<L> &, 
02005                                       const VariableVectorTuple<SL> &) {}};
02006 
02007 
02009 //  types
02011   private:
02013     typedef typename CheckVariableVectorList<VariableVector<
02014       QuantityVector<QT, ST>, DerivedQuantity<QT, DQSU, DQT> >, 
02015                                                   LTail>::Result L;
02016 
02018     typedef VariableVectorTuple<L> VVT;
02019 
02020   public:
02022     typedef std::size_t size_type;
02023 
02025 
02029     typedef Loki::Tuple<typename GetVar<L>::Result> QuantityTuple;
02030 
02032 // construction
02034 public:
02036   VariableVectorTuple (void) {}
02037 
02039 
02041   VariableVectorTuple (const size_type n)
02042   {QuantityTuple tuple;
02043    for (size_type i = 0; i < n; ++i)
02044      push_back (tuple);
02045   }
02046 
02048 
02050   VariableVectorTuple (const size_type n, const QuantityTuple &tuple)
02051   {for (size_type i = 0; i < n; ++i)
02052      push_back (tuple);
02053   }
02054 
02056 // copy construction
02058 public:
02060 
02064   template<typename SL>
02065     VariableVectorTuple (const VariableVectorTuple<SL> &tuple) 
02066     {for (size_type i = 0; i < tuple.size (); ++i)
02067        push_back (tuple.at(i));
02068     }
02069 
02070 // copy elements between begin and end ... (needs iterator!) ...
02071 
02073 // comparisons
02076 #define VARIABLEVECTORTUPLE_COMPARE_REC(opType, recName) \
02077 static bool recName (const VariableVectorTuple<typename BSUtilities::IF< \
02078   (int(Loki::TL::Length<L1>::value) == int(Loki::TL::Length<L2>::value)), \
02079     L1, UnequalElementNumber>::RET> &tuple1, \
02080                                  const VariableVectorTuple<L2> &tuple2) \
02081    {return (Compare<N-1, L1, L2>::equal (tuple1, tuple2) && \
02082      Loki::Field<N-1>((dynamic_cast<const Loki::Tuple<L1> &>(tuple1))) \
02083        opType (Loki::Field<N-1>((dynamic_cast<const \
02084                                        Loki::Tuple<L2> &>(tuple2))))); \
02085      } 
02086 
02087 template<int N, typename L1, typename L2> 
02088   struct Compare 
02089   {
02090     VARIABLEVECTORTUPLE_COMPARE_REC(==, equal)
02091     VARIABLEVECTORTUPLE_COMPARE_REC(!=, notEqual)
02092     VARIABLEVECTORTUPLE_COMPARE_REC(>, greaterThan)
02093     VARIABLEVECTORTUPLE_COMPARE_REC(<, lessThan)
02094     VARIABLEVECTORTUPLE_COMPARE_REC(>=, greaterEqual)
02095     VARIABLEVECTORTUPLE_COMPARE_REC(<=, lessEqual)
02096   }; 
02097 
02098 #define VARIABLEVECTORTUPLE_COMPARE_RECEND(recName) \
02099 static bool recName (const VariableVectorTuple<L1> &, \
02100            const VariableVectorTuple<L2> &) {return true;} 
02101 
02102 template<typename L1, typename L2> 
02103   struct Compare<0, L1, L2> 
02104   {
02105     VARIABLEVECTORTUPLE_COMPARE_RECEND(equal)
02106     VARIABLEVECTORTUPLE_COMPARE_RECEND(notEqual)
02107     VARIABLEVECTORTUPLE_COMPARE_RECEND(greaterThan)
02108     VARIABLEVECTORTUPLE_COMPARE_RECEND(lessThan)
02109     VARIABLEVECTORTUPLE_COMPARE_RECEND(greaterEqual)
02110     VARIABLEVECTORTUPLE_COMPARE_RECEND(lessEqual)
02111   }; 
02112 
02113 #define VARIABLEVECTORTUPLE_COMPARISON_OPERATORS(opName, recName) \
02114 template<typename SL> \
02115   bool opName (const VariableVectorTuple<SL> &rhs) const \
02116   {return Compare<Loki::TL::Length<L>::value, L, SL>::recName \
02117                                                         (*this, rhs);} 
02118 
02119 VARIABLEVECTORTUPLE_COMPARISON_OPERATORS(operator==, equal)
02120 VARIABLEVECTORTUPLE_COMPARISON_OPERATORS(operator!=, notEqual)
02121 VARIABLEVECTORTUPLE_COMPARISON_OPERATORS(operator>, greaterThan)
02122 VARIABLEVECTORTUPLE_COMPARISON_OPERATORS(operator<, lessThan)
02123 VARIABLEVECTORTUPLE_COMPARISON_OPERATORS(operator>=, greaterEqual)
02124 VARIABLEVECTORTUPLE_COMPARISON_OPERATORS(operator<=, lessEqual)
02125 
02127 // assignment 
02130 
02132 template<typename SL>
02133   VariableVectorTuple & operator= (const VariableVectorTuple<SL> &tuple)
02134   {Assign<Loki::TL::Length<L>::value, L, SL>::assign (*this, tuple);
02135   return *this;}
02136 
02138 // element access
02141 
02144   QuantityTuple at (const size_type index) const
02145     {QuantityTuple values;
02146      GetValAt<Loki::TL::Length<L>::value, L>::getval
02147                                                  (*this, &values, index);
02148      return values;
02149     }
02150 
02152 
02155   QuantityTuple operator[] (const size_type index) const
02156     {QuantityTuple values;
02157      GetVal<Loki::TL::Length<L>::value, L>::getval(*this, &values, index);
02158      return values;
02159     }
02160 
02162   QuantityTuple front (void) const {return (*this).at(0);}
02163 
02165   QuantityTuple back (void) const {return (*this).at((*this).size() - 1);}
02166 
02168 // other functionality
02171     size_type number (void) const {return Loki::TL::Length<L>::value;}
02172 
02174 /*  all vectors have the same size, return value determined from
02175     first vector.
02176 */
02177     size_type size (void) const 
02178      {return Loki::Field<0>(*(dynamic_cast<const Loki::Tuple<L> *>
02179                                                        (this))).size ();}
02180 
02182 /*  uses data from a QTuple; uses helper class PushBack.
02183 */
02184     template<typename L1>
02185       void push_back (const Loki::Tuple<L1> &new_values)
02186       {PushBack<Loki::TL::Length<L>::value, L, L1>::pushBack 
02187                                                      (*this, new_values);}
02188 
02191 //*/
02192 //    void insert (const QTuple &new_values, const int index)
02193 //    {
02194 //      AddVal<Loki::TL::Length<L>::value, L>::addval 
02195 //                                             (*this, new_values, index);
02196 //    }
02197 //
02200 //*/
02201 //    void erase (const int index)
02202 //    {
02203 //      EraVal<Loki::TL::Length<L>::value, L>::eraval (*this, index);
02204 //    }
02205 //
02208 //*/
02209 //      bool operator== (const QuantityVectorTuple &tuple) const
02210 //        {return CmpVec<Loki::TL::Length<L>::value, L>::cmpVec 
02211 //                                                        (*this, tuple);}
02212 
02215 //    position index.
02216 //*/
02217 //    template<int I>
02218 //      typename Loki::TL::TypeAt<L, I>::Result::V 
02219 //                                  value (const unsigned int index) const
02220 //                      {return (Loki::Field<I>((*this).vectors))[index];}
02221 //
02224 //    should be taken. This, consequently, also defines the return type
02225 //    of the function, since this vector is associated with a certain 
02226 //    Variable<> type. The return type is determined by the base 
02227 //    quantity BQ of this Variable (in turn retrieved from the typelist 
02228 //    of the enclosing QuantityVectorTuple, at position I), and the new 
02229 //    unit, in which the value should be returned. Index I iterates over 
02230 //    a, possibly, inhomogeneous collection of QuantityVectors. 
02231 //    The second index index defines the position of the requested values
02232 //    in the QuantityVector. This collection is homogeneous, all values
02233 //    are returned in the same type. Thus, index does not change the 
02234 //    return type, but only defines the numerical value of the result.
02235 //    The difference between the two accessing indices is reflected in 
02236 //    their respective treatment as a template argument (which must be 
02237 //    fixed at compile time, thus fixing the return type) and a function 
02238 //    argument (not fixed), respectively. The value is converted into
02239 //    unit. The conversion routine of variables checks that NU is of an
02240 //    appropriate type.
02241 //*/
02242 //    template<int I, class NU>
02243 //      T<typename Loki::TL::TypeAt<L, I>::Result::V::BQ, NU> 
02244 //        value (const int index, const NU &unit) const
02245 //          {return 
02246 //               ((Loki::Field<I>((*this).vectors)).value (index))(unit);}
02247 //
02250 //    values located in the vectors of the QuantityVectorTuple, at
02251 //    position index respectively.
02252 //*/
02253 //    QTuple operator[] (const int index) const
02254 //    {
02255 //      QTuple values;
02256 //      return GetVal<Loki::TL::Length<L>::value, L>::getval 
02257 //                                                 (*this, values, index);
02258 //    }
02259 //
02262 //*/
02263 //    QTuple values (const int index) const {return (*this)[index];}
02264 //
02266 //    template<int I>
02267 //      QuantityVector<T, typename Loki::TL::TypeAt<L, I>::Result::V::BQ,
02268 //        typename Loki::TL::TypeAt<L, I>::Result::V::Unit> 
02269 //                                     getVector (Loki::Int2Type<I>) const
02270 //      {return QuantityVector<T, 
02271 //        typename Loki::TL::TypeAt<L, I>::Result::V::BQ,
02272 //          typename Loki::TL::TypeAt<L, I>::Result::V::Unit> 
02273 //                                     (Loki::Field<I>((*this).vectors));}
02274 //
02276 //    template<int N, class L1> friend class AddVal;
02277 //     
02278 //    template<int N, class L1> friend class GetVal;
02279 //     
02280 //    template<int N, class L1> friend class EraVal;
02281 //     
02282 //    template<int N, class L1> friend class CmpVec;
02283 //     
02284 //    template<int N, class L1> friend class Copy;
02285 //     
02286 //    template<int N, class L1> friend class Assign;
02287 //
02288 //    template<int N, class L1, typename Archive> friend class SaveVec;
02289 //    template<int N, class L1, typename Archive> friend class LoadVec;
02290 //
02291 // private:
02293 //      friend class boost::serialization::access;
02294 //
02297 //    of the Tuple; NOTE: QuantityVectorTuple is not auto registered with
02298 //    the serialization library, since it is not a derived class and can
02299 //    not be serialized through a base class;
02300 //    before any of the vectors, the (for all vectors in the tuple identical)
02301 //    size is stored; this is needed by the load routine to assure that
02302 //    all vectors have the same number of elements. 
02303 //*/
02304 //      template<typename Archive>
02305 //        void save (Archive &ar, const unsigned int ) const
02306 //        {
02307 //          int _size = size ();
02308 //          ar << BOOST_SERIALIZATION_NVP (_size);
02309 //          SaveVec<Loki::TL::Length<L>::value, L, Archive>
02310 //                                         ::saveVec (*this, ar);
02311 //        }
02312 //
02315 //    of the Tuple; NOTE: QuantityVectorTuple is not auto registered with
02316 //    the serialization library, since it is not a derived class and can
02317 //    not be serialized through a base class;
02318 //    before any of the vectors is read, the variable _size is retrieved;
02319 //    this is the size of all of the vectors and must be equal for each
02320 //    vector in the tuple. 
02321 //*/
02322 //      template<typename Archive>
02323 //        void load (Archive &ar, const unsigned int )
02324 //        {
02325 //          int _size;
02326 //          ar >> BOOST_SERIALIZATION_NVP (_size);
02327 //          LoadVec<Loki::TL::Length<L>::value, L, Archive>
02328 //                                         ::loadVec (*this, ar, _size);
02329 //        }
02330 //
02331 //BOOST_SERIALIZATION_SPLIT_MEMBER()
02332 
02333   };
02334 
02336 // global functions
02339 
02342 template<typename QT, typename ST, typename SU, typename DQT>
02343 void swap (VariableVector<QuantityVector<QT, ST>, 
02344   DerivedQuantity<QT, SU, DQT> > &vector1, 
02345     VariableVector<QuantityVector<QT, ST>, DerivedQuantity<QT, SU, DQT> > 
02346                                                                  &vector2)
02347   {vector1.swap (vector2);}
02348 
02350 
02352 template<typename QT, typename ST, typename SU, typename DQT,
02353                   typename SQT, typename SST, typename SSU, typename SDQT>
02354 void swap (VariableVector<QuantityVector<QT, ST>, 
02355   DerivedQuantity<QT, SU, DQT> > &vector1, 
02356     VariableVector<QuantityVector<SQT, SST>, 
02357                               DerivedQuantity<SQT, SSU, SDQT> > &vector2)
02358   {vector1.swap (vector2);}
02359 
02360 } // end namespace quantity
02361 
02362 #endif /* _QuantityAggregates */