xml configuration dom parsing finished, still missing connection to filter factory...
[metaproxy-moved-to-github.git] / src / router_flexml.hpp
index 7ef7ddf..08744e3 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: router_flexml.hpp,v 1.4 2005-10-28 10:35:30 marc Exp $
+/* $Id: router_flexml.hpp,v 1.5 2005-10-31 11:59:08 marc Exp $
    Copyright (c) 2005, Index Data.
 
    %LICENSE%
@@ -7,16 +7,13 @@
 #include "router.hpp"
 
 #include <iostream>
-//#include <stdexcept>
+#include <stdexcept>
 #include <map>
 #include <list>
 
 #include <libxml/xmlversion.h>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
-//#include <libxml/xmlIO.h>
-//#include <libxml/xmlreader.h>
-//#include <libxslt/transform.h>
 
 #include <boost/shared_ptr.hpp>
 
@@ -40,7 +37,6 @@ namespace yp2
                     = xmlParseMemory(m_xmlconf.c_str(), m_xmlconf.size());
 
                 parse_xml_config_dom();
-                //parse_xml_config_xmlreader();
             }
 
         ~RouterFleXML()
@@ -50,9 +46,9 @@ namespace yp2
     
     
     private:
-        typedef std::map<std::string, boost::shared_ptr<const yp2::filter::Base> > 
+        typedef std::map<std::string, boost::shared_ptr<const yp2::filter::Base> >
                 IdFilterMap ;
-        typedef  std::list<std::string> FilterIdList;
+        typedef std::list<std::string> FilterIdList;
         typedef std::map<std::string, FilterIdList > IdRouteMap ;
 
     private:
@@ -84,108 +80,126 @@ namespace yp2
         
 
         void parse_xml_config_dom() {
-            //xmlNs *yp2_ns =  xmlNewNs(pptr, BAD_CAST
-            //         "http://indexdata.dk/yp2/config/1", 0);
-
-            
    
-            if (m_xmlconf_doc)
-            {
-                const xmlNode* root = xmlDocGetRootElement(m_xmlconf_doc);
+            if (!m_xmlconf_doc){    
+                std::cerr << "XML configuration DOM pointer empty" << std::endl;
+            }
             
-                if ((std::string((const char *) root->name) != "yp2")
-                    || (std::string((const char *)(root->ns->href)) 
-                        != "http://indexdata.dk/yp2/config/1")
-                   )
-                    xml_dom_error(root, 
-                                  "expected <yp2 xmlns=\"http://indexdata.dk/yp2/config/1\">, got ");
-
+            const xmlNode* root = xmlDocGetRootElement(m_xmlconf_doc);
             
-                for (const struct _xmlAttr *attr = root->properties; attr; attr = attr->next)
+            if ((std::string((const char *) root->name) != "yp2")
+                || (std::string((const char *)(root->ns->href)) 
+                    != "http://indexdata.dk/yp2/config/1")
+                )
+                xml_dom_error(root, 
+                              "expected <yp2 xmlns=\"http://indexdata.dk/yp2/config/1\">, got ");
+            
+            
+            for (const struct _xmlAttr *attr = root->properties; attr; attr = attr->next)
+            {
+                if (std::string((const char *)attr->name) == "xmlns")
                 {
-                    if (std::string((const char *)attr->name) == "xmlns")
-                    {
-                        const xmlNode *val = attr->children;
-                        //BOOST_CHECK_EQUAL(val->type, XML_TEXT_NODE);
-                        if (std::string((const char *)val->content) 
-                            !=  "http://indexdata.dk/yp2/config/1")
-                            xml_dom_error(root, 
-                                          "expected  xmlns=\"http://indexdata.dk/yp2/config/1\", got ");
-                    }  
-                }
-                std::cout << "processing /yp2" << std::endl;
-
-                // process <start> node which is expected first element node
-                const xmlNode* node = root->children;
-                for (; node && node->type != XML_ELEMENT_NODE; node = node->next)
-                    ;
-                if (std::string((const char *)node->name) 
-                    !=  "start")
-                    xml_dom_error(root, "expected  <start>, got ");
-
-                std::cout << "processing /yp2/start" << std::endl;
-                
-                // process <filters> node which is expected second element node
-                node = node->next;
-                for (; node && node->type != XML_ELEMENT_NODE; node = node->next)
-                    ;
-                if (std::string((const char *)node->name) 
-                    !=  "filters")
-                    xml_dom_error(root, "expected  <filters>, got ");
-
-                std::cout << "processing /yp2/filters" << std::endl;
-
-                // process <filter> nodes  in next level
-                const xmlNode* node2 = node->children;
-                for (; node2 && node2->type != XML_ELEMENT_NODE; node2 = node2->next)
-                    ;
-                if (std::string((const char *)node2->name) 
-                    !=  "filter")
-                    xml_dom_error(root, "expected  <filter>, got ");
-#if 0
-                while(node2 && std::string((const char *)node2->name) ==  "filter"){
-                    std::cout << "processing /yp2/filters/filter" << std::endl;
-                    for (; node2 && node2->type != XML_ELEMENT_NODE; node2 = node2->next)
-                        std::cout << (const char *) root->name << std::endl;
-                    if(node2->type != XML_ELEMENT_NODE)
-                        break;
-                    }
-#endif
-                // process <routes> node which is expected third element node
-                node = node->next;
-                for (; node && node->type != XML_ELEMENT_NODE; node = node->next)
-                    ;
-                if (std::string((const char *)node->name) 
-                    !=  "routes")
-                    xml_dom_error(root, "expected  <routes>, got ");
-
-                std::cout << "processing /yp2/routes" << std::endl;
+                    const xmlNode *val = attr->children;
+                    if (std::string((const char *)val->content) 
+                        !=  "http://indexdata.dk/yp2/config/1")
+                        xml_dom_error(root, 
+                                      "expected  xmlns=\"http://indexdata.dk/yp2/config/1\", got ");
+                }  
+            }
+            std::cout << "processing /yp2" << std::endl;
+            
+            // process <start> node which is expected first element node
+            const xmlNode* node = jump_to_children(root, XML_ELEMENT_NODE);
+            //for (; node && node->type != XML_ELEMENT_NODE; node = node->next)
+            //    ;
+            
+            check_node_name(node, "start");
+            std::cout << "processing /yp2/start" << std::endl;
+            
+            // process <filters> node which is expected second element node
+            node = jump_to_next(node, XML_ELEMENT_NODE);
+            check_node_name(node, "filters");
+            std::cout << "processing /yp2/filters" << std::endl;
+            
+            // process <filter> nodes  in next level
+            const xmlNode* node2 = jump_to_children(node, XML_ELEMENT_NODE);
+            check_node_name(node2, "filter");
+            
+            unsigned int filter_nr = 0;
+            while(node2 && std::string((const char *)node2->name) ==  "filter"){
+                filter_nr++;
+                std::cout << "processing /yp2/filters/filter[" 
+                          << filter_nr << "]" << std::endl;
+                node2 = jump_to_next(node2, XML_ELEMENT_NODE);
+            }
+            
+            // process <routes> node which is expected third element node
+            node = jump_to_next(node, XML_ELEMENT_NODE);
+            check_node_name(node, "routes");
+            std::cout << "processing /yp2/routes" << std::endl;
+            
+            // process <route> nodes  in next level
+            node2 = jump_to_children(node, XML_ELEMENT_NODE);
+            check_node_name(node2, "route");
+            
+            unsigned int route_nr = 0;
+            while(node2 && std::string((const char *)node2->name) ==  "route"){
+                route_nr++;
+                std::cout << "processing /yp2/routes/route[" 
+                          << route_nr << "]" << std::endl;
                 
-                // process <route> nodes  in next level
-                node2 = node->children;
-                for (; node2 && node2->type != XML_ELEMENT_NODE; node2 = node2->next)
-                    ;
-                if (std::string((const char *)node2->name) 
-                    !=  "route")
-                    xml_dom_error(root, "expected  <route>, got ");
-
-                std::cout << "processing /yp2/routes/route" << std::endl;
-
                 // process <filter> nodes in third level
-                const xmlNode* node3 = node2->children;
-                for (; node3 && node3->type != XML_ELEMENT_NODE; node3 = node3->next)
-                    ;
-                if (std::string((const char *)node3->name) 
-                    !=  "filter")
-                    xml_dom_error(root, "expected  <filter>, got ");
-
-                std::cout << "processing /yp2/routes/route/filter" << std::endl;
+                const xmlNode* node3 
+                    = jump_to_children(node2, XML_ELEMENT_NODE);
+                check_node_name(node3, "filter");
+                
+                unsigned int filter3_nr = 0;
+                while(node3 && std::string((const char *)node3->name) ==  "filter"){
+                    filter3_nr++;
+                    
+                    std::cout << "processing /yp2/routes/route[" 
+                              << route_nr << "]/filter[" 
+                              << filter3_nr << "]" << std::endl;
+                    
+                    node3 = jump_to_next(node3, XML_ELEMENT_NODE);
+                    
+                }
+                node2 = jump_to_next(node2, XML_ELEMENT_NODE);
             }
+            
+            
+        }
+        
+        
+        const xmlNode* jump_to(const xmlNode* node, int xml_node_type){
+            for (; node && node->type != xml_node_type; node = node->next)
+                ;
+            return node;
         }
-    
 
+        const xmlNode* jump_to_next(const xmlNode* node, int xml_node_type){
+            node = node->next;
+            for (; node && node->type != xml_node_type; node = node->next)
+                ;
+            return node;
+        }
+        
+        const xmlNode* jump_to_children(const xmlNode* node, int xml_node_type){
+            node = node->children;
+            for (; node && node->type != xml_node_type; node = node->next)
+                ;
+            return node;
+        }
+        
+        void check_node_name(const xmlNode* node, std::string name){
+            if (std::string((const char *)node->name) 
+                !=  name)
+                xml_dom_error(node, "expected  <" + name + ">, got ");
+        }
+    
     
 #if 0
+
         void parse_xml_config_xmlreader() {   
 
             xmlTextReader* reader;
@@ -232,7 +246,6 @@ namespace yp2
                 || std::string("route") != (const char*)xmlTextReaderConstName(reader)
                 )
                 xml_error(reader, "start element <start route=\"route_id\"/> expected");
-
             std::cout << "<start " << xmlTextReaderConstName(reader) <<  "=\"" 
                       <<  xmlTextReaderConstValue(reader) << "\"/>" << std::endl;
             //<< xmlTextReaderGetAttribute(reader, (const xmlChar *)"route")