source: XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp @ 138

#ifndef __ATTRIBUT__
#define __ATTRIBUT__

#include "base_attribut.hpp"

using XMLIOSERVER::BaseAttribut;
using std::ostringstream;
using namespace blitz ;

namespace XMLIOSERVER
{
   template <class Ctype>
      class Attribut : public BaseAttribut
   {
      public :

         Attribut(void)
            : BaseAttribut(), _hasValue(false), value()
         { /* Ne rien faire de plus */ }

         Attribut(const Ctype& value_)
            : BaseAttribut(), _hasValue(true), value(value_)
         { /* Ne rien faire de plus */ }

         Attribut(const Attribut& attr)
            : BaseAttribut(attr), _hasValue(attr._hasValue)
         { if (_hasValue) value = attr.value ; }

         Attribut& operator = (const Attribut & attr)
         {
            _hasValue = attr._hasValue ;
            if (_hasValue) this->setValue(attr.value) ;
            return (*this) ;
         }

         operator Ctype() const
         {
            if (!_hasValue)
               XMLIOError("L'attribut \"" + this->getName() + "\" est invalide !");
            return (value) ;
         }

         Ctype* getValue(void)
         {
            //if (!_hasValue) return(NULL); // REVOIR: 4 h de debug à cause de ça !!!
            return (&value);
         }

         const Ctype * getValueConst(void) const
         {
            //if (!_hasValue) return(NULL); // REVOIR: 4 h de debug à cause de ça !!!
            return (&value);
         }

         Ctype* operator ->(void) { return (&value); }
         Ctype& operator * (void) { return (value) ; }

      public : /* virtual */

         virtual bool hasValue(void) const { return (_hasValue); }
         virtual const char * getType(void) const = 0;

         virtual void setFromString(const std::string& str)
         {
            istringstream iss(str); Ctype val;
            iss >> val;
            this->setValue(val);
         }

         virtual void assignValue(const BaseAttribut* _ba)
         { value = ((Attribut*)_ba) -> value; _hasValue = true; }

         virtual ostream& print(std::ostream & _out) const
         {
            if (_hasValue)
            {
               _out << " " << getName()
                    << "=\"" << boolalpha << value << "\"" ;
            }
            return (_out) ;
         }

         virtual void setValue(const Ctype & value_)
         { _hasValue = true ; value = value_ ;}

         virtual void getValue(Ctype & value_) const
         {
            if (!_hasValue) XMLIOError("L'attribut \"" + this->getName() + "\" est invalide !");
            value_ = value ;
         }

         virtual ~Attribut(void)
         { /* Ne rien faire de plus */ }

      private :

         bool _hasValue ;
         Ctype value ;

   }; // class Attribut

#define SET_ARRAY_DIM(type, dim)                                             \
   template<>                                                                \
      void Attribut<Array<type,dim> >::setValue (const Array<type,dim>& val) \
   { _hasValue = true ; value.resize(val.shape()); value = val ; }

#define PRINT_ARRAY1(type)                                            \
   template <>                                                        \
      ostream& Attribut<Array<type, 1> >::print(ostream & _out) const \
   {                                                                  \
      if (_hasValue)                                                  \
      _out << " " << getName() << "=\"" << value(0)                   \
           << "(" << value.extent(0) << ")"                           \
           << value(value.size()-1); _out << "\"" ;                   \
      return (_out) ;                                                 \
   }

#define PRINT_ARRAY2(type)                                            \
   template <>                                                        \
      ostream& Attribut<Array<type, 2> >::print(ostream & _out) const \
   {                                                                  \
      if (_hasValue)                                                  \
      _out << " " << getName() << "=\"" << value(0, 0)                \
           << "(" << value.extent(0) << "," << value.extent(1) << ")" \
           << value(value.extent(0)-1, value.extent(1)-1)             \
           << "\"" ;                                                  \
      return (_out) ;                                                 \
   }

#define SET_ARRAY_TYPE(type) \
   PRINT_ARRAY1(type)        \
   PRINT_ARRAY2(type)        \
   SET_ARRAY_DIM(type, 1)    \
   SET_ARRAY_DIM(type, 2)    \
   SET_ARRAY_DIM(type, 3)    \
   SET_ARRAY_DIM(type, 4)

   SET_ARRAY_TYPE(double)
   SET_ARRAY_TYPE(float)
   SET_ARRAY_TYPE(int)
   SET_ARRAY_TYPE(bool)

#undef SET_ARRAY_DIM
#undef SET_ARRAY_TYPE
#undef PRINT_ARRAY

   template <>
      void Attribut<Array<double, 1> >::setFromString(const std::string& _str)
   {
      istringstream iss(_str) ;
      char c = '\0'; int size = 0;
      double d = 0.,valsup = 0., valinf = 0.;
      std::vector<double> vect; Array<double, 1> arr;

      iss >> d; vect.push_back(d);
      if (!iss.eof ())
      {
         iss >> c;
         switch (c)
         {
            case ',' : // Le tableau est généré valeur par valeur.
               iss.unget();
               while(!iss.eof ())
               { // On récupÚre chacune des valeurs une par une jusqu'à ce que le buffer soit vide.
                  iss >> c >> d;
                  if (c != ',')
                     XMLIOError("Le tableau de valeur est mal défini !");
                  vect.push_back(d);
               }
               size = vect.size();
               break;
            case '(' : // Le tableau est généré automatiquement.
               if (!iss.eof ())
               { // on récupÚre la borne supérieure
                  valinf = d;
                  iss >> size >> c >> d;
                  if ((c != ')') || (size <= 0))
                     XMLIOError("Le tableau de valeur est mal défini !");
                  valsup = d;
               }
               d = (valsup - valinf) / (double)(size - 1);
               for (int j = 1; j <= size; j++)
                  vect.push_back(valinf + j * d);
               break;
            default :
               XMLIOError("Le tableau de valeur est mal défini !");
         }
      }

      arr.resize(size);
      for (int i = 0; i < size; i++)
         arr(i) = vect[i];

      this->setValue(arr);
   }

   template <>
      void Attribut<bool>::setFromString(const std::string& str)
   {
      const bool val =
          (str.compare(string(".TRUE.")) == 0) ? true : false;
      this->setValue(val);
   }

   template <>
      void Attribut<string>::setFromString(const std::string& str)
   { this->setValue(str); }

} // namespace XMLIOSERVER

#endif //__ATTRIBUT__