metaproxy  1.13.0
Private Types | Private Member Functions | Private Attributes | Friends | List of all members
metaproxy_1::RouterFleXML::Rep Class Reference
Collaboration diagram for metaproxy_1::RouterFleXML::Rep:
Collaboration graph

Private Types

typedef std::map< std::string, boost::shared_ptr< const mp::filter::Base > > IdFilterMap
 

Private Member Functions

 Rep ()
 
void base (xmlDocPtr doc, mp::FactoryFilter &factory, bool test_only, const char *file_include_path)
 
void parse_xml_config_dom (xmlDocPtr doc, bool test_only, const char *file_include_path)
 
void parse_xml_filters (xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path)
 
void parse_xml_filters1 (xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path, Route &route)
 
void parse_xml_routes (xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path)
 
void check_routes_in_filters (const xmlNode *n)
 

Private Attributes

IdFilterMap m_id_filter_map
 
std::map< std::string, RouterFleXML::Routem_routes
 
std::string m_start_route
 
std::string m_dl_path
 
bool m_xinclude
 
FactoryFilterm_factory
 

Friends

class RouterFleXML
 
class RouterFleXML::Pos
 

Detailed Description

Definition at line 47 of file router_flexml.cpp.

Member Typedef Documentation

typedef std::map<std::string, boost::shared_ptr<const mp::filter::Base > > metaproxy_1::RouterFleXML::Rep::IdFilterMap
private

Definition at line 57 of file router_flexml.cpp.

Constructor & Destructor Documentation

metaproxy_1::RouterFleXML::Rep::Rep ( )
private

Definition at line 415 of file router_flexml.cpp.

415  : m_xinclude(false)
416 {
417 }

Member Function Documentation

void metaproxy_1::RouterFleXML::Rep::base ( xmlDocPtr  doc,
mp::FactoryFilter factory,
bool  test_only,
const char *  file_include_path 
)
private

Definition at line 419 of file router_flexml.cpp.

References m_factory, m_start_route, and parse_xml_config_dom().

421 {
422  m_factory = &factory;
423  m_start_route = "start";
424  parse_xml_config_dom(doc, test_only, file_include_path);
425 }
void parse_xml_config_dom(xmlDocPtr doc, bool test_only, const char *file_include_path)

Here is the call graph for this function:

void metaproxy_1::RouterFleXML::Rep::check_routes_in_filters ( const xmlNode *  n)
private

Definition at line 272 of file router_flexml.cpp.

273 {
274  while (node)
275  {
276  if (mp::xml::is_element_mp(node, "filters"))
277  {
278  const xmlNode *n =
279  mp::xml::jump_to_children(node, XML_ELEMENT_NODE);
281  }
282  else if (mp::xml::is_element_mp(node, "filter"))
283  {
284  const xmlNode *n =
285  mp::xml::jump_to_children(node, XML_ELEMENT_NODE);
286  while (n)
287  {
288  const struct _xmlAttr *attr;
289  // we assume thar that route attribute is only at one level
290  // below filter.. At least that works for multi and virt_db.
291  for (attr = n->properties; attr; attr = attr->next)
292  {
293  if (!strcmp((const char *) attr->name, "route"))
294  {
295  std::string value;
296 
297  if (attr->children && attr->children->type == XML_TEXT_NODE)
298  value = std::string((const char *)attr->children->content);
299 
300  std::map<std::string,RouterFleXML::Route>::iterator it;
301  it = m_routes.find(value);
302  if (it == m_routes.end())
303  {
304  throw mp::XMLError("Route '" + value + "' does not exist");
305  }
306  }
307  }
308  n = mp::xml::jump_to_next(n, XML_ELEMENT_NODE);
309  }
310  }
311  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
312  }
313 }
void check_routes_in_filters(const xmlNode *n)
std::map< std::string, RouterFleXML::Route > m_routes
void metaproxy_1::RouterFleXML::Rep::parse_xml_config_dom ( xmlDocPtr  doc,
bool  test_only,
const char *  file_include_path 
)
private

Definition at line 315 of file router_flexml.cpp.

Referenced by base().

318 {
319  if (!doc)
320  throw mp::XMLError("Empty XML Document");
321 
322  const xmlNode* root = xmlDocGetRootElement(doc);
323 
324  if (file_include_path)
325  {
326  int r = yaz_xml_include_glob((xmlNode *) root, file_include_path,
327  YAZ_FILE_GLOB_FAIL_NOTEXIST);
328  if (r)
329  throw mp::XMLError("YAZ XML Include failed");
330  }
331 
332  mp::xml::check_element_mp(root, "metaproxy");
333 
334  const xmlNode* node = mp::xml::jump_to_children(root, XML_ELEMENT_NODE);
335 
336  if (mp::xml::is_element_mp(node, "dlpath"))
337  {
338  m_dl_path = mp::xml::get_text(node);
339  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
340  }
341  // process <start> node which is expected first element node
342  if (mp::xml::check_element_mp(node, "start"))
343  {
344  const struct _xmlAttr *attr;
345  for (attr = node->properties; attr; attr = attr->next)
346  {
347  std::string name = std::string((const char *) attr->name);
348  std::string value;
349 
350  if (attr->children && attr->children->type == XML_TEXT_NODE)
351  value = std::string((const char *)attr->children->content);
352 
353  if (name == "route")
354  m_start_route = value;
355  else if (name == "base")
356  ;// Ignore XInclude base attribute.
357  else
358  throw mp::XMLError("Only attribute route allowed"
359  " in element 'start'. Got " + name);
360  }
361  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
362  }
363  // process <filters> node if given
364  if (mp::xml::is_element_mp(node, "filters"))
365  {
366  parse_xml_filters(doc, mp::xml::jump_to_children(node,
367  XML_ELEMENT_NODE),
368  test_only, file_include_path);
369 
370  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
371  }
372  // process <routes> node which is expected third element node
373  mp::xml::check_element_mp(node, "routes");
374 
375  parse_xml_routes(doc, mp::xml::jump_to_children(node, XML_ELEMENT_NODE),
376  test_only, file_include_path);
377 
378  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
379  if (node)
380  {
381  throw mp::XMLError("Unexpected element "
382  + std::string((const char *)node->name));
383  }
384 
385  node = mp::xml::jump_to_children(root, XML_ELEMENT_NODE);
386  while (node)
387  {
388  if (mp::xml::is_element_mp(node, "filters"))
390  mp::xml::jump_to_children(node,
391  XML_ELEMENT_NODE));
392  else if (mp::xml::is_element_mp(node, "routes"))
393  {
394  const xmlNode* n = mp::xml::jump_to_children(node,
395  XML_ELEMENT_NODE);
396  while (n)
397  {
398  if (mp::xml::is_element_mp(n, "route"))
399  {
401  mp::xml::jump_to_children(n, XML_ELEMENT_NODE));
402 
403  }
404  n = mp::xml::jump_to_next(n, XML_ELEMENT_NODE);
405  }
406  }
407  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
408  }
409  std::map<std::string,RouterFleXML::Route>::iterator it;
410  it = m_routes.find(m_start_route);
411  if (it == m_routes.end())
412  throw mp::XMLError("Start route '" + m_start_route + "' not found");
413 }
void parse_xml_routes(xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path)
void parse_xml_filters(xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path)
void check_routes_in_filters(const xmlNode *n)
std::map< std::string, RouterFleXML::Route > m_routes
void metaproxy_1::RouterFleXML::Rep::parse_xml_filters ( xmlDocPtr  doc,
const xmlNode *  node,
bool  test_only,
const char *  file_include_path 
)
private

Definition at line 97 of file router_flexml.cpp.

101 {
102  unsigned int filter_nr = 0;
103  while (node && mp::xml::check_element_mp(node, "filter"))
104  {
105  filter_nr++;
106 
107  const struct _xmlAttr *attr;
108  std::string id_value;
109  std::string type_value;
110  for (attr = node->properties; attr; attr = attr->next)
111  {
112  std::string name = std::string((const char *) attr->name);
113  std::string value;
114 
115  if (attr->children && attr->children->type == XML_TEXT_NODE)
116  value = std::string((const char *)attr->children->content);
117 
118  if (name == "id")
119  id_value = value;
120  else if (name == "type")
121  type_value = value;
122  else if (name == "base")
123  ;// Ignore XInclude base attribute.
124  else
125  throw mp::XMLError("Only attribute id or type allowed"
126  " in filter element. Got " + name);
127  }
128 
129  if (!m_factory->exist(type_value))
130  {
131  yaz_log(YLOG_LOG, "Loading %s (dlpath %s)",
132  type_value.c_str(), m_dl_path.c_str());
133  m_factory->add_creator_dl(type_value, m_dl_path);
134  }
135  boost::shared_ptr<mp::filter::Base> fb(m_factory->create(type_value));
136 
137  fb->configure(node, test_only, file_include_path);
138 
139  if (m_id_filter_map.find(id_value) != m_id_filter_map.end())
140  throw mp::XMLError("Filter " + id_value + " already defined");
141 
142  m_id_filter_map[id_value] = fb;
143 
144  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
145  }
146 }
bool exist(std::string fi)
bool add_creator_dl(const std::string &fi, const std::string &path)
metaproxy_1::filter::Base * create(std::string fi)
void metaproxy_1::RouterFleXML::Rep::parse_xml_filters1 ( xmlDocPtr  doc,
const xmlNode *  node,
bool  test_only,
const char *  file_include_path,
Route route 
)
private

Definition at line 148 of file router_flexml.cpp.

References metaproxy_1::RouterFleXML::Route::m_list.

153 {
154  while (node)
155  {
156  if (mp::xml::is_element_mp(node, "filters"))
157  {
158  const xmlNode* node1 =
159  mp::xml::jump_to_children(node, XML_ELEMENT_NODE);
160 
161  parse_xml_filters1(doc, node1, test_only, file_include_path, route);
162  }
163  else if (mp::xml::check_element_mp(node, "filter"))
164  {
165  const struct _xmlAttr *attr;
166  std::string refid_value;
167  std::string type_value;
168  for (attr = node->properties; attr; attr = attr->next)
169  {
170  std::string name = std::string((const char *) attr->name);
171  std::string value;
172 
173  if (attr->children && attr->children->type == XML_TEXT_NODE)
174  value = std::string((const char *)attr->children->content);
175 
176  if (name == "refid")
177  refid_value = value;
178  else if (name == "type")
179  type_value = value;
180  else if (name == "base")
181  ;// Ignore XInclude base attribute.
182  else
183  throw mp::XMLError("Only attribute 'refid' or 'type'"
184  " allowed for element 'filter'."
185  " Got " + name);
186  }
187  if (refid_value.length())
188  {
189  std::map<std::string,
190  boost::shared_ptr<const mp::filter::Base > >::iterator it;
191  it = m_id_filter_map.find(refid_value);
192  if (it == m_id_filter_map.end())
193  throw mp::XMLError("Unknown filter refid "
194  + refid_value);
195  else
196  route.m_list.push_back(it->second);
197  }
198  else if (type_value.length())
199  {
200  if (!m_factory->exist(type_value))
201  {
202  yaz_log(YLOG_LOG, "Loading %s (dlpath %s)",
203  type_value.c_str(), m_dl_path.c_str());
204  m_factory->add_creator_dl(type_value, m_dl_path);
205  }
206  boost::shared_ptr<mp::filter::Base>
207  filter_base(m_factory->create(type_value));
208 
209  filter_base->configure(node, test_only, file_include_path);
210 
211  route.m_list.push_back(filter_base);
212  }
213 
214  }
215  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
216  }
217 }
void parse_xml_filters1(xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path, Route &route)
bool exist(std::string fi)
bool add_creator_dl(const std::string &fi, const std::string &path)
metaproxy_1::filter::Base * create(std::string fi)
void metaproxy_1::RouterFleXML::Rep::parse_xml_routes ( xmlDocPtr  doc,
const xmlNode *  node,
bool  test_only,
const char *  file_include_path 
)
private

Definition at line 220 of file router_flexml.cpp.

224 {
225  mp::xml::check_element_mp(node, "route");
226 
227  unsigned int route_nr = 0;
228  while (mp::xml::is_element_mp(node, "route"))
229  {
230  route_nr++;
231 
232  const struct _xmlAttr *attr;
233  std::string id_value;
234  for (attr = node->properties; attr; attr = attr->next)
235  {
236  std::string name = std::string((const char *) attr->name);
237  std::string value;
238 
239  if (attr->children && attr->children->type == XML_TEXT_NODE)
240  value = std::string((const char *)attr->children->content);
241 
242  if (name == "id")
243  id_value = value;
244  else if (name == "base")
245  ;// Ignore XInclude base attribute.
246  else
247  throw mp::XMLError("Only attribute 'id' allowed for"
248  " element 'route'."
249  " Got " + name);
250  }
251 
252  Route route;
253 
254  // process <filter> / <filters> nodes in third level
255  const xmlNode* node3 = mp::xml::jump_to_children(node, XML_ELEMENT_NODE);
256 
257 
258 
259  parse_xml_filters1(doc, node3, test_only, file_include_path, route);
260 
261  std::map<std::string,RouterFleXML::Route>::iterator it;
262  it = m_routes.find(id_value);
263  if (it != m_routes.end())
264  throw mp::XMLError("Route id='" + id_value
265  + "' already exist");
266  else
267  m_routes[id_value] = route;
268  node = mp::xml::jump_to_next(node, XML_ELEMENT_NODE);
269  }
270 }
void parse_xml_filters1(xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path, Route &route)
std::map< std::string, RouterFleXML::Route > m_routes

Friends And Related Function Documentation

friend class RouterFleXML
friend

Definition at line 48 of file router_flexml.cpp.

friend class RouterFleXML::Pos
friend

Definition at line 49 of file router_flexml.cpp.

Member Data Documentation

std::string metaproxy_1::RouterFleXML::Rep::m_dl_path
private

Definition at line 65 of file router_flexml.cpp.

FactoryFilter* metaproxy_1::RouterFleXML::Rep::m_factory
private

Definition at line 81 of file router_flexml.cpp.

Referenced by base().

IdFilterMap metaproxy_1::RouterFleXML::Rep::m_id_filter_map
private

Definition at line 59 of file router_flexml.cpp.

std::map<std::string,RouterFleXML::Route> metaproxy_1::RouterFleXML::Rep::m_routes
private

Definition at line 61 of file router_flexml.cpp.

std::string metaproxy_1::RouterFleXML::Rep::m_start_route
private

Definition at line 63 of file router_flexml.cpp.

Referenced by base().

bool metaproxy_1::RouterFleXML::Rep::m_xinclude
private

Definition at line 79 of file router_flexml.cpp.


The documentation for this class was generated from the following file: