source: XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp @ 130

#ifndef __FIELD__
#define __FIELD__

using XMLIOSERVER::XML::XMLNode;
using XMLIOSERVER::XML::THashAttributes;

namespace XMLIOSERVER
{
   class CGrid; // CGRID = CDOMAINE + CAXIS
   class CFile;

   class CField : public ObjectTemplate<CField>, public FieldAttribut
   {
      public:

         CField(void) : ObjectTemplate<CField>(), FieldAttribut(), lastStored(NULL), grid(NULL), file(NULL)
         {/* Ne rien faire de plus */}
         CField(const string& _id) : ObjectTemplate<CField>(_id), FieldAttribut(), lastStored(NULL), grid(NULL), file(NULL)
         {/* Ne rien faire de plus */}

         inline void solveGridRef(void) ;

         const CGrid* getGrid(void) const { return (grid); }
         const Array<double, 1>& getData(void) const { return (data); }

         void initLastStoredDate(const Date& _newlastStored)
         { if(lastStored == NULL) lastStored = new Date(_newlastStored); };

         bool isStorable(const Date& currDate)
         {
            if (lastStored == NULL) return (false);
            if (freq_op.hasValue())
               return (currDate >= (*lastStored + (Duration)freq_op));
            return (true);
         }

         void storeData(const Array<double, 1> & arr, const Date& currDate)
         {
            *lastStored = currDate;
            data.resize(shape(arr.size())) ;
            data = arr;
         }

         void solveOperation(void)
         {
            FieldOperation*   fope = this->operation.getValue();
            Duration      *  ffope = this->freq_op.getValue();

            if (fope != NULL)
            { // Si une opération sur le champ est définie ...
               if (fope->getId().compare("once") == 0)
                  this->freq_op.setValue(NoneDu);
            }
            else
            { // Si aucune opération sur le champ n'est définie ...
               FieldOperation ope("inst");
               this->operation.setValue(ope);
            }

            // Si la fréquence d'opération n'est pas définie, on l'initialise à 0s.
            // Une fréquence à 0s signifie que l'opération se fera à chaque écriture de données depuis la simulation.
            if (ffope == NULL)
               this->freq_op.setValue(NoneDu);

            this->operation.getValue()->setFreqOp(this->freq_op);
         }

         const CFile* getRelFile(void) const { return (file); }
         void setRelFile(CFile* _file) { file = _file; }

      public: /* virtual */

         virtual CField* getReference(void) const
         {
            if(!field_ref.hasValue()) return (NULL);
            if (!CField::HasObject(field_ref))
            { WARNING("Référence invalide sur l'objet "+GetName()+" nommé \""+((string)field_ref)+"\""); return (NULL); }

            return (CField::GetObject(field_ref));
         }

         virtual ~CField(void)
         { if(lastStored !=  NULL) delete lastStored; }

      public: /* static */

         static string GetName(void) { return ("field"); }
         static string GetDefName(void)  { return (CField::GetName()); }

      private :

         Date* lastStored;

         CGrid* grid ;
         CFile* file;

         Array<double, 1>  data;

   }; // class CField

} // namespace XMLIOSERVER

DECLARE_GROUP(Field)

/* Pour la gestion des références aux groupes de champs */
namespace XMLIOSERVER
{
   template <>
      CField& GroupTemplate<CField, FieldAttribut>::createChildRef(const CField* const _ori)
   {
      if (!_ori->hasId())
         throw (new XMLIOUndefinedValueException("Impossible de créer une référence à un élément sans identifiant !"));

      CField& obj = *ObjectTemplate<CField>::CreateObject();
      obj.field_ref = _ori->getId();
      childList.addObject(&obj);
      return (obj);
   }

   template <>
      void GroupTemplate<CField, FieldAttribut>::solveRefInheritance (void)
   {
      std::vector<CField*> _allf ;

      if(!group_ref.hasValue() || (GetName().compare("field_group") != 0)) return;
      if (!GroupTemplate<CField, FieldAttribut>::HasObject(group_ref))
      { WARNING("Référence invalide sur l'objet "+GetName()+" nommé \""+((string)group_ref)+"\""); return; }

      const GroupTemplate<CField, FieldAttribut>* const gref
               = GroupTemplate<CField, FieldAttribut>::GetObject(group_ref);

      gref->getAllChildren(_allf);
      std::vector<CField*>::iterator it ;
      for ( it = _allf.begin() ; it != _allf.end(); it++ )
         this->createChildRef(*it);
   }


} // namespace XMLIOSERVER

#endif // __FIELD__