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

#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 */}

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

         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 );
            }
         }

         AbstractDataOutput* getDataOutput(void) const { return (output); }
         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::vector<CField*>& getEnabledFields(void) const { return (enabledFields); }

         const std::set<const CGrid*> getEnabledGrids(void) const
         {
            std::set<const CGrid*> sgrid;
            const std::vector<CField*> enabledFields = 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 CDomain*> getEnabledDomains(void) const
         {
            const std::set<const CGrid*> sgrid = 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 = 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);
         }

         virtual bool hasChild(void) const { return (vfieldGroup != NULL); }
         virtual void printChild(ostream& out) const { out << *vfieldGroup << std::endl; }

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

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

         FieldGroup* getVirtualFieldGroup(void) const { return (vfieldGroup); }

         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;

            getAllFields(enabledFields);

            for ( it = enabledFields.begin() ; it != enabledFields.end(); it++ )
            {
               if ((*it)->enabled.hasValue()) // Si l'attribut 'enabled' est défini ...
               {
                  if (! ((*it)->enabled))
                  { enabledFields.erase(it); continue; }
               }
               else // Si l'attribut 'enabled' n'est pas défini ...
               {
                  if (!default_enabled)
                  { enabledFields.erase(it); continue; }
               }

               if ((*it)->level.hasValue()) // Si l'attribut 'level' est défini ...
               {
                  if ((*it)->level > _outputlevel)
                  { enabledFields.erase(it); continue; }
               }
               else // Si l'attribut 'level' n'est pas défini ...
               {
                  if (default_level > _outputlevel)
                  { enabledFields.erase(it); 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();
         }

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

      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__