X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=src%2Frouter_flexml.cpp;h=c029fa2f15ed757216ec156a8fb4ddd014168ea3;hb=79100c2ae2dac4bdde4f4d46b69e147562b4ec6c;hp=69953e096a4458a3618cd8553068a56d2d3cc3c3;hpb=ddef5183e8d66d71d9ded936a0c68b947d7804e0;p=metaproxy-moved-to-github.git

diff --git a/src/router_flexml.cpp b/src/router_flexml.cpp
index 69953e0..c029fa2 100644
--- a/src/router_flexml.cpp
+++ b/src/router_flexml.cpp
@@ -1,5 +1,5 @@
-/* $Id: router_flexml.cpp,v 1.16 2006-01-19 09:41:01 adam Exp $
-   Copyright (c) 2005, Index Data.
+/* $Id: router_flexml.cpp,v 1.17 2006-03-16 10:40:59 adam Exp $
+   Copyright (c) 2005-2006, Index Data.
 
 %LICENSE%
  */
@@ -20,23 +20,24 @@
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 
+namespace mp = metaproxy_1;
 
-namespace yp2 {
+namespace metaproxy_1 {
     class RouterFleXML::Route {
         friend class RouterFleXML::Rep;
         friend class RouterFleXML::Pos;
         friend class RouterFleXML;
-        std::list<boost::shared_ptr<const yp2::filter::Base> > m_list;
+        std::list<boost::shared_ptr<const mp::filter::Base> > m_list;
     };
     class RouterFleXML::Rep {
         friend class RouterFleXML;
         friend class RouterFleXML::Pos;
         Rep();
 
-        void base(xmlDocPtr doc, yp2::FactoryFilter &factory);
+        void base(xmlDocPtr doc, mp::FactoryFilter &factory);
 
         typedef std::map<std::string,
-                         boost::shared_ptr<const yp2::filter::Base > >
+                         boost::shared_ptr<const mp::filter::Base > >
                          IdFilterMap ;
 
         IdFilterMap m_id_filter_map;
@@ -62,19 +63,19 @@ namespace yp2 {
         virtual const filter::Base *move(const char *route);
         virtual RoutePos *clone();
         virtual ~Pos();
-        yp2::RouterFleXML::Rep *m_p;
+        mp::RouterFleXML::Rep *m_p;
 
         std::map<std::string, 
                  RouterFleXML::Route>::iterator m_route_it;
-        std::list<boost::shared_ptr <const yp2::filter::Base> >::iterator m_filter_it;
+        std::list<boost::shared_ptr <const mp::filter::Base> >::iterator m_filter_it;
     };
 }
 
-void yp2::RouterFleXML::Rep::parse_xml_filters(xmlDocPtr doc,
+void mp::RouterFleXML::Rep::parse_xml_filters(xmlDocPtr doc,
                                                const xmlNode *node)
 {
     unsigned int filter_nr = 0;
-    while(node && yp2::xml::check_element_yp2(node, "filter"))
+    while(node && mp::xml::check_element_yp2(node, "filter"))
     {
         filter_nr++;
 
@@ -94,7 +95,7 @@ void yp2::RouterFleXML::Rep::parse_xml_filters(xmlDocPtr doc,
             else if (name == "type")
                 type_value = value;
             else
-                throw yp2::XMLError("Only attribute id or type allowed"
+                throw mp::XMLError("Only attribute id or type allowed"
                                     " in filter element. Got " + name);
         }
 
@@ -104,27 +105,27 @@ void yp2::RouterFleXML::Rep::parse_xml_filters(xmlDocPtr doc,
                 m_dl_path << "\n";
             m_factory->add_creator_dl(type_value, m_dl_path);
         }
-        yp2::filter::Base* filter_base = m_factory->create(type_value);
+        mp::filter::Base* filter_base = m_factory->create(type_value);
 
         filter_base->configure(node);
 
         if (m_id_filter_map.find(id_value) != m_id_filter_map.end())
-            throw yp2::XMLError("Filter " + id_value + " already defined");
+            throw mp::XMLError("Filter " + id_value + " already defined");
 
         m_id_filter_map[id_value] =
-            boost::shared_ptr<yp2::filter::Base>(filter_base);
+            boost::shared_ptr<mp::filter::Base>(filter_base);
 
-        node = yp2::xml::jump_to_next(node, XML_ELEMENT_NODE);
+        node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
     }
 }
 
-void yp2::RouterFleXML::Rep::parse_xml_routes(xmlDocPtr doc,
+void mp::RouterFleXML::Rep::parse_xml_routes(xmlDocPtr doc,
                                               const xmlNode *node)
 {
-    yp2::xml::check_element_yp2(node, "route");
+    mp::xml::check_element_yp2(node, "route");
 
     unsigned int route_nr = 0;
-    while(yp2::xml::is_element_yp2(node, "route"))
+    while(mp::xml::is_element_yp2(node, "route"))
     {
         route_nr++;
 
@@ -141,7 +142,7 @@ void yp2::RouterFleXML::Rep::parse_xml_routes(xmlDocPtr doc,
             if (name == "id")
                 id_value = value;
             else
-                throw yp2::XMLError("Only attribute 'id' allowed for"
+                throw mp::XMLError("Only attribute 'id' allowed for"
                                     " element 'route'."
                                     " Got " + name);
         }
@@ -149,10 +150,10 @@ void yp2::RouterFleXML::Rep::parse_xml_routes(xmlDocPtr doc,
         Route route;
 
         // process <filter> nodes in third level
-        const xmlNode* node3 = yp2::xml::jump_to_children(node, XML_ELEMENT_NODE);
+        const xmlNode* node3 = mp::xml::jump_to_children(node, XML_ELEMENT_NODE);
 
         unsigned int filter3_nr = 0;
-        while(node3 && yp2::xml::check_element_yp2(node3, "filter"))
+        while(node3 && mp::xml::check_element_yp2(node3, "filter"))
         {
             filter3_nr++;
             
@@ -172,17 +173,17 @@ void yp2::RouterFleXML::Rep::parse_xml_routes(xmlDocPtr doc,
                 else if (name == "type")
                     type_value = value;
                 else
-                    throw yp2::XMLError("Only attribute 'refid' or 'type'"
+                    throw mp::XMLError("Only attribute 'refid' or 'type'"
                                         " allowed for element 'filter'."
                                         " Got " + name);
             }
             if (refid_value.length())
             {
                 std::map<std::string,
-                    boost::shared_ptr<const yp2::filter::Base > >::iterator it;
+                    boost::shared_ptr<const mp::filter::Base > >::iterator it;
                 it = m_id_filter_map.find(refid_value);
                 if (it == m_id_filter_map.end())
-                    throw yp2::XMLError("Unknown filter refid "
+                    throw mp::XMLError("Unknown filter refid "
                                         + refid_value);
                 else
                     route.m_list.push_back(it->second);
@@ -195,45 +196,45 @@ void yp2::RouterFleXML::Rep::parse_xml_routes(xmlDocPtr doc,
                         m_dl_path << "\n";
                     m_factory->add_creator_dl(type_value, m_dl_path);
                 }
-                yp2::filter::Base* filter_base = m_factory->create(type_value);
+                mp::filter::Base* filter_base = m_factory->create(type_value);
 
                 filter_base->configure(node3);
                 
                 route.m_list.push_back(
-                    boost::shared_ptr<yp2::filter::Base>(filter_base));
+                    boost::shared_ptr<mp::filter::Base>(filter_base));
             }
-            node3 = yp2::xml::jump_to_next(node3, XML_ELEMENT_NODE);
+            node3 = mp::xml::jump_to_next(node3, XML_ELEMENT_NODE);
             
         }
         std::map<std::string,RouterFleXML::Route>::iterator it;
         it = m_routes.find(id_value);
         if (it != m_routes.end())
-            throw yp2::XMLError("Route id='" + id_value
+            throw mp::XMLError("Route id='" + id_value
                                 + "' already exist");
         else
             m_routes[id_value] = route;
-        node = yp2::xml::jump_to_next(node, XML_ELEMENT_NODE);
+        node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
     }
 }
 
-void yp2::RouterFleXML::Rep::parse_xml_config_dom(xmlDocPtr doc)
+void mp::RouterFleXML::Rep::parse_xml_config_dom(xmlDocPtr doc)
 {
     if (!doc)
-        throw yp2::XMLError("Empty XML Document");
+        throw mp::XMLError("Empty XML Document");
     
     const xmlNode* root = xmlDocGetRootElement(doc);
     
-    yp2::xml::check_element_yp2(root,  "yp2");
+    mp::xml::check_element_yp2(root,  "yp2");
 
-    const xmlNode* node = yp2::xml::jump_to_children(root, XML_ELEMENT_NODE);
+    const xmlNode* node = mp::xml::jump_to_children(root, XML_ELEMENT_NODE);
 
-    if (yp2::xml::is_element_yp2(node, "dlpath"))
+    if (mp::xml::is_element_yp2(node, "dlpath"))
     {
-        m_dl_path = yp2::xml::get_text(node);
-        node = yp2::xml::jump_to_next(node, XML_ELEMENT_NODE);
+        m_dl_path = mp::xml::get_text(node);
+        node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
     }
     // process <start> node which is expected first element node
-    if (yp2::xml::check_element_yp2(node, "start"))
+    if (mp::xml::check_element_yp2(node, "start"))
     {
         const struct _xmlAttr *attr;
         std::string id_value;
@@ -248,50 +249,50 @@ void yp2::RouterFleXML::Rep::parse_xml_config_dom(xmlDocPtr doc)
             if (name == "route")
                 m_start_route = value;
             else
-                throw yp2::XMLError("Only attribute start allowed"
+                throw mp::XMLError("Only attribute start allowed"
                                     " in element 'start'. Got " + name);
         }
-        node = yp2::xml::jump_to_next(node, XML_ELEMENT_NODE);
+        node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
     }
     // process <filters> node if given
-    if (yp2::xml::is_element_yp2(node, "filters"))
+    if (mp::xml::is_element_yp2(node, "filters"))
     {
-        parse_xml_filters(doc, yp2::xml::jump_to_children(node,
+        parse_xml_filters(doc, mp::xml::jump_to_children(node,
                                                           XML_ELEMENT_NODE));
                       
-        node = yp2::xml::jump_to_next(node, XML_ELEMENT_NODE);
+        node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
     }
     // process <routes> node which is expected third element node
-    yp2::xml::check_element_yp2(node, "routes");
+    mp::xml::check_element_yp2(node, "routes");
     
-    parse_xml_routes(doc, yp2::xml::jump_to_children(node, XML_ELEMENT_NODE));
+    parse_xml_routes(doc, mp::xml::jump_to_children(node, XML_ELEMENT_NODE));
 
-    node = yp2::xml::jump_to_next(node, XML_ELEMENT_NODE);
+    node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
     if (node)
     {
-        throw yp2::XMLError("Unexpected element " 
+        throw mp::XMLError("Unexpected element " 
                             + std::string((const char *)node->name));
     }
 }        
 
-yp2::RouterFleXML::Rep::Rep() : m_xinclude(false)
+mp::RouterFleXML::Rep::Rep() : m_xinclude(false)
 {
 }
 
-void yp2::RouterFleXML::Rep::base(xmlDocPtr doc, yp2::FactoryFilter &factory)
+void mp::RouterFleXML::Rep::base(xmlDocPtr doc, mp::FactoryFilter &factory)
 {
     m_factory = &factory;
     parse_xml_config_dom(doc);
     m_start_route = "start";
 }
 
-yp2::RouterFleXML::RouterFleXML(xmlDocPtr doc, yp2::FactoryFilter &factory)
+mp::RouterFleXML::RouterFleXML(xmlDocPtr doc, mp::FactoryFilter &factory)
     : m_p(new Rep)
 {
     m_p->base(doc, factory);
 }
 
-yp2::RouterFleXML::RouterFleXML(std::string xmlconf, yp2::FactoryFilter &factory) 
+mp::RouterFleXML::RouterFleXML(std::string xmlconf, mp::FactoryFilter &factory) 
     : m_p(new Rep)
 {            
     LIBXML_TEST_VERSION;
@@ -299,7 +300,7 @@ yp2::RouterFleXML::RouterFleXML(std::string xmlconf, yp2::FactoryFilter &factory
     xmlDocPtr doc = xmlParseMemory(xmlconf.c_str(),
                                    xmlconf.size());
     if (!doc)
-        throw yp2::XMLError("xmlParseMemory failed");
+        throw mp::XMLError("xmlParseMemory failed");
     else
     {
         m_p->base(doc, factory);
@@ -307,11 +308,11 @@ yp2::RouterFleXML::RouterFleXML(std::string xmlconf, yp2::FactoryFilter &factory
     }
 }
 
-yp2::RouterFleXML::~RouterFleXML()
+mp::RouterFleXML::~RouterFleXML()
 {
 }
 
-const yp2::filter::Base *yp2::RouterFleXML::Pos::move(const char *route)
+const mp::filter::Base *mp::RouterFleXML::Pos::move(const char *route)
 {
     if (route && *route)
     {
@@ -320,20 +321,20 @@ const yp2::filter::Base *yp2::RouterFleXML::Pos::move(const char *route)
         if (m_route_it == m_p->m_routes.end())
         {
             std::cout << "no such route " << route << "\n";
-            throw yp2::XMLError("bad route " + std::string(route));
+            throw mp::XMLError("bad route " + std::string(route));
         }
         m_filter_it = m_route_it->second.m_list.begin();
     }
     if (m_filter_it == m_route_it->second.m_list.end())
         return 0;
-    const yp2::filter::Base *f = (*m_filter_it).get();
+    const mp::filter::Base *f = (*m_filter_it).get();
     m_filter_it++;
     return f;
 }
 
-yp2::RoutePos *yp2::RouterFleXML::createpos() const
+mp::RoutePos *mp::RouterFleXML::createpos() const
 {
-    yp2::RouterFleXML::Pos *p = new yp2::RouterFleXML::Pos;
+    mp::RouterFleXML::Pos *p = new mp::RouterFleXML::Pos;
 
     p->m_route_it = m_p->m_routes.find(m_p->m_start_route);
     if (p->m_route_it == m_p->m_routes.end())
@@ -346,16 +347,16 @@ yp2::RoutePos *yp2::RouterFleXML::createpos() const
     return p;
 }
 
-yp2::RoutePos *yp2::RouterFleXML::Pos::clone()
+mp::RoutePos *mp::RouterFleXML::Pos::clone()
 {
-    yp2::RouterFleXML::Pos *p = new yp2::RouterFleXML::Pos;
+    mp::RouterFleXML::Pos *p = new mp::RouterFleXML::Pos;
     p->m_filter_it = m_filter_it;
     p->m_route_it = m_route_it;
     p->m_p = m_p;
     return p;
 }
 
-yp2::RouterFleXML::Pos::~Pos()
+mp::RouterFleXML::Pos::~Pos()
 {
 }