metaproxy 1.22.1
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::Route > m_routes
 
std::string m_start_route
 
std::string m_dl_path
 
bool m_xinclude
 
FactoryFilter * m_factory
 

Friends

class RouterFleXML
 
class RouterFleXML::Pos
 

Detailed Description

Definition at line 47 of file router_flexml.cpp.

Member Typedef Documentation

◆ IdFilterMap

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

◆ Rep()

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

Definition at line 415 of file router_flexml.cpp.

415 : m_xinclude(false)
416{
417}
metaproxy_1::RouterFleXML::Rep::m_xinclude
bool m_xinclude
Definition router_flexml.cpp:79

Member Function Documentation

◆ base()

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.

421{
422 m_factory = &factory;
423 m_start_route = "start";
424 parse_xml_config_dom(doc, test_only, file_include_path);
425}
metaproxy_1::RouterFleXML::Rep::m_factory
FactoryFilter * m_factory
Definition router_flexml.cpp:81
metaproxy_1::RouterFleXML::Rep::m_start_route
std::string m_start_route
Definition router_flexml.cpp:63
metaproxy_1::RouterFleXML::Rep::parse_xml_config_dom
void parse_xml_config_dom(xmlDocPtr doc, bool test_only, const char *file_include_path)
Definition router_flexml.cpp:315
metaproxy_1::RouterFleXML::start
void start()
Definition router_flexml.cpp:501

References metaproxy_1::RouterFleXML::start().

Here is the call graph for this function:

◆ check_routes_in_filters()

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);
280 check_routes_in_filters(n);
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}
metaproxy_1::RouterFleXML::Rep::check_routes_in_filters
void check_routes_in_filters(const xmlNode *n)
Definition router_flexml.cpp:272
metaproxy_1::RouterFleXML::Rep::m_routes
std::map< std::string, RouterFleXML::Route > m_routes
Definition router_flexml.cpp:61

◆ parse_xml_config_dom()

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.

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"))
389 check_routes_in_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 {
400 check_routes_in_filters(
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}
metaproxy_1::RouterFleXML::Rep::m_dl_path
std::string m_dl_path
Definition router_flexml.cpp:65
metaproxy_1::RouterFleXML::Rep::parse_xml_filters
void parse_xml_filters(xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path)
Definition router_flexml.cpp:97
metaproxy_1::RouterFleXML::Rep::parse_xml_routes
void parse_xml_routes(xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path)
Definition router_flexml.cpp:220

◆ parse_xml_filters()

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}
metaproxy_1::FactoryFilter::create
metaproxy_1::filter::Base * create(std::string fi)
Definition factory_filter.cpp:92
metaproxy_1::FactoryFilter::add_creator_dl
bool add_creator_dl(const std::string &fi, const std::string &path)
Definition factory_filter.cpp:104
metaproxy_1::FactoryFilter::exist
bool exist(std::string fi)
Definition factory_filter.cpp:81
metaproxy_1::RouterFleXML::Rep::m_id_filter_map
IdFilterMap m_id_filter_map
Definition router_flexml.cpp:59

◆ parse_xml_filters1()

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.

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}
metaproxy_1::RouterFleXML::Rep::parse_xml_filters1
void parse_xml_filters1(xmlDocPtr doc, const xmlNode *node, bool test_only, const char *file_include_path, Route &route)
Definition router_flexml.cpp:148

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

◆ parse_xml_routes()

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}

Friends And Related Symbol Documentation

◆ RouterFleXML

friend class RouterFleXML
friend

Definition at line 48 of file router_flexml.cpp.

◆ RouterFleXML::Pos

friend class RouterFleXML::Pos
friend

Definition at line 49 of file router_flexml.cpp.

Member Data Documentation

◆ m_dl_path

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

Definition at line 65 of file router_flexml.cpp.

◆ m_factory

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

Definition at line 81 of file router_flexml.cpp.

◆ m_id_filter_map

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

Definition at line 59 of file router_flexml.cpp.

◆ m_routes

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

Definition at line 61 of file router_flexml.cpp.

◆ m_start_route

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

Definition at line 63 of file router_flexml.cpp.

◆ m_xinclude

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:
Generated by doxygen 1.9.8