Changeset 91


Ignore:
Timestamp:
06/03/10 12:24:27 (12 years ago)
Author:
hozdoba
Message:

Corrections de plusieurs problÚmes.

Location:
XMLIO_V2/dev/dev_rv
Files:
1 added
11 edited

Legend:

Unmodified
Added
Removed
  • XMLIO_V2/dev/dev_rv/README

    r88 r91  
    22 
    33Ceci est une version expérimentale non fonctionnelle et non documentée. 
    4  
    5 * Certaines classes et fonctionnalité sont présentes pour effectuer des tests. 
    6 * Les classes de gestion des grilles, des fichiers et des axes ne sont pas présents dans cete version. 
    7 * Le répertoire old disparaitera dans les versions ultérieures. 
    8  
    9 <<commit pour sauvegarde uniquement>> 
  • XMLIO_V2/dev/dev_rv/context.hpp

    r88 r91  
    1212         {/* Ne rien faire de plus */}                
    1313         Context(const string& _id) : ObjectTemplate<Context>(_id) 
    14          {/* Ne rien faire de plus */}    
     14         {/* Ne rien faire de plus */} 
     15          
     16         static void SetCurrentContext(const string& id) 
     17         { 
     18            // On modifie le context courrant pour tout les ObjectTemplate 
     19            FieldGroup::SetContext(id); 
     20            Field::SetContext(id); 
     21         } 
    1522          
    1623         void parse (XMLNode& _node) 
     
    3037                             
    3138                  string name = _node.getElementName(); 
    32                   std::cout << name << std::endl; 
    3339                  attributes.clear(); 
    3440                  _node.getAttributes(attributes);    
  • XMLIO_V2/dev/dev_rv/field.hpp

    r88 r91  
    11#ifndef __FIELD__ 
    22#define __FIELD__ 
     3 
     4using XMLIOSERVER::XML::XMLNode; 
    35 
    46namespace XMLIOSERVER 
  • XMLIO_V2/dev/dev_rv/field_attribut.hpp

    r88 r91  
    3030         { /* Ne rien faire de plus */ } 
    3131                  
    32          // TODO Définir un constructeur par copie au lieu de registerAllAttributes (éventuellement) 
     32         // TODO Peut-être définir un constructeur par copie au lieu de registerAllAttributes (éventuellement) 
    3333          
    3434         virtual void registerAllAttributes(void) 
  • XMLIO_V2/dev/dev_rv/field_group.hpp

    r88 r91  
    22#define __FIELD_GROUP__ 
    33 
     4 
     5using XMLIOSERVER::XML::THashAttributes; 
     6 
    47namespace XMLIOSERVER 
    58{    
    6    class FieldGroup : public GroupTemplate<Field>, public FieldAttribut 
     9   class FieldGroup : public GroupTemplate<Field, FieldAttribut> 
    710   { 
    811      public: 
    912       
    10          FieldGroup(void) : GroupTemplate<Field>(), FieldAttribut() 
     13         FieldGroup(void) : GroupTemplate<Field, FieldAttribut>() 
    1114         {/* Ne rien faire de plus */}                
    12          FieldGroup(const string& _id) : GroupTemplate<Field>(_id), FieldAttribut() 
     15         FieldGroup(const string& _id) : GroupTemplate<Field, FieldAttribut>(_id) 
    1316         {/* Ne rien faire de plus */} 
    1417          
  • XMLIO_V2/dev/dev_rv/main.cpp

    r88 r91  
    99        try 
    1010        { 
    11                 // Tests de la classe StrHashMap : 
    12                 //StrHashMap<AbstractObject>::CLASS_TEST(); 
    13                 //ObjectTemplate<AbstractObject>::CLASS_TEST(); 
    14                 //GroupTemplate<AbstractObject>::CLASS_TEST(); 
    15                 XMLParser::CLASS_TEST(); 
    16  
    17              
     11                XMLParser::CLASS_TEST();             
    1812                // Code à executer ici 
    1913        } 
  • XMLIO_V2/dev/dev_rv/xmlio.hpp

    r88 r91  
    2727// Concernant les attributs ... 
    2828#include "field_attribut.hpp" 
    29  
    3029#include "xmlio_object.hpp" 
     30#include "xmlio_xml_node.hpp" 
     31#include "xmlio_object_template.hpp" 
     32#include "field.hpp"       
     33#include "xmlio_group_template.hpp"       
     34#include "field_group.hpp"       
     35#include "context.hpp" 
     36#include "xmlio_xml_parser.hpp"  
    3137 
    3238 
    33 #include "xmlio_object_template.hpp" 
    34 //#include "xmlio_group_template.hpp" // < Inclusion dans "xmlio_xml_parser.hpp 
    35  
    36 // Les Objets "principaux"  
    37 // #include "field.hpp" // < Inclusion dans "xmlio_xml_parser.hpp"  
    38  
    39 // Concernant le parsing xml ... 
    40 #include "xmlio_xml_parser.hpp"  
    41  
    42 //#include "context.hpp" // < Inclusion dans "xmlio_xml_parser.hpp"  
    4339 
    4440 
  • XMLIO_V2/dev/dev_rv/xmlio_container.hpp

    r88 r91  
    8181          
    8282         bool addObject(Mapped& element) 
    83          { if(element.hasId()) return(addValue(element.getId(), element));   return(addValue(element));   } 
     83         { if(element.hasId()) return(addValue(element.getId(), element));   return(addValue(element)); } 
    8484          
    8585         bool addPtrObject(Mapped element) 
    86          { if(element->hasId()) return(addValue(element->getId(), element));   return(addValue(element));   } 
     86         { if(element->hasId()) return(addValue(element->getId(), element));   return(addValue(element)); } 
    8787          
    8888         bool removeObject(const string& kval) 
     
    9595         {/* Ne rien faire de plus */} 
    9696          
    97  
    98 #define   STRHASHMAP_TEST(DESC, SIZE, VECTORSIZE) \ 
    99          if(map.getSize() != SIZE or map.getVectorSize() != VECTORSIZE) \ 
    100          { log << "Test de la classe StrHashMap > " << DESC << "... echec !" << std::endl; return (false); } 
    101        
    102          /// POUR TESTS /// 
    103          static bool CLASS_TEST(ostream& log = std::clog) 
    104          { 
    105             StrHashMap<Mapped> map; 
    106             Mapped obj0("toto"), obj1("titi"),  obj3; 
    107              
    108             //////////////////////////////////////////////////////////////////// 
    109             map.addObject(obj0);   map.addObject(obj1); 
    110             STRHASHMAP_TEST("Ajout d'objets identifiés au conteneur", 2, 2); 
    111             map.removeObject("toto"); 
    112             STRHASHMAP_TEST("Suppression d'objets identifiés du conteneur", 1, 1); 
    113             map.addObject(obj3);    
    114             STRHASHMAP_TEST("Ajout d'objets non-identifiés au conteneur", 1, 2); 
    115             // A étoffer en cas de soucis avec cette classe ... 
    116             //////////////////////////////////////////////////////////////////// 
    117              
    118             log << "Test  StrHashMap ... ok !" << std::endl; 
    119             return (true);       
    120          }; 
    121 #undef   STRHASHMAP_TEST 
    122           
    12397   }; // class StrHashMap 
    12498             
  • XMLIO_V2/dev/dev_rv/xmlio_group_template.hpp

    r88 r91  
    44namespace XMLIOSERVER 
    55{ 
    6    template <class T> 
    7       class GroupTemplate : public ObjectTemplate<GroupTemplate<T> > 
     6   template <class T, class U> 
     7      class GroupTemplate : public ObjectTemplate<GroupTemplate<T, U> >, public U 
    88   { 
    99      public: 
    1010             
    11          GroupTemplate(void) : ObjectTemplate<GroupTemplate<T> >(), childList(), groupList() 
     11         GroupTemplate(void) : ObjectTemplate<GroupTemplate<T, U> >(), childList(), groupList(), U() 
    1212         {/* Ne rien faire de plus */}                
    13          GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T> >(_id), childList(), groupList() 
     13         GroupTemplate(const string& _id) : ObjectTemplate<GroupTemplate<T, U> >(_id), childList(), groupList(), U() 
    1414         {/* Ne rien faire de plus */}             
    1515       
     
    1818         /// Pour les groupes d'objets enfants /// 
    1919          
    20          GroupTemplate<T>& createGroup(const string _id) throw (XMLIOUndefinedValueException)  
     20         GroupTemplate<T, U>& createGroup(const string _id) throw (XMLIOUndefinedValueException)  
    2121         { 
    22             GroupTemplate<T>& obj = GroupTemplate<T>::CreateObject(_id); 
     22            GroupTemplate<T, U>& obj = GroupTemplate<T, U>::CreateObject(_id); 
    2323            groupList.addPtrObject(&obj); 
    2424            return (obj); 
    2525         } 
    2626          
    27          GroupTemplate<T>& createGroup(void) 
     27         GroupTemplate<T, U>& createGroup(void) 
    2828         { 
    29             GroupTemplate<T>& obj = GroupTemplate<T>::CreateObject(); 
     29            GroupTemplate<T, U>& obj = GroupTemplate<T, U>::CreateObject(); 
    3030            groupList.addPtrObject(&obj);             
    3131            return (obj); 
    3232         } 
    3333          
    34          GroupTemplate<T>& getGroup(const string _id) throw (XMLIOUndefinedValueException) { return (*groupList[_id]); } 
     34         GroupTemplate<T, U>& getGroup(const string _id) throw (XMLIOUndefinedValueException) { return (*groupList[_id]); } 
    3535         bool hasGroup(const string _id) { return (groupList.hasMappedValue(_id)); } 
    3636          
    37          const StrHashMap<GroupTemplate<T>* >& getGroupList(void) { return (groupList); } 
     37         const StrHashMap<GroupTemplate<T, U>* >& getGroupList(void) { return (groupList); } 
    3838          
    3939         size_t getNbGroup() const {return (groupList.getVectorSize()); } 
     
    6262         size_t getNbChild() const {return (childList.getVectorSize()); } 
    6363             
    64          static bool CLASS_TEST(ostream& log = std::clog) 
    65          { 
    66             GroupTemplate<T> group; 
    67             /////////////////////////////////////////             
    68             GroupTemplate<T>& group0 = group.createGroup("toto"); 
    69             GroupTemplate<T>& group1 = group.createGroup(); 
    70             T& child0 = group.createChild("toto"); 
    71             T& child1 = group.createChild(); 
    72             log << "Nombre de (groupes) enfants : " << group.getNbChild() << "/" << group.getNbGroup() << " (2/2 attendu)" << std::endl; 
    73             ///////////////////////////////////////// 
    74             log << "Test  GroupTemplate ... ok !" << std::endl; 
    75             return (true);       
    76          };    
    77  
    7864         
    7965         ~GroupTemplate() 
     
    8470      private: 
    8571         StrHashMap<T*> childList; 
    86          StrHashMap<GroupTemplate<T>* > groupList; 
     72         StrHashMap<GroupTemplate<T, U>* > groupList; 
    8773 
    8874   }; // class GroupTemplate 
  • XMLIO_V2/dev/dev_rv/xmlio_object_template.hpp

    r88 r91  
    2424            // Ajout d'un nouvel objet si l'identifiant n'est pas répertorié. 
    2525            T identified_object(_id); 
    26             ObjectTemplate<T>::CurrListObj.addObject(identified_object); 
     26            ObjectTemplate<T>::AllListObj[CurrContext].addObject(identified_object); 
    2727            ObjectTemplate<T>::GetObject(_id).registerAllAttributes(); 
    2828            return (ObjectTemplate<T>::GetObject(_id)); 
     
    3535         } 
    3636          
    37          static T& GetObject(const string _id) throw (XMLIOUndefinedValueException) { return (ObjectTemplate<T>::CurrListObj[_id]); } 
    38          static bool HasObject(const string _id) { return (ObjectTemplate<T>::CurrListObj.hasMappedValue(_id)); } 
     37         static T& GetObject(const string _id) throw (XMLIOUndefinedValueException) 
     38         { return (ObjectTemplate<T>::AllListObj[CurrContext][_id]); } 
    3939          
    40          static const StrHashMap<T> GetCurrentListObject(void) { return (CurrListObj); } 
     40         static bool HasObject(const string _id) 
     41         { return (ObjectTemplate<T>::AllListObj[CurrContext].hasMappedValue(_id)); } 
    4142          
    42          virtual void registerAllAttributes(void) {}; 
     43         static const StrHashMap<T> GetCurrentListObject(void) { return (AllListObj[CurrContext]); } 
     44                 
     45         static void SetContext(const string& id) 
     46         { ObjectTemplate<T>::CurrContext = id; }  
    4347          
    4448         virtual const char* getName(void) const {return ("ObjectTemplate"); } 
    45           
    46          /// POUR TESTS /// 
    47           
    48 #define   OBJECTTEMPLATE_TEST(DESC, SIZE, VECTORSIZE) \ 
    49          if(ObjectTemplate<T>::CurrListObj.getSize() != SIZE or ObjectTemplate<T>::CurrListObj.getVectorSize() != VECTORSIZE) \ 
    50          { log << "Test de la classe ObjectTemplate > " << DESC << "... echec !" << std::endl; return (false); } 
    51              
    52          static bool CLASS_TEST(ostream& log = std::clog) 
    53          { 
    54             //////////////////////////////////////////////////////////////////// 
    55             T& obj0= ObjectTemplate<T>::CreateObject("toto"); 
    56             T& obj1= ObjectTemplate<T>::CreateObject("tata"); 
    57             OBJECTTEMPLATE_TEST("Ajout d'objets identifiés au conteneur", 2, 2); 
    58             T& obj2= ObjectTemplate<T>::CreateObject("tata"); 
    59             OBJECTTEMPLATE_TEST("Ajout d'objets identifiés déjà existants au conteneur", 2, 2);             
    60             T& obj3= ObjectTemplate<T>::CreateObject(); 
    61             OBJECTTEMPLATE_TEST("Ajout d'objets non-identifiés au conteneur", 2, 3); 
    62             //////////////////////////////////////////////////////////////////// 
    63              
    64             log << "Test  ObjectTemplate ... ok !" << std::endl; 
    65             return (true);       
    66          };    
    67 #undef   OBJECTTEMPLATE_TEST 
    68           
    6949          
    7050         virtual ~ObjectTemplate(void) 
     
    7959          
    8060      private : 
    81          static StrHashMap<T> CurrListObj; 
     61          
     62         static string CurrContext; 
     63         static HashMap<string, StrHashMap<T> > AllListObj; 
    8264       
    8365   };// class ObjectTemplate 
    8466    
    85    template <class T> StrHashMap<T> ObjectTemplate<T>::CurrListObj ; 
     67   template <class T> string ObjectTemplate<T>::CurrContext ; 
     68   template <class T> HashMap<string, StrHashMap<T> > ObjectTemplate<T>::AllListObj; 
    8669    
    8770}// namespace XMLIOSERVER 
  • XMLIO_V2/dev/dev_rv/xmlio_xml_parser.hpp

    r88 r91  
    11#ifndef __XMLIO_XML_PARSER__ 
    22#define __XMLIO_XML_PARSER__  
    3  
    4 // Entêtes Poco DOM 
    5 #include <Poco/DOM/DOMParser.h> 
    6 #include <Poco/DOM/Document.h> 
    7 #include <Poco/DOM/Element.h> 
    8  
    9 #include <Poco/DOM/NamedNodeMap.h> 
    10  
    11 //#include <Poco/DOM/AutoPtr.h> 
    12  
    13 // Entêtes Poco SAX 
    14 #include <Poco/SAX/InputSource.h> 
    153 
    164// Utilisation de la STL 
    175using std::string; 
    186 
    19 using std::pair; 
    20 using std::vector; 
    21 using std::deque; 
    22  
    23 using std::istream; 
    24 using std::ostream; 
    25 using std::ostringstream; 
    26 using std::ifstream; 
    27  
    28 // Utilisation de la biliothÚque POCO 
    29 using Poco::XML::DOMParser; 
    30 using Poco::XML::InputSource; 
    31  
    32 using Poco::XML::Document; 
    33 using Poco::XML::Node; 
    34 using Poco::XML::Element; 
    35  
    36 using Poco::XML::NamedNodeMap; 
    37  
    38 using Poco::HashMap; 
    39  
    407namespace XMLIOSERVER 
    418{ 
    429   namespace XML 
    43    { 
    44        
    45       typedef HashMap<string, string> THashAttributes; 
    46           
    47       // TODO Mettre des auto_ptr ici car gestion de la mémoire lamentable sans. 
    48       typedef Document* PDocument; 
    49       typedef Node*     PNode; 
    50           
    51       class XMLNode 
    52       { 
    53          protected : 
    54              
    55             XMLNode(const string& _rootName) : rootName(_rootName) { this->cNode = NULL ; } 
    56              
    57          public : 
    58              
    59             static XMLNode CreateNode(istream& _istr, const string& _rootName = string("simulation")) 
    60             { 
    61                XMLNode node(_rootName); 
    62                    
    63                if ((_istr.good())) 
    64                { // S'il est possible de lire le flux en entrée ... 
    65                   InputSource src(_istr); 
    66                   DOMParser parser; 
    67                       
    68                   // On parse la source XML et on vérifie que le premier noeud (racine) est du type "Element" 
    69                   // ... et à pour valeur la chaîne rootName. 
    70                   PDocument pDoc = parser.parse(&src); 
    71                   if (!(pDoc->documentElement()->nodeName().compare(_rootName))) 
    72                   { 
    73                      node.cNode = pDoc->documentElement(); 
    74                      node.goToChildElement(); 
    75                   } 
    76                   else 
    77                   { 
    78                      ostringstream oss; 
    79                      oss << "L'élément racine doit avoir pour valeur <" << _rootName << "> (\"" <<  (pDoc->documentElement()->nodeName()) <<"\" lue)"; 
    80                      throw XMLParsingException(oss.str()); 
    81                   }     
    82                } 
    83                else 
    84                   throw XMLIOStreamException("Impossible de lire le flux en entrée pour le parsing XML !"); 
    85                    
    86                return (node); 
    87             } 
    88                 
    89             string getElementName(void) const {return (this->cNode->nodeName());} 
    90                  
    91             bool goToNextElement(Node* nextElement = 0)  
    92             { 
    93                nextElement = (!nextElement)? this->cNode->nextSibling() : nextElement; 
    94                
    95                // On parcourt la liste des "siblings" jusqu'à trouver un élément quelconque. 
    96                for(; ; nextElement = nextElement->nextSibling()) 
    97                if (nextElement == NULL) break; 
    98                else if (nextElement->nodeType() == 1) 
    99                {// Si l'un des noeuds est un élément... 
    100                 this->cNode = nextElement ; 
    101                 return (true); 
    102                }  
    103               return (false); 
    104              } 
    105               
    106              bool goToChildElement(void) 
    107              { 
    108               // On parcourt la liste des enfants jusqu'à trouver un élément quelconque. 
    109               if (this->cNode->firstChild()) 
    110                if (this->goToNextElement(this->cNode->firstChild())) 
    111                 return (true); 
    112                  
    113               return (false); 
    114              } 
    115               
    116              bool goToParentElement(void) 
    117              {  
    118               // Pas de retour au parent si on est à la racine. 
    119               if (!(this->getElementName().compare(rootName))) return (false); 
    120               this->cNode = this->cNode->parentNode(); 
    121               return (true); 
    122              } 
    123               
    124              bool getAttributes(THashAttributes& attributes) const 
    125              { 
    126               if(!this->cNode->hasAttributes()) return (false); 
    127               NamedNodeMap* map = this->cNode->attributes(); 
    128                
    129               for(unsigned int i = 0; i< map->length(); i++) 
    130                attributes[map->item(i)->nodeName()] = map->item(i)->nodeValue(); 
    131  
    132               return (true); 
    133              } 
    134              
    135             ~XMLNode()  
    136             { /* Ne rien faire de plus */ } 
    137  
    138          private : 
    139                    
    140             PNode  cNode; 
    141             string rootName;       
    142           
    143       };// class XMLNode 
    144        
    145       #include "field.hpp" 
    146        
    147       #include "xmlio_group_template.hpp"       
    148       #include "field_group.hpp" 
    149        
    150       #include "context.hpp" 
    151              
     10   {           
    15211      using XMLIOSERVER::Context; 
    15312       
     
    15514      { 
    15615         public :  
     16          
    15717            static void Parse(XMLNode& _node) 
    15818            { 
     
    16121              do {                 
    16222                 // Traitement de l'identifiant 
    163                   _node.getAttributes(attributes);             
     23                  _node.getAttributes(attributes); 
     24                             
    16425                  if (attributes.end() == attributes.find("id")) 
    165                   { WARNING("L'un des contexts ne sera pas traité car il n'est pas identifié !"); continue; } 
     26                  { WARNING("Le context ne sera pas traité car il n'est pas identifié !"); continue; } 
     27                   
     28                  if( Context::HasObject(attributes["id"])) 
     29                  { WARNING("Le context ne sera pas traité car il existe déjà !"); continue; } 
     30                   
     31                  Context::SetCurrentContext(attributes["id"]); 
    16632                  Context& context = Context::CreateObject(attributes["id"]); 
     33                   
    16734                  context.parse(_node); 
    16835                  attributes.clear(); 
     
    17138            }     
    17239             
    173             static bool CLASS_TEST(ostream& log = std::clog) 
     40            static bool CLASS_TEST(const string& file = string("/local/testsuite/iodef_test.xml"), ostream& log = std::clog) 
    17441            { 
    175                ifstream istr( "/local/testsuite/iodef_test.xml" , ifstream::in ); // Modifier le répertoire de test ici 
     42               ifstream istr( file.c_str() , ifstream::in ); 
    17643               XMLNode node = XMLNode::CreateNode(istr); 
    17744               XMLParser::Parse(node); 
Note: See TracChangeset for help on using the changeset viewer.