1 /* $Id: router_flexml.cpp,v 1.12 2006-01-09 13:53:13 adam Exp $
2 Copyright (c) 2005, Index Data.
9 #include "router_flexml.hpp"
10 #include "factory_filter.hpp"
11 #include "factory_static.hpp"
17 #include <boost/shared_ptr.hpp>
19 #include <libxml/xmlversion.h>
20 #include <libxml/parser.h>
21 #include <libxml/tree.h>
25 class RouterFleXML::Route {
26 friend class RouterFleXML::Rep;
27 friend class RouterFleXML::Pos;
28 friend class RouterFleXML;
29 std::list<boost::shared_ptr<const yp2::filter::Base> > m_list;
31 class RouterFleXML::Rep {
32 friend class RouterFleXML;
33 friend class RouterFleXML::Pos;
36 void base(xmlDocPtr doc, yp2::FactoryFilter &factory);
38 typedef std::map<std::string,
39 boost::shared_ptr<const yp2::filter::Base > >
42 IdFilterMap m_id_filter_map;
44 std::map<std::string,RouterFleXML::Route> m_routes;
46 std::string m_start_route;
48 void parse_xml_config_dom(xmlDocPtr doc);
50 bool check_element_yp2(const xmlNode *ptr,
51 const std::string &name);
53 const xmlNode* jump_to(const xmlNode* node, int xml_node_type);
55 const xmlNode* jump_to_next(const xmlNode* node, int xml_node_type);
57 const xmlNode* jump_to_children(const xmlNode* node, int xml_node_type);
58 void parse_xml_filters(xmlDocPtr doc, const xmlNode *node);
59 void parse_xml_routes(xmlDocPtr doc, const xmlNode *node);
63 FactoryFilter *m_factory; // TODO shared_ptr
66 class RouterFleXML::Pos : public RoutePos {
68 virtual const filter::Base *move();
69 virtual RoutePos *clone();
71 yp2::RouterFleXML::Rep *m_p;
74 RouterFleXML::Route>::iterator m_route_it;
75 std::list<boost::shared_ptr <const yp2::filter::Base> >::iterator m_filter_it;
79 const xmlNode* yp2::RouterFleXML::Rep::jump_to_children(const xmlNode* node,
82 node = node->children;
83 for (; node && node->type != xml_node_type; node = node->next)
88 const xmlNode* yp2::RouterFleXML::Rep::jump_to_next(const xmlNode* node,
92 for (; node && node->type != xml_node_type; node = node->next)
97 const xmlNode* yp2::RouterFleXML::Rep::jump_to(const xmlNode* node,
100 for (; node && node->type != xml_node_type; node = node->next)
105 bool yp2::RouterFleXML::Rep::check_element_yp2(const xmlNode *ptr,
106 const std::string &name)
108 if (!yp2::xml::is_element_yp2(ptr, name))
109 throw XMLError("Expected element name " + name);
114 void yp2::RouterFleXML::Rep::parse_xml_filters(xmlDocPtr doc,
117 unsigned int filter_nr = 0;
118 while(node && check_element_yp2(node, "filter"))
122 const struct _xmlAttr *attr;
123 std::string id_value;
124 std::string type_value;
125 for (attr = node->properties; attr; attr = attr->next)
127 std::string name = std::string((const char *) attr->name);
130 if (attr->children && attr->children->type == XML_TEXT_NODE)
131 value = std::string((const char *)attr->children->content);
135 else if (name == "type")
138 throw XMLError("Only attribute id or type allowed"
139 " in filter element. Got " + name);
142 yp2::filter::Base* filter_base = m_factory->create(type_value);
144 filter_base->configure(node);
146 if (m_id_filter_map.find(id_value) != m_id_filter_map.end())
147 throw XMLError("Filter " + id_value + " already defined");
149 m_id_filter_map[id_value] =
150 boost::shared_ptr<yp2::filter::Base>(filter_base);
152 node = jump_to_next(node, XML_ELEMENT_NODE);
156 void yp2::RouterFleXML::Rep::parse_xml_routes(xmlDocPtr doc,
159 check_element_yp2(node, "route");
161 unsigned int route_nr = 0;
162 while(yp2::xml::is_element_yp2(node, "route"))
166 const struct _xmlAttr *attr;
167 std::string id_value;
168 for (attr = node->properties; attr; attr = attr->next)
170 std::string name = std::string((const char *) attr->name);
173 if (attr->children && attr->children->type == XML_TEXT_NODE)
174 value = std::string((const char *)attr->children->content);
179 throw XMLError("Only attribute 'id' allowed for element"
186 // process <filter> nodes in third level
187 const xmlNode* node3 = jump_to_children(node, XML_ELEMENT_NODE);
189 unsigned int filter3_nr = 0;
190 while(node3 && check_element_yp2(node3, "filter"))
194 const struct _xmlAttr *attr;
195 std::string refid_value;
196 std::string type_value;
197 for (attr = node3->properties; attr; attr = attr->next)
199 std::string name = std::string((const char *) attr->name);
202 if (attr->children && attr->children->type == XML_TEXT_NODE)
203 value = std::string((const char *)attr->children->content);
207 else if (name == "type")
210 throw XMLError("Only attribute 'refid' or 'type'"
211 " allowed for element 'filter'."
214 if (refid_value.length())
216 std::map<std::string,
217 boost::shared_ptr<const yp2::filter::Base > >::iterator it;
218 it = m_id_filter_map.find(refid_value);
219 if (it == m_id_filter_map.end())
220 throw XMLError("Unknown filter refid " + refid_value);
222 route.m_list.push_back(it->second);
224 else if (type_value.length())
226 yp2::filter::Base* filter_base = m_factory->create(type_value);
228 filter_base->configure(node3);
230 route.m_list.push_back(
231 boost::shared_ptr<yp2::filter::Base>(filter_base));
233 node3 = jump_to_next(node3, XML_ELEMENT_NODE);
236 std::map<std::string,RouterFleXML::Route>::iterator it;
237 it = m_routes.find(id_value);
238 if (it != m_routes.end())
239 throw XMLError("Route id='" + id_value + "' already exist");
241 m_routes[id_value] = route;
242 node = jump_to_next(node, XML_ELEMENT_NODE);
246 void yp2::RouterFleXML::Rep::parse_xml_config_dom(xmlDocPtr doc)
249 throw XMLError("Empty XML Document");
251 const xmlNode* root = xmlDocGetRootElement(doc);
253 check_element_yp2(root, "yp2");
255 // process <start> node which is expected first element node
256 const xmlNode* node = jump_to_children(root, XML_ELEMENT_NODE);
257 if (check_element_yp2(node, "start"))
259 const struct _xmlAttr *attr;
260 std::string id_value;
261 for (attr = node->properties; attr; attr = attr->next)
263 std::string name = std::string((const char *) attr->name);
266 if (attr->children && attr->children->type == XML_TEXT_NODE)
267 value = std::string((const char *)attr->children->content);
270 m_start_route = value;
272 throw XMLError("Only attribute start allowed"
273 " in element 'start'. Got " + name);
275 node = jump_to_next(node, XML_ELEMENT_NODE);
277 // process <filters> node which is expected second element node
278 check_element_yp2(node, "filters");
280 parse_xml_filters(doc, jump_to_children(node, XML_ELEMENT_NODE));
282 // process <routes> node which is expected third element node
283 node = jump_to_next(node, XML_ELEMENT_NODE);
284 check_element_yp2(node, "routes");
286 parse_xml_routes(doc, jump_to_children(node, XML_ELEMENT_NODE));
289 yp2::RouterFleXML::Rep::Rep() : m_xinclude(false)
293 void yp2::RouterFleXML::Rep::base(xmlDocPtr doc, yp2::FactoryFilter &factory)
295 m_factory = &factory;
296 parse_xml_config_dom(doc);
297 m_start_route = "start";
300 yp2::RouterFleXML::RouterFleXML(xmlDocPtr doc, yp2::FactoryFilter &factory)
303 m_p->base(doc, factory);
306 yp2::RouterFleXML::RouterFleXML(std::string xmlconf, yp2::FactoryFilter &factory)
311 xmlDocPtr doc = xmlParseMemory(xmlconf.c_str(),
314 throw XMLError("xmlParseMemory failed");
317 m_p->base(doc, factory);
322 yp2::RouterFleXML::~RouterFleXML()
326 const yp2::filter::Base *yp2::RouterFleXML::Pos::move()
328 if (m_filter_it == m_route_it->second.m_list.end())
330 const yp2::filter::Base *f = (*m_filter_it).get();
335 yp2::RoutePos *yp2::RouterFleXML::createpos() const
337 yp2::RouterFleXML::Pos *p = new yp2::RouterFleXML::Pos;
339 p->m_route_it = m_p->m_routes.find(m_p->m_start_route);
340 if (p->m_route_it == m_p->m_routes.end())
345 p->m_filter_it = p->m_route_it->second.m_list.begin();
350 yp2::RoutePos *yp2::RouterFleXML::Pos::clone()
352 yp2::RouterFleXML::Pos *p = new yp2::RouterFleXML::Pos;
353 p->m_filter_it = m_filter_it;
354 p->m_route_it = m_route_it;
359 yp2::RouterFleXML::Pos::~Pos()
367 * indent-tabs-mode: nil
368 * c-file-style: "stroustrup"
370 * vim: shiftwidth=4 tabstop=8 expandtab