Changeset 108 for XMLIO_V2

Timestamp:

06/18/10 14:33:19 (14 years ago)

Author:

hozdoba

Message:

Début de prise en charge des références (sans contrÎle ni transmission d'attribut pour le moment).

Location:

XMLIO_V2/dev/dev_rv/src/XMLIO

Files:

• attribut.hpp (modified) (4 diffs)
• attribut_registrar.hpp (modified) (1 diff)
• base_attribut.hpp (modified) (4 diffs)
• context.hpp (modified) (3 diffs)
• declare_attribut.hpp (modified) (1 diff)
• field.hpp (modified) (1 diff)
• file.hpp (modified) (1 diff)
• main_cpp.cpp (modified) (2 diffs)
• xmlio_group_template.hpp (modified) (4 diffs)
• xmlio_logger.hpp (modified) (5 diffs)
• xmlio_object_template.hpp (modified) (5 diffs)
• xmlio_xml_node.hpp (modified) (1 diff)
• xmlio_xml_parser.hpp (modified) (1 diff)

XMLIO_V2/dev/dev_rv/src/XMLIO/attribut.hpp

@@ -12 +12 @@
    class IStringStream_alt
    {
-      public : 
+      public :
          IStringStream_alt(const std::string& str) : iss(str)
          { /* Ne rien faire de plus */}
-         
+
          istream& operator>> (std::string& s) {s.assign(this->iss.str()); return (this->iss);}
          istream& operator>> (int& s) { return (iss>>s); }
@@ -24 +24 @@
             return (this->iss);
          }
-         
-      private : 
+
+      private :
          istringstream iss;
-         
+
    }; // class IStringStream_alt
 
@@ -35 +35 @@
    {
       public :
-     
+
          bool hasValue ;
          Ctype value ;
-         
-         virtual bool _hasValue() {return hasValue;}
 
-         virtual const char * getName(void) const = 0 ;
-      
+         virtual bool _hasValue() const { return hasValue; }
+
          Attribut(void) : hasValue(false) {} ;
          Attribut(const Ctype& value_) : hasValue(true), value(value_) {} ;
-         
-         Attribut(const Attribut& attr) : hasValue(attr.hasValue) 
+
+         Attribut(const Attribut& attr) : hasValue(attr.hasValue)
          {  if (hasValue) value=attr.value ; }
 
          Attribut& operator = (const Attribut & attr)
-         { 
+         {
             hasValue=attr.hasValue ;
             if (hasValue) value=attr.value ;
-            return *this ; 
+            return *this ;
          }
-     
+
          virtual const char * getType(void) const = 0;
-     
-         virtual void setFromString(const std::string str) 
-         {    
+
+         virtual void setFromString(const std::string str)
+         {
             IStringStream_alt iss(str); Ctype val;
             iss >> val;
             this->setValue(val);
-         }   
+         }
 
-         operator Ctype()
+         operator Ctype() const
          {
-            if (!hasValue)
-            {
-               ostringstream oss;
-               oss << "CAttribut& CAttribut<Ctype>::operator Ctype , access to undefined value of attribut <<" << this->getName() <<">>";
-                                                                          
-               throw XMLIOUndefinedValueException(oss.str());
-            }
+            if (!hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
             return value ;
          }
-         
+
          virtual void assignValue(const BaseAttribut* _ba)
          { value = ((Attribut*)_ba) -> value; hasValue = true; }
@@ -85 +77 @@
          virtual void setValue(const Ctype & value_)
          { hasValue=true ; value=value_ ; }
-         
+
          virtual void getValue(Ctype & value_) const
          {
-            if (!hasValue)
-            {
-               ostringstream oss;
-               oss << "CAttribut& CAttribut<Ctype>::operator Ctype , access to undefined value of attribut <<" << this->getName() <<">>";
-                                                                          
-               throw XMLIOUndefinedValueException(oss.str());
-            }
+            if (!hasValue) throw XMLIOUndefinedValueException("L'attribut \"" + this->getName() + "\" est invalide !");
             value_=value ;
          }
 
-   }; // class Attribut 
+   }; // class Attribut
 }; // namespace XMLIOSERVER
-  
+
 #endif //__ATTRIBUT__

XMLIO_V2/dev/dev_rv/src/XMLIO/attribut_registrar.hpp

@@ -52 +52 @@
          void setSAttribut(const string& att_name, const std::string& value)
          {
-            //std::cout << "Attribut :" <<  att_name<< ", " << value<< std::endl;
-
-            if (hasAttribut(att_name))
-            { getAttribut(att_name)->setFromString(value) ; }
-            else
-            {
-               ostringstream oss;
-               oss << "CAttributRegistrar::setAttribut<ValueType>, could not find <<" << att_name <<">> attribut in registred list" <<">>";
-               throw XMLIOUndefinedValueException(oss.str());
-            }
+            if (hasAttribut(att_name)) getAttribut(att_name)->setFromString(value);
+            else throw XMLIOUndefinedValueException("Impossible de trouver l'attribut nommé \"" + att_name +"\" dans la liste des attributs enregistrés !");
          }
 

XMLIO_V2/dev/dev_rv/src/XMLIO/base_attribut.hpp

@@ -13 +13 @@
    {
       public:
-     
-         virtual const char * getName(void) const = 0  ;        
+
+         virtual string getName(void) const = 0  ;
          virtual ostream & print(ostream& o) const = 0  ;
-     
+
          friend ostream& operator <<(ostream& o,const BaseAttribut& Attr)
          {return Attr.print(o) ; }
-         
+
          virtual void assignValue(const BaseAttribut*) = 0;
-     
-         virtual const char * getId(void) {return getName();} ;
+
+         virtual string getId(void) const {return getName();} ;
          bool hasId(void){return (true);}
 
          virtual void setFromString(const std::string str) = 0;
-     
+
 #define  SETTER_AND_GETTER(TYPE) \
          virtual void setValue(const TYPE & value)          { error_set() ; }\
@@ -36 +36 @@
          virtual void getValue(Array<TYPE,2>& value) const  { error_get() ; }\
          virtual void getValue(Array<TYPE,3>& value) const  { error_get() ; }
-         
+
          SETTER_AND_GETTER(int)
          SETTER_AND_GETTER(bool)
@@ -42 +42 @@
          SETTER_AND_GETTER(char)
          SETTER_AND_GETTER(string)
-      
+
 #undef SETTER_AND_GETTER
 
-         
-         virtual bool _hasValue() = 0;
+
+         virtual bool _hasValue() const = 0;
 
          static void error_set(void)
@@ -53 +53 @@
          static void error_get(void)
          { throw XMLIOIncompatibleTypeException("BaseAttribut::set<type> >Getting value type is incompatible with attribut type"); }
-     
+
    }; //class BaseAttribut
 } // namespace XMLIOSERVER
 
 #endif //__BASE_ATTRIBUT__
-  
+

XMLIO_V2/dev/dev_rv/src/XMLIO/context.hpp

@@ -16 +16 @@
          static void ShowTree(ostream& os = std::clog)
          {
-            clog <<  "<?xml version=\"1.0\"?>" << std::endl;
-            clog <<  "<simulation>" << std::endl;
+            clog << NIndent << "<?xml version=\"1.0\"?>" << std::endl;
+            clog << NIndent << "<"<< Context::GetRootName() << ">" << std::endl;
             HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
             for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
                // On sort chacun des contextes successivement.
-               clog << *((*it).second)[(*it).first] << std::endl;
-            clog << "</simulation>" << std::endl  ;
+            { Context::SetCurrentContext((*it).first); clog << *((*it).second)[(*it).first] << std::endl; }
+            clog << NIndent << "</" << Context::GetRootName() << ">" << std::endl  ;
          }
 
@@ -36 +36 @@
             HashMap<string, StrHashMap<Context> > &AllListContext = Context::GetAllListObject();
             for (HashMap<string, StrHashMap<Context> >::Iterator it = AllListContext.begin(); it != AllListContext.end(); it++)
-               // Résolution des héritages des descendands (cà d des héritages de groupes) pour chacun des contextes.
+            {
+               // Résolution des héritages descendants (cà d des héritages de groupes) pour chacun des contextes.
+               Context::SetCurrentContext((*it).first);
                ((*it).second)[(*it).first]->resolveDescInheritance();
+
+               // Résolution des héritages par référence au niveau des fichiers
+               const std::vector<CFile*>& allFiles = CFile::GetCurrentListObject().getVector();
+               for (unsigned int i = 0; i < allFiles.size(); i++) allFiles[i]->resolveFieldRefInheritance();
+            }
          }
 
@@ -113 +120 @@
 
          static string GetName(void) {return ("context"); }
+         static string GetRootName(void) {return ("simulation"); }
 
          virtual bool hasChild(void) const

XMLIO_V2/dev/dev_rv/src/XMLIO/declare_attribut.hpp

@@ -8 +8 @@
    {                                                  \
       public:                                         \
-         const char * getName(void) const { return #att_name ;}                     \
+         virtual string getName(void) const { return #att_name ;}                   \
          virtual const char * getType(void) const { return #att_type ;}             \
          attr_##att_name(void) : Attribut<att_type>() {}                            \

XMLIO_V2/dev/dev_rv/src/XMLIO/field.hpp

@@ -17 +17 @@
 
          static string GetName(void) {return ("field"); }
+
+         virtual CField* getReference(void) const
+         {
+            if(!field_ref._hasValue()) return (NULL);
+            string refname = field_ref;
+            if (!CField::HasObject(refname))
+            { WARNING("Référence invalide sur l'objet "+GetName()+" nommé \""+refname+"\""); return (NULL);}
+
+            return (&CField::GetObject(field_ref));
+         }
 
          void parse (XMLNode& _node)

XMLIO_V2/dev/dev_rv/src/XMLIO/file.hpp

@@ -36 +36 @@
          }
 
+         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)
+         {
+            std::vector<CField*> allF; getAllFields(allF);
+            for (unsigned int i = 0; i < allF.size(); i++) allF[i]->resolveRefInheritance();
+         }
 
          FieldGroup* getVirtualFieldGroup(void) { return (vfieldGroup); }

XMLIO_V2/dev/dev_rv/src/XMLIO/main_cpp.cpp

@@ -12 +12 @@
    {
       string file("/local/XMLIOSERVER_DEV/dev_rv/test/iodef_test.xml");
+      //string file("/local/XMLIOSERVER_DEV/dev_rv/iodef_test.xml");
 
-      //string file("/local/XMLIOSERVER_DEV/dev_rv/iodef_test.xml");
       ifstream istr( file.c_str() , ifstream::in );
 
       // On commence la lecture du flux de donnée xml qui doit posséder pour racine un unique noeud nommé "simulation".
-      XMLNode node = XMLNode::CreateNode(istr, "simulation");
+      XMLNode node = XMLNode::CreateNode(istr, Context::GetRootName());
       // On parse le fichier xml noeud par noeud (ie on construit dynamiquement notre arbre d'objets).
       XMLParser::Parse(node);
@@ -26 +26 @@
       // On poursuit le traitement ...
 
-      // On écrit l'arborescence resultante du traitement sur la sortie.
+      // On écrit l'arborescence résultante du traitement sur la sortie.
       Context::ShowTree(std::clog);
 

XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_group_template.hpp

@@ -51 +51 @@
             groupList.addObject(&obj);
 
-            return (GroupTemplate<T, U>::GetObject(_id));
+            return (obj);
          }
 
@@ -89 +89 @@
 
          const StrHashMap<T*>& getCurrentListChild(void) { return (childList); }
+         const vector<T*>& getCurrentVectorChild(void) { return (childList.getVector()); }
 
          size_t getNbChild() const {return (childList.getVectorSize()); }
+
+         void getAllChildren(std::vector<T*>& _allc )
+         {
+            const vector<GroupTemplate<T, U>*>& groupvect = groupList.getVector();
+            _allc.insert (_allc.end(), getCurrentVectorChild().begin(), getCurrentVectorChild().end());
+
+            for(unsigned int i = 0; i < groupvect.size() ; i++)
+               groupvect[i] -> getAllChildren(_allc);
+         }
 
          virtual ~GroupTemplate()
@@ -108 +118 @@
             {// Si l'identifiant est défini.
                if (V::HasObject(attributes["id"]))
-                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée "+attributes["id"]+" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
+                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée \""+attributes["id"]+"\" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
                instance_ptr = (V*)(&createGroup(attributes["id"]));
                instance_ptr->parse(_node);
@@ -126 +136 @@
             {// Si l'identifiant est défini.
                if (V::HasObject(attributes["id"]))
-                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée "+attributes["id"]+" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
+                  WARNING("Dans le context actuel, une instance de type "+V::GetName()+" nommée \""+attributes["id"]+"\" existe déjà , le second fera référence au premier par défaut !"); // TODO TODO
                instance_ptr = (V*)(&createChild(attributes["id"]));
                instance_ptr->parse(_node);

XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_logger.hpp

@@ -1 +1 @@
 #ifndef __XMLIO_LOGGER__
-#define __XMLIO_LOGGER__ 
+#define __XMLIO_LOGGER__
 
 // Entête Poco logging
@@ -12 +12 @@
 #include <Poco/AutoPtr.h>
 
+#include <csignal>
+
+#ifdef __GNUC__
+#include <execinfo.h>
+#include <cxxabi.h>
+#endif // __GNUC__
 
 // Classes utilisées issues de Poco
@@ -28 +34 @@
    {
       public :
-      
+
          ILogger(const string& _fileLogName, bool _withConsole = true)
          {
             // Perte mémoire faible ici (/ still reachable: 84 bytes in 2 blocks /)
-   
+
             // TODO Créer une sortie fichier.
             AutoPtr<PatternFormatter> pf = new PatternFormatter("[%Y-%m-%d %H:%M:%S] %t");
@@ -38 +44 @@
             AutoPtr<FormattingChannel> pFCConsole = new FormattingChannel(pf);
             pFCConsole->setChannel(cc);
-            pFCConsole->open();            
+            pFCConsole->open();
             Logger::create("ConsoleLogger", pFCConsole, Message::PRIO_INFORMATION);
+
+            signal(SIGSEGV, SigHandler);
          }
 
-         static Logger & GetConsoleLogger(void) {return (Logger::get("ConsoleLogger"));}   
-         
-         ~ILogger(void) 
-         { /* Ne rien faire de plus */ }   
-               
+
+         static void ShowBTrace(std::ostream& out = std::clog)
+         {
+#ifdef __GNUC__
+            int status = 0;
+            string value;
+            void *stack_addrs[20] = {NULL};
+            size_t stack_depth = backtrace(stack_addrs, 20);
+            char **stack_strings = backtrace_symbols(stack_addrs, stack_depth);
+
+            out << "Trace : " << std::endl;
+            for (size_t i = 2, j = 0; i < stack_depth; i++)
+            {
+               value.assign(stack_strings[i]);
+               size_t bpos = value.find ('('), epos = value.find ('+');
+               if ((bpos != string::npos) and (epos != string::npos))
+               {
+                  char* demangled_name = abi::__cxa_demangle(value.substr(bpos+1, epos-bpos-1).c_str(), 0, 0, &status);
+                  if (status == 0) out << "   "  << ++j << " -> "  << (demangled_name) << std::endl;
+                  else out << "   "  << ++j << " -> "  << value.substr(bpos+1, epos-bpos-1) << std::endl;
+                  free(demangled_name);
+               }
+            }
+
+            free(stack_strings);
+#endif // __GNUC__
+         }
+
+         static void SigHandler(int _sigValue)
+         {
+            std::cerr << "============= Erreur =============" << std::endl;
+            std::cerr << "Signal " << _sigValue << " reçu !" << std::endl;
+            ShowBTrace(std::cerr);
+            std::cerr << "==================================" << std::endl;
+            exit(EXIT_FAILURE);
+         }
+
+
+         static Logger & GetConsoleLogger(void) {return (Logger::get("ConsoleLogger"));}
+
+         ~ILogger(void)
+         { /* Ne rien faire de plus */ }
+
    }; // class XMLIOLogger
-   
+
    // Initialisation de la classe de Logging
    static ILogger LOGGER("xmlio.log");
 
-/////////////////////////////////////////////////////////////////////
-static unsigned int Indent;
+   /////////////////////////////////////////////////////////////////////
+   static unsigned int Indent = 0;
+   static const char*  Increm = "   ";
 
-std::ostream& NIndent(std::ostream& out)
-{ for(unsigned int i = 0; i < Indent; i++) out << "  "; return(out); }
+   std::ostream& NIndent(std::ostream& out)
+   {
+      static unsigned int LineNB = 1;
+      out<< LineNB++ << ". ";
+      for(unsigned int i = 0;i < Indent; i++) out << Increm;
+      return(out);
+   }
 
-std::ostream& IncIndent(std::ostream& out) { Indent++; return (NIndent(out)); }
-std::ostream& DecEndl(std::ostream& out) { Indent--; return (NIndent(out)); }
-/////////////////////////////////////////////////////////////////////
+   std::ostream& IncIndent(std::ostream& out) { Indent++; return (NIndent(out)); }
+   std::ostream& DecEndl(std::ostream& out) { Indent--; return (out); }
+   /////////////////////////////////////////////////////////////////////
 
-/************* POUR MEMOIRE **********************
-#include <stdio.h> 
-#include <execinfo.h> 
-#include <signal.h> 
-#include <stdlib.h> 
- 
-void handler(int sig) { 
-  void *array[10]; 
-  size_t size; 
-  // get void*'s for all entries on the stack 
-  size = backtrace(array, 10); 
-  // print out all the frames to stderr 
-  fprintf(stderr, "Error: signal %d:\n", sig); 
-  backtrace_symbols_fd(array, size, 2); 
-  exit(1); 
-} 
-void baz() { 
- int *foo = (int*)-1; // make a bad pointer 
-  printf("%d\n", *foo);       // causes segfault 
-} 
-void bar() { baz(); } 
-void foo() { bar(); } 
- 
-int main(int argc, char **argv) { 
-  signal(SIGSEGV, handler);   // install our handler 
-  foo(); // this will call foo, bar, and baz.  baz segfaults. 
-} 
- 
- ***************************************************************/
-   
 }; // namespace XMLIOSERVER
 
@@ -99 +121 @@
 // A compléter.
 
-#endif // __XMLIO_LOGGER__  
+#endif // __XMLIO_LOGGER__

XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_object_template.hpp

@@ -22 +22 @@
       public :
 
-
          friend ostream& operator<< (ostream& out, const T& c)
          {
             const AttributRegistrar &ar = c;
+
+            if (c.baseObject != NULL)
+               out <<  IncIndent << "<-- Reference resolved for the following "+ T::GetName() +" : \"" << c.baseObject->getId() << "\" -->" << DecEndl << std::endl;
+
             if (c.hasChild())
             {
@@ -39 +42 @@
          string getName(void) const {return (T::GetName()); }
 
+         virtual T* getReference(void) const { return (NULL); }
+
          virtual bool hasChild(void) const { return (false); }
          virtual void printChild(ostream& out) const { /* Ne rien faire de plus */ }
+
          virtual void resolveDescInheritance(const AttributRegistrar* _parent = 0) { addAttributes(*_parent); }
+         virtual void resolveRefInheritance(void)
+         {
+            std::vector<T*> allRef;
+            T* refer = (T*)this;
+            // On remonte le fil des héritages par référence (Boucle infinie).
+            while((refer = refer->getReference()) != NULL)
+               allRef.insert(allRef.begin(), baseObject = refer);
+
+            // Gestion des attributs ici.
+         }
 
          static T& CreateObject(const string _id) throw (XMLIOUndefinedValueException)
@@ -83 +99 @@
       protected :
 
-         ObjectTemplate(void) : AbstractObject()
+         ObjectTemplate(void) : AbstractObject(), baseObject(NULL)
          {/* Ne rien faire de plus */}
-         ObjectTemplate(const string& _id) : AbstractObject(_id)
+         ObjectTemplate(const string& _id) : AbstractObject(_id), baseObject(NULL)
          {/* Ne rien faire de plus */}
 
@@ -100 +116 @@
             {
                if (V::HasObject(did))
-                  WARNING("Le noeud nommé "+ did +" existe déjà pour les instances de type "+V::GetName()+", le dernier défini complétera le premier dans le context actuel!");
+                  WARNING("Le noeud nommé \""+ did +"\" existe déjà pour les instances de type "+V::GetName()+", le dernier défini complétera le premier dans le context actuel!");
                instance_ptr = (V*)&V::CreateObject(did);
                instance_ptr->parse(_node, parseAttr);
@@ -108 +124 @@
 
       private :
+         T* baseObject;
 
          static string CurrContext;

XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_xml_node.hpp

@@ -54 +54 @@
             { /* Ne rien faire de plus */}
 
-            static XMLNode CreateNode(istream& _istr, const string& _rootName = string("simulation"))
+            static XMLNode CreateNode(istream& _istr, const string& _rootName)
             {
                XMLNode node(_rootName);

XMLIO_V2/dev/dev_rv/src/XMLIO/xmlio_xml_parser.hpp

@@ -31 +31 @@
                   { WARNING("Le context ne sera pas traité car il n'est pas identifié !"); continue; }
 
-                  if( Context::HasObject(attributes["id"]))
+                  if( Context::GetAllListObject().find(attributes["id"]) != Context::GetAllListObject().end())
                   { WARNING("Le context ne sera pas traité car il existe déjà un autre context possédant le même nom !"); continue; }