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

#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()
         {/* Ne rien faire de plus */}
         CFile(const string& _id) : ObjectTemplate<CFile>(_id), FileAttribut(), vfieldGroup(NULL), enabledFields()
         {/* 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 );
            }
         }

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

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

         virtual void printChild(ostream& out) const { out << *vfieldGroup << std::endl; }
         /*{ // Sortie sans affichage des groupes.
            std::vector<CField*> allF; getAllFields(allF);
            for (unsigned int i = 0; i < allF.size(); i++)
               out << *(allF[i]) << std::endl;
         }*/

         virtual void resolveDescInheritance(const AttributRegistrar* _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) { return (vfieldGroup); }

         void findEnabledFields(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; }
               }

            }
         }

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

      private :

         FieldGroup* vfieldGroup; // FieldGroup "virtuel"
         std::vector<CField*> enabledFields;

   }; // class CFile

} // namespace XMLIOSERVER

DECLARE_GROUP(File)


#endif // __CFILE__