QuantityCluster.h

Go to the documentation of this file.

/* Copyright (C) 2003 - 2006, 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 "xmlwriter.h"
#include "xmlReader.h"
#include <tinyxml/tinyxml.h>

#include <vector>

namespace quantity {

//
//  the QuantityVector abstract base class
//


template<class Q> class QuantityVector;


template<class DIM, class BT, class UL, class DU, class ST>
                    class QuantityVector<Quantity<DIM, BT, UL, DU, ST> >
  {
    private:
      typedef Quantity<DIM, BT, UL, DU, ST> Q;

    public:
      static const std::string TAG;

      static const std::string IDTAG;
      static const std::string QTAG;
      static const std::string UTAG;
      static const std::string DTAG;
      static const std::string VTAG;
  };

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string QuantityVector<Quantity<DIM, BT, UL, DU, ST> >::TAG
                                                     = "quantityVector";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string QuantityVector<Quantity<DIM, BT, UL, DU, ST> >
                                                         ::IDTAG = "ID";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string QuantityVector<Quantity<DIM, BT, UL, DU, ST> >
                                                    ::QTAG = "quantity";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string QuantityVector<Quantity<DIM, BT, UL, DU, ST> >
                                                    ::UTAG = "unit";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string QuantityVector<Quantity<DIM, BT, UL, DU, ST> >
                                                    ::VTAG = "value";

template<class DIM, class BT, class UL, class DU, class ST>
  const std::string QuantityVector<Quantity<DIM, BT, UL, DU, ST> >
                                                    ::DTAG = "data";

//
//  the VariableVector 
//


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


template<class BT, class DIM, class UL, class DU, class SU, class ST>
  class VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU>
                 : public QuantityVector<Quantity<DIM, BT, UL, DU, ST> >
  {
    private:
      typedef typename unit::CheckUnit<unit::Unit<BT>, SU>::Check Check;

    public:
      typedef Quantity<DIM, BT, UL, DU, ST> PQ;

      typedef Variable<Quantity<DIM, BT, UL, 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 size = new_vector.size ();
        values.reserve (size);

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


    void save (BSUtilities::xmlw::XmlStream &os) const
    {
      os << BSUtilities::xmlw::tag (TAG)
         << BSUtilities::xmlw::attr (IDTAG) << ID
           << BSUtilities::xmlw::attr (QTAG) << PQ::Name ()
           << BSUtilities::xmlw::attr (UTAG) << SU::Name ();

      for (int i = 0; i < size (); i++)
         os << BSUtilities::xmlw::tag (DTAG) 
            << BSUtilities::xmlw::attr (VTAG) << values[i] 
                                        << BSUtilities::xmlw::endtag ();

      os << BSUtilities::xmlw::endtag (TAG);
    }


    void load (const TiXmlHandle node)
    {
       TiXmlElement *element = node.Element();
        if (element
          && (element->ValueStr () == TAG)
                                   && (element->Attribute(IDTAG) == ID))
        {
// load Quantity
// load unit
          TiXmlNode *child = 0;

          std::string value;

          while (child = element->IterateChildren (DTAG, child))
          {
            if ((child->ToElement ())->Attribute (VTAG))
            {
              value = (child->ToElement ())->Attribute (VTAG);
              values.push_back 
                (BSUtilities::Conversion<ST>::string_to(value));
            }
          }
        }
        else
          throw LoadError
                    ("error loading QuantityVector: incorrect element");

    }


      bool operator== 
        (const VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU> 
                                                          &vector) const
      {
        return ((size () == vector.size ()) 
                                          && (values == vector.values));
      }


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


      template<template<class, class> class Q1, class BT1, class DIM1, 
                           class UL1, class DU1, class SU1, class ST1>
        void push_back (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST1>, 
                                                     SU1> &new_quantity)
          {values.push_back (Reverse<SU>::VAL
            (Standardize<typename
              CheckAgainstAllUnits<typename Q1<Quantity<DIM1, BT1,
                                             UL1, DU1, ST1>, SU1>::Unit,
              typename Loki::TL::Append<UL, unit::NonPrefixable<BT1, 
                    unit::GenericUnit> >::Result >::RET>::VAL
                                             (new_quantity.value ())));}


      template<template<class, class> class Q1, class BT1, class DIM1, 
                           class UL1, class DU1, class SU1, class ST1>
        void insert (const Q1<Quantity<DIM1, BT1, UL1,
                         DU1, ST1>, SU1> &new_quantity, const int index)
          {if (index >= 0 && index < size ())
            {typename std::vector<ST>::iterator pos 
                                              = values.begin () + index;
              values.insert (pos, Reverse<SU>::VAL
                (Standardize<typename
                   CheckAgainstAllUnits<typename Q1<Quantity<DIM1, BT1,
                                             UL1, DU1, ST1>, SU1>::Unit,
                  typename Loki::TL::Append<UL,
                    unit::NonPrefixable<BT1, 
                        unit::GenericUnit> >::Result >::RET>::VAL
                                              (new_quantity.value ())));
            }
          else
            {throw VectorOutOfBounds();}
        }                                                    


      template<template<class, class> class Q1, class BT1, class DIM1, 
                           class UL1, class DU1, class SU1, class ST1>
        void replace (const Q1<Quantity<DIM1, BT1, UL1, DU1, ST1>, SU1> 
                                         &new_quantity, const int index)
          {if (index >= 0 && index < size ())
            {values[index] = Reverse<SU>::VAL
              (Standardize<typename
                CheckAgainstAllUnits<typename Q1<Quantity<DIM1, BT1,
                                             UL1, DU1, ST1>, SU1>::Unit,
                typename Loki::TL::Append<UL,
                  unit::NonPrefixable<BT1,
                      unit::GenericUnit> >::Result >::RET>::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 ();}


      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<class NU>
        Variable<Quantity<DIM, BT, UL, 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<DIM, BT, UL, 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<DIM, BT, UL, DU, ST>, NU> 
                    min (const NU &unit) const {return (min ()) (unit);}


      static const std::string ID;

  };

template<class BT, class DIM, class UL, class DU, class SU, class ST>
const std::string VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU>::ID
                                                           = "Variable";


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).push_back 
                                         (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).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 (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 EraVal
  {
    public:
      static void eraval (VariableVectorTuple<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 (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;}
  };


template<int N, class L>
  class SaveVecType
  {
    public:
      static void saveVecType 
        (const VariableVectorTuple<L> &tuple, 
                                       BSUtilities::xmlw::XmlStream &os)
      {
        os << BSUtilities::xmlw::attr (VariableVectorTuple<L>::QTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
          << Loki::TL::TypeAt<L, N-1>::Result::PQ::Name ()
            << BSUtilities::xmlw::attr (VariableVectorTuple<L>::UTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
                     << Loki::TL::TypeAt<L, N-1>::Result::Unit::Name ();
        SaveVecType<N-1, L>::saveVecType (tuple, os);
      }
  };


template<class L>
  class SaveVecType<0, L>
  {
    public:
      static void saveVecType 
        (const VariableVectorTuple<L> &, 
                                      BSUtilities::xmlw::XmlStream &) {}
  };


template<int N, class L>
  class SaveVec
  {
    public:
      static void saveVec 
        (const VariableVectorTuple<L> &tuple, int index,
                                       BSUtilities::xmlw::XmlStream &os)
      {
        os << BSUtilities::xmlw::attr (VariableVectorTuple<L>::VTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
           << Loki::Field<N-1>(tuple.vectors)[index].value ();
        SaveVec<N-1, L>::saveVec (tuple, index, os);
      }
  };


template<class L>
  class SaveVec<0, L>
  {
    public:
      static void saveVec 
        (const VariableVectorTuple<L> &, int, 
                                      BSUtilities::xmlw::XmlStream &) {}
  };


template<int N, class L>
  class CheckQuantities
  {
    public:
      static bool checkQuantities
        (const VariableVectorTuple<L> &tuple, 
                                            const TiXmlElement *element)
      {
        if ((element->Attribute (VariableVectorTuple<L>::QTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
                       == Loki::TL::TypeAt<L, N-1>::Result::PQ::Name ())
          && (element->Attribute (VariableVectorTuple<L>::UTAG 
                          + BSUtilities::Conversion<int>::to_string (N))
                    == Loki::TL::TypeAt<L, N-1>::Result::Unit::Name ()))
          {return CheckQuantities<N-1, L>::checkQuantities 
                                                      (tuple, element);}

        else
          return false;
      }
  };


template<class L>
  class CheckQuantities<0, L>
  {
    public:
      static bool checkQuantities 
        (const VariableVectorTuple<L> &, const TiXmlElement *) 
                                                          {return true;}
  };


template<int N, class L, class ST>
  class LoadVec
  {
    public:
      static void loadvec 
        (VariableVectorTuple<L> &tuple, const TiXmlNode *child)
      {
        const TiXmlElement *element = child->ToElement();

        if (element->Attribute 
          (VariableVectorTuple<L>::VTAG 
                         + BSUtilities::Conversion<int>::to_string (N)))
        {
          Loki::Field<N-1>(tuple.vectors).push_back 
            (typename Loki::TL::TypeAt<L, N-1>::Result::V
              (BSUtilities::Conversion<ST>::string_to
                (element->Attribute (VariableVectorTuple<L>::VTAG 
                      + BSUtilities::Conversion<int>::to_string (N)))));
          LoadVec<N-1, L, ST>::loadvec (tuple, child);
        }

        else
          throw LoadError 
                ("error loading VariableVectorTuple: incorrect vector");

      }
  };


template<class L, class ST>
  class LoadVec<0, L, ST>
  {
    public:
      static void loadvec (VariableVectorTuple<L> &, const TiXmlNode *)
                                                                      {}
  };


template<int N, class L>
  class CmpVec
  {
    public:
      static bool cmpVec
        (const VariableVectorTuple<L> &tuple1, 
                                   const VariableVectorTuple<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 VariableVectorTuple<L> &, const VariableVectorTuple<L> &)
                                                          {return true;}
  };

//
//  the VariableVector tuple
//


template<class DIM, class BT, class UL, class DU, 
                                        class ST, class SU, class LTail>
  class VariableVectorTuple<Loki::Typelist<
             VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU>, LTail> >
  {
  private:
    typedef Loki::Typelist<VariableVector<
                           Quantity<DIM, BT, UL, DU, ST>, SU>, LTail> L;

    Loki::Tuple<L> vectors;

  public:

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


    void save (BSUtilities::xmlw::XmlStream &os) const
    {
      os << BSUtilities::xmlw::tag (TAG);

      SaveVecType<Loki::TL::Length<L>::value, L>::saveVecType 
                                                            (*this, os);

      for (int index = 0; index < size (); index++)
      {
        os << BSUtilities::xmlw::tag (VariableVectorTuple<L>::DTAG);
        SaveVec<Loki::TL::Length<L>::value, L>::saveVec 
                                                     (*this, index, os);
        os << BSUtilities::xmlw::endtag (DTAG);
      }

      os << BSUtilities::xmlw::endtag (TAG);
    }


    void load (const TiXmlHandle node)
    {
       TiXmlElement *element = node.Element();
        if (element && (element->ValueStr () == TAG))
        {
          if(CheckQuantities<Loki::TL::Length<L>::value, L>
                                     ::checkQuantities (*this, element))
          {
            TiXmlNode *child = 0;
            
            TiXmlElement *element = node.Element();

            while (child = element->IterateChildren (DTAG, child))
              {LoadVec<Loki::TL::Length<L>::value, L, ST>::loadvec 
                                                        (*this, child);}
          }

          else
            throw LoadError
              ("error loading VariableVectorTuple: "
                                                "incorrect attributes");
        }

        else
          throw LoadError
            ("error loading VariableVectorTuple: incorrect element");

    }


      bool operator== (const VariableVectorTuple &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 VariableTuple; uses helper class AddVal.
*/
    void push_back (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 insert (const VariableTuple &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 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 EraVal;
     
    template<int N, class L1> friend class SaveVec;
     
    template<int N, class L1> friend class CmpVec;
     
    template<int N, class L1, class ST1> friend class LoadVec;
     
    template<int N, class L1> friend class Copy;
     
    template<int N, class L1> friend class Assign;

      static const std::string TAG;
     
      static const std::string QTAG;
     
      static const std::string UTAG;
     
      static const std::string DTAG;
     
      static const std::string VTAG;
     
  };

template<class DIM, class BT, class UL, class DU, 
                                        class ST, class SU, class LTail>
  const std::string 
    VariableVectorTuple<Loki::Typelist<
      VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU>, LTail> >::TAG
                                                = "variableVectorTuple";

template<class DIM, class BT, class UL, class DU, 
                                        class ST, class SU, class LTail>
  const std::string 
    VariableVectorTuple<Loki::Typelist<
      VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU>, LTail> >::QTAG
                                                           = "quantity";

template<class DIM, class BT, class UL, class DU, 
                                        class ST, class SU, class LTail>
  const std::string 
    VariableVectorTuple<Loki::Typelist<
      VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU>, LTail> >::UTAG
                                                               = "unit";

template<class DIM, class BT, class UL, class DU, 
                                        class ST, class SU, class LTail>
  const std::string 
    VariableVectorTuple<Loki::Typelist<
      VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU>, LTail> >::DTAG
                                                               = "data";

template<class DIM, class BT, class UL, class DU, 
                                        class ST, class SU, class LTail>
  const std::string 
    VariableVectorTuple<Loki::Typelist<
      VariableVector<Quantity<DIM, BT, UL, DU, ST>, SU>, LTail> >::VTAG
                                                              = "value";

}

#endif /* _QuantityCluster */

---