source: XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp @ 137

#ifndef __CFILE__
#define __CFILE__

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

namespace XMLIOSERVER
{
   class CFile : public ObjectTemplate<CFile>, public FileAttribut
   {
      public:

         CFile(void)
            : ObjectTemplate<CFile>(), FileAttribut(),
              vfieldGroup(NULL), enabledFields(), output(NULL)
         { /* Ne rien faire de plus */ }

         CFile(const string& _id)
            : ObjectTemplate<CFile>(_id), FileAttribut(),
              vfieldGroup(NULL), enabledFields(), output(NULL)
         { /* Ne rien faire de plus */ }

         AbstractDataOutput*         getDataOutput       (void) const { return (output); }
         FieldGroup*                 getVirtualFieldGroup(void) const { return (vfieldGroup); }
         const std::vector<CField*>& getEnabledFields    (void) const { return (enabledFields); }

         FieldGroup * createVirtualFieldGroup(const std::string _id)
         {
            return (vfieldGroup == NULL)
               ? vfieldGroup = (FieldGroup*) FieldGroup::CreateObject(_id)
               : vfieldGroup;
         }

         void initializeDataOutput(AbstractDataOutput* _output)
         {
            if (_output != NULL) output = _output;
            else throw XMLIOSERVER::XMLIOUndefinedValueException
               ("Impossible d'initialiser la sortie de données pour le fichier nommé '"+ getId() +"'.") ;
         }

         void getAllFields(std::vector<CField*>& _allF) const
         {  if (vfieldGroup!=NULL) vfieldGroup->getAllChildren(_allF); }

         const std::set<const CGrid*> getEnabledGrids(void) const
         {
            std::set<const CGrid*> sgrid;
            const std::vector<CField*> enabledFields = this->getEnabledFields();
            std::vector<CField*>::const_iterator it;

            for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
               sgrid.insert((*it)->getGrid());

            return (sgrid);
         }

         const std::set<const FieldOperation*> getEnabledOperation(void) const
         {
            std::set<const FieldOperation*> sope;
            const std::vector<CField*> enabledFields = this->getEnabledFields();
            std::vector<CField*>::const_iterator it;

            for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
               if ((*it)->operation.hasValue())
                  sope.insert((*it)->operation.getValue());

            return (sope);
         }

         const std::set<const CDomain*> getEnabledDomains(void) const
         {
            const std::set<const CGrid*> sgrid = this->getEnabledGrids();
            std::set<const CDomain*> sdomain;
            std::set<const CGrid*>::const_iterator it;

            for ( it = sgrid.begin() ; it != sgrid.end(); it++ )
               sdomain.insert((*it)->getRelDomain());

            return (sdomain);
         }

         const std::set<const CAxis*> getEnabledAxis(void) const
         {
            const std::set<const CGrid*> sgrid = this->getEnabledGrids();
            std::set<const CAxis*> saxis;
            std::set<const CGrid*>::const_iterator it;

            for ( it = sgrid.begin() ; it != sgrid.end(); it++ )
               saxis.insert((*it)->getRelAxis());

            return (saxis);
         }

         void solveFieldRefInheritance(void)
         { // Résolution des héritages par référence de chacun des champs contenus dans le fichier.
            std::vector<CField*> allF; this->getAllFields(allF);
            for (unsigned int i = 0; i < allF.size(); i++)
               allF[i]->solveRefInheritance();
         }

         void findEnabledFields(const Date& inidate,
               int default_outputlevel = 5, int default_level = 1, bool default_enabled = true )
         {
            const int _outputlevel =
               (output_level.hasValue()) ? (int)output_level : default_outputlevel;
            std::vector<CField*>::iterator it;

            this->getAllFields(enabledFields);

            for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
            { // TODO Jeu avec les itérateurs un peu bizarre, à modifier.
              // std::cout << (*it)->field_ref <<std::endl;
               if ((*it)->enabled.hasValue()) // Si l'attribut 'enabled' est défini ...
               {
                  if (! ((*it)->enabled))
                  { it--; enabledFields.erase(it+1); continue; }
               }
               else // Si l'attribut 'enabled' n'est pas défini ...
               {
                  if (!default_enabled)
                  { it--; enabledFields.erase(it+1); continue; }
               }

               if ((*it)->level.hasValue()) // Si l'attribut 'level' est défini ...
               {
                  if ((*it)->level > _outputlevel)
                  { it--; enabledFields.erase(it+1); continue; }
               }
               else // Si l'attribut 'level' n'est pas défini ...
               {
                  if (default_level > _outputlevel)
                  { it--; enabledFields.erase(it+1); continue; }
               }

               // Le champ est finalement actif, on ajoute la référence au champ de base.
               (*it)->getBaseObject()->addRefObject(*it);
               (*it)->setRelFile(this);
               (*it)->initLastStoredDate(inidate);
            }
         }

         void solveEFGridRef(void)
         {
            for (unsigned int i = 0; i < enabledFields.size(); i++)
               enabledFields[i]->solveGridRef();
         }

         void solveEFOperation(void)
         {
            for (unsigned int i = 0; i < enabledFields.size(); i++)
               enabledFields[i]->solveOperation();
         }

      public : /* virtual */

         virtual void parse (XMLNode& _node)
         {
            string name = _node.getElementName();
            THashAttributes attributes;

            /// PARSING GESTION DES ATTRIBUTS ///
            _node.getAttributes(attributes);
            this->setAttributes(attributes);
            attributes.clear();

            /// PARSING POUR GESION DES ENFANTS ///
            if (_node.goToChildElement() and hasId())
            { // Si la définition du fichier intégre des champs et si le fichier est identifié.
               _node.goToParentElement();
               vfieldGroup = CreateInstanceAndParse<FieldGroup>(_node, getId().c_str(), false );
            }
         }

         virtual bool hasChild(void) const
         { return (vfieldGroup != NULL); }

         virtual void printChild(ostream& out) const
         { out << *vfieldGroup << std::endl; }

         virtual void solveDescInheritance(const AttributRegistrar* const _parent = 0)
         { addAttributes(*_parent); if(vfieldGroup != NULL) vfieldGroup->solveDescInheritance(); }

         virtual  ~CFile(void)
         {
            if(vfieldGroup != NULL) delete vfieldGroup;
            if(output != NULL) delete output;
         }

      public : /* static */

         static string GetName(void) { return ("file"); }
         static string GetDefName(void)  { return (CFile::GetName()); }

      private :

         FieldGroup* vfieldGroup; // FieldGroup "virtuel"
         std::vector<CField*> enabledFields; // Liste des champs à sortie dans le fichier courant.

         AbstractDataOutput* output; // Gestion de la sortie des données.

   }; // class CFile

} // namespace XMLIOSERVER

DECLARE_GROUP(File)


#endif // __CFILE__