Changeset 120 for XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp

Timestamp:

09/08/10 15:02:31 (14 years ago)

Author:

hozdoba

Message:

Mise à jour intermédiaire ...
A venir : commit d'une version stable intégrant l'écriture de fichiers NetCDF4.
(en cours de finalisation actuellement)

File:

• XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp (modified) (2 diffs)

XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp

@@ -7 +7 @@
 using XMLIOSERVER::XMLIOUndefinedValueException;
 using std::ostringstream;
+using namespace blitz ;
 
 namespace XMLIOSERVER
 {
-   class IStringStream_alt
-   {
-      public :
-         IStringStream_alt(const std::string& str) : iss(str)
-         { /* Ne rien faire de plus */}
-
-         istream& operator>> (std::string& s)
-         {s.assign(this->iss.str()); return (this->iss);}
-         istream& operator>> (int& s) { return (iss>>s); }
-         istream& operator>> (bool& s)
-         {
-            if(!this->iss.str().compare(string(".TRUE."))) s =  true;
-            else s = false;
-            return (this->iss);
-         }
-
-      private :
-         istringstream iss;
-
-   }; // class IStringStream_alt
-
-
    template <class Ctype>
       class Attribut : public BaseAttribut
    {
       public :
-
          operator Ctype() const
          {
-            if (!hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
+            if (!_hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
             return (value) ;
          }
 
-         virtual bool _hasValue() const { return (hasValue); }
+         Ctype* operator ->() { return (&value) ; }
+         Ctype& operator *() { return (value) ; }
 
-      protected :
+         virtual bool hasValue() const { return (_hasValue); }
+         virtual const char * getType(void) const = 0;
 
-         Attribut(void) : hasValue(false) {} ;
-         Attribut(const Ctype& value_) : hasValue(true), value(value_) {} ;
+         Attribut(void) : _hasValue(false) {} ;
+         Attribut(const Ctype& value_) : _hasValue(true), value(value_) {} ;
 
-         Attribut(const Attribut& attr) : hasValue(attr.hasValue)
-         {  if (hasValue) value=attr.value ; }
+         Attribut(const Attribut& attr) : _hasValue(attr._hasValue)
+         {  if (_hasValue) value = attr.value ; }
 
          Attribut& operator = (const Attribut & attr)
          {
-            hasValue=attr.hasValue ;
-            if (hasValue) value=attr.value ;
-            return *this ;
+            _hasValue = attr._hasValue ;
+            if (_hasValue) setValue(attr.value) ;
+            return (*this) ;
          }
 
-         virtual const char * getType(void) const = 0;
-
-         virtual void setFromString(const std::string str)
+         virtual void setFromString(const std::string& str)
          {
-            IStringStream_alt iss(str); Ctype val;
+            istringstream iss(str); Ctype val;
             iss >> val;
             this->setValue(val);
@@ -70 +48 @@
 
          virtual void assignValue(const BaseAttribut* _ba)
-         { value = ((Attribut*)_ba) -> value; hasValue = true; }
+         { value = ((Attribut*)_ba) -> value; _hasValue = true; }
 
          virtual ostream& print(ostream & o) const
-         { if (hasValue) o << " " << getName() << "=\"" << boolalpha << value << "\"" ; return o ; }
+         { if (_hasValue) o << " " << getName() << "=\"" << boolalpha << value << "\"" ; return o ; }
 
          virtual void setValue(const Ctype & value_)
-         { hasValue=true ; value=value_ ; }
+         { _hasValue = true ; value = value_ ;}
 
          virtual void getValue(Ctype & value_) const
          {
-            if (!hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
-            value_=value ;
+            if (!_hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
+            value_ = value ;
          }
 
       private :
 
-         bool hasValue ;
+         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 SET_ARRAY_TYPE(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(int)
+   SET_ARRAY_TYPE(bool)
+
+   template <>
+      void Attribut<bool>::setFromString(const std::string& str)
+   {
+      istringstream iss(str) ;
+      bool val = (! iss.str().compare(string(".TRUE."))) ? true : false;
+      this->setValue(val);
+   }
+
+   template <>
+      void Attribut<string>::setFromString(const std::string& str)
+   { this->setValue(str); }
+
 } // namespace XMLIOSERVER
 
 #endif //__ATTRIBUT__
-
-