CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Member Functions | Private Attributes
MonitorXMLParser Class Reference

#include <MonitorXMLParser.h>

Public Member Functions

const std::vector< DB_ME > & getDB_ME (void) const
 
void load () throw ( std::runtime_error )
 
 MonitorXMLParser (const std::string &fromFile)
 
 ~MonitorXMLParser () throw ()
 

Private Member Functions

void handleElement (xercesc::DOMElement *element)
 

Private Attributes

std::vector< DB_ME > DBMonitoringElements_
 
xercesc::XercesDOMParser * parser_
 
TagNames * tags_
 
std::string xmlFile_
 

Detailed Description

Definition at line 162 of file MonitorXMLParser.h.

Constructor & Destructor Documentation

MonitorXMLParser::MonitorXMLParser ( const std::string &  fromFile)

Definition at line 21 of file MonitorXMLParser.cc.

References dtNoiseDBValidation_cfg::cerr, alignCSCRings::e, ERROR_XERCES_INIT, cmsRelvalreport::exit, python.rootplot.argparse::message, parser_, fetchall_from_DQM_v2::release, tags_, and xmlFile_.

21  {
22 
23  try{
24 
25  xercesc::XMLPlatformUtils::Initialize();
26 
27  }catch( xercesc::XMLException& e ){
28 
29  char* message = xercesc::XMLString::transcode( e.getMessage() ) ;
30 
31  std::cerr << "XML toolkit initialization error: " << message << std::endl;
32 
33  xercesc::XMLString::release( &message );
34 
35  exit( ERROR_XERCES_INIT );
36 
37  }
38 
39  xmlFile_ = fromFile;
40  parser_ = new xercesc::XercesDOMParser();
41  tags_ = new TagNames();
42 
43 }
MonitorXMLParser::xmlFile_
std::string xmlFile_
Definition: MonitorXMLParser.h:167
fetchall_from_DQM_v2.release
tuple release
Definition: fetchall_from_DQM_v2.py:110
dtNoiseDBValidation_cfg.cerr
tuple cerr
Definition: dtNoiseDBValidation_cfg.py:22
MonitorXMLParser::parser_
xercesc::XercesDOMParser * parser_
Definition: MonitorXMLParser.h:168
MonitorXMLParser::~MonitorXMLParser ( )
throw (
)

Definition at line 47 of file MonitorXMLParser.cc.

References dtNoiseDBValidation_cfg::cerr, alignCSCRings::e, python.rootplot.argparse::message, parser_, fetchall_from_DQM_v2::release, and tags_.

47  {
48 
49  try{
50  xercesc::XMLPlatformUtils::Terminate();
51  } catch ( xercesc::XMLException& e ){
52  char* message = xercesc::XMLString::transcode( e.getMessage() );
53  std::cerr << "XML toolkit teardown error: " << message << std::endl;
54  xercesc::XMLString::release( &message ) ;
55  }
56 
57  delete parser_;
58  delete tags_;
59 
60 }
fetchall_from_DQM_v2.release
tuple release
Definition: fetchall_from_DQM_v2.py:110
dtNoiseDBValidation_cfg.cerr
tuple cerr
Definition: dtNoiseDBValidation_cfg.py:22
MonitorXMLParser::parser_
xercesc::XercesDOMParser * parser_
Definition: MonitorXMLParser.h:168

Member Function Documentation

const std::vector< DB_ME >& MonitorXMLParser::getDB_ME ( void  ) const
inline

Definition at line 178 of file MonitorXMLParser.h.

References DBMonitoringElements_.

Referenced by MonitorElementsDb::MonitorElementsDb().

178 { return (DBMonitoringElements_ ); }
MonitorXMLParser::DBMonitoringElements_
std::vector< DB_ME > DBMonitoringElements_
Definition: MonitorXMLParser.h:166
void MonitorXMLParser::handleElement ( xercesc::DOMElement *  element)
private

Definition at line 66 of file MonitorXMLParser.cc.

References DbQuery::alias, DbQuery::arg, TagNames::ATTR_ALIAS, TagNames::ATTR_ARG, TagNames::ATTR_LOOP, TagNames::ATTR_NAME, TagNames::ATTR_NCYCLE, TagNames::ATTR_TITLE, TagNames::ATTR_XBINS, TagNames::ATTR_XFROM, TagNames::ATTR_XTO, TagNames::ATTR_YBINS, TagNames::ATTR_YFROM, TagNames::ATTR_YTO, TagNames::ATTR_ZBINS, TagNames::ATTR_ZFROM, TagNames::ATTR_ZTO, trackerHits::c, DBMonitoringElements_, alignCSCRings::e, DB_ME::loop, DB_ME::ncycle, DB_ME::queries, DbQuery::query, fetchall_from_DQM_v2::release, alignCSCRings::s, TagNames::TAG_1D, TagNames::TAG_2D, TagNames::TAG_ME, TagNames::TAG_QUERY, TagNames::TAG_TPROFILE, TagNames::TAG_TPROFILE2D, tags_, DB_ME::title, DB_ME::type, DB_ME::xbins, DB_ME::xfrom, DB_ME::xto, DB_ME::ybins, DB_ME::yfrom, DB_ME::yto, DB_ME::zbins, DB_ME::zfrom, and DB_ME::zto.

Referenced by load().

66  {
67 
68  if( xercesc::XMLString::equals( tags_->TAG_ME, element->getTagName() ) ) {
69 
70  char* c;
71  std::stringstream s;
72  DB_ME me;
73  bool meok;
74 
75  meok = false;
76 
77  xercesc::DOMNodeList* d1Nodes = element->getElementsByTagName( tags_->TAG_1D );
78  const XMLSize_t d1Count = d1Nodes->getLength();
79 
80  for( XMLSize_t d1Index = 0; d1Index < d1Count; ++d1Index ){
81 
82  xercesc::DOMNode* d1Node = d1Nodes->item( d1Index ) ;
83 
84  xercesc::DOMElement* d1Element = dynamic_cast< xercesc::DOMElement* >( d1Node ) ;
85 
86  const XMLCh* d1titleXMLCh = d1Element->getAttribute( tags_->ATTR_TITLE ) ;
87  c = xercesc::XMLString::transcode( d1titleXMLCh );
88  me.type = "th1d";
89  me.title = c;
90  meok = true;
91  xercesc::XMLString::release( &c );
92 
93  const XMLCh* d1xbinsXMLCh = d1Element->getAttribute( tags_->ATTR_XBINS ) ;
94  c = xercesc::XMLString::transcode( d1xbinsXMLCh );
95  s.clear(); s.str( c );
96  s >> me.xbins;
97  xercesc::XMLString::release( &c );
98 
99  const XMLCh* d1xfromXMLCh = d1Element->getAttribute( tags_->ATTR_XFROM ) ;
100  c = xercesc::XMLString::transcode( d1xfromXMLCh );
101  s.clear(); s.str( c );
102  s >> me.xfrom;
103  xercesc::XMLString::release( &c );
104 
105  const XMLCh* d1xtoXMLCh = d1Element->getAttribute( tags_->ATTR_XTO ) ;
106  c = xercesc::XMLString::transcode( d1xtoXMLCh );
107  s.clear(); s.str( c );
108  s >> me.xto;
109  xercesc::XMLString::release( &c );
110 
111  const XMLCh* d1ncycleXMLCh = d1Element->getAttribute( tags_->ATTR_NCYCLE ) ;
112  c = xercesc::XMLString::transcode( d1ncycleXMLCh );
113  s.clear(); s.str( c );
114  s >> me.ncycle;
115  xercesc::XMLString::release( &c );
116 
117  const XMLCh* d1loopXMLCh = d1Element->getAttribute( tags_->ATTR_LOOP ) ;
118  c = xercesc::XMLString::transcode( d1loopXMLCh );
119  s.clear(); s.str( c );
120  s >> me.loop;
121  xercesc::XMLString::release( &c );
122 
123  me.ybins = 0;
124  me.yfrom = 0.0;
125  me.yto = 0.0;
126  me.zbins = 0;
127  me.zfrom = 0.0;
128  me.zto = 0.0;
129 
130  }
131 
132  xercesc::DOMNodeList* d2Nodes = element->getElementsByTagName( tags_->TAG_2D );
133  const XMLSize_t d2Count = d2Nodes->getLength();
134 
135  for( XMLSize_t d2Index = 0; d2Index < d2Count; ++d2Index ){
136 
137  xercesc::DOMNode* d2Node = d2Nodes->item( d2Index ) ;
138 
139  xercesc::DOMElement* d2Element = dynamic_cast< xercesc::DOMElement* >( d2Node ) ;
140 
141  const XMLCh* d2titleXMLCh = d2Element->getAttribute( tags_->ATTR_TITLE ) ;
142  c = xercesc::XMLString::transcode( d2titleXMLCh );
143  me.type = "th2d";
144  me.title = c;
145  meok = true;
146  xercesc::XMLString::release( &c );
147 
148  const XMLCh* d2xbinsXMLCh = d2Element->getAttribute( tags_->ATTR_XBINS ) ;
149  c = xercesc::XMLString::transcode( d2xbinsXMLCh );
150  s.clear(); s.str( c );
151  s >> me.xbins;
152  xercesc::XMLString::release( &c );
153 
154  const XMLCh* d2xfromXMLCh = d2Element->getAttribute( tags_->ATTR_XFROM ) ;
155  c = xercesc::XMLString::transcode( d2xfromXMLCh );
156  s.clear(); s.str( c );
157  s >> me.xfrom;
158  xercesc::XMLString::release( &c );
159 
160  const XMLCh* d2xtoXMLCh = d2Element->getAttribute( tags_->ATTR_XTO ) ;
161  c = xercesc::XMLString::transcode( d2xtoXMLCh );
162  s.clear(); s.str( c );
163  s >> me.xto;
164  xercesc::XMLString::release( &c );
165 
166  const XMLCh* d2ybinsXMLCh = d2Element->getAttribute( tags_->ATTR_YBINS ) ;
167  c = xercesc::XMLString::transcode( d2ybinsXMLCh );
168  s.clear(); s.str( c );
169  s >> me.ybins;
170  xercesc::XMLString::release( &c );
171 
172  const XMLCh* d2yfromXMLCh = d2Element->getAttribute( tags_->ATTR_YFROM ) ;
173  c = xercesc::XMLString::transcode( d2yfromXMLCh );
174  s.clear(); s.str( c );
175  s >> me.yfrom;
176  xercesc::XMLString::release( &c );
177 
178  const XMLCh* d2ytoXMLCh = d2Element->getAttribute( tags_->ATTR_YTO ) ;
179  c = xercesc::XMLString::transcode( d2ytoXMLCh );
180  s.clear(); s.str( c );
181  s >> me.yto;
182  xercesc::XMLString::release( &c );
183 
184  const XMLCh* d2ncycleXMLCh = d2Element->getAttribute( tags_->ATTR_NCYCLE ) ;
185  c = xercesc::XMLString::transcode( d2ncycleXMLCh );
186  s.clear(); s.str( c );
187  s >> me.ncycle;
188  xercesc::XMLString::release( &c );
189 
190  const XMLCh* d2loopXMLCh = d2Element->getAttribute( tags_->ATTR_LOOP ) ;
191  c = xercesc::XMLString::transcode( d2loopXMLCh );
192  s.clear(); s.str( c );
193  s >> me.loop;
194  xercesc::XMLString::release( &c );
195 
196  me.zbins = 0;
197  me.zfrom = 0.0;
198  me.zto = 0.0;
199 
200  }
201 
202  xercesc::DOMNodeList* tpNodes = element->getElementsByTagName( tags_->TAG_TPROFILE );
203  const XMLSize_t tpCount = tpNodes->getLength();
204 
205  for( XMLSize_t tpIndex = 0; tpIndex < tpCount; ++tpIndex ){
206 
207  xercesc::DOMNode* tpNode = tpNodes->item( tpIndex ) ;
208 
209  xercesc::DOMElement* tpElement = dynamic_cast< xercesc::DOMElement* >( tpNode ) ;
210 
211  const XMLCh* tptitleXMLCh = tpElement->getAttribute( tags_->ATTR_TITLE ) ;
212  c = xercesc::XMLString::transcode( tptitleXMLCh );
213  me.type = "tprofile";
214  me.title = c;
215  meok = true;
216  xercesc::XMLString::release( &c );
217 
218  const XMLCh* tpxbinsXMLCh = tpElement->getAttribute( tags_->ATTR_XBINS ) ;
219  c = xercesc::XMLString::transcode( tpxbinsXMLCh );
220  s.clear(); s.str( c );
221  s >> me.xbins;
222  xercesc::XMLString::release( &c );
223 
224  const XMLCh* tpxfromXMLCh = tpElement->getAttribute( tags_->ATTR_XFROM ) ;
225  c = xercesc::XMLString::transcode( tpxfromXMLCh );
226  s.clear(); s.str( c );
227  s >> me.xfrom;
228  xercesc::XMLString::release( &c );
229 
230  const XMLCh* tpxtoXMLCh = tpElement->getAttribute( tags_->ATTR_XTO ) ;
231  c = xercesc::XMLString::transcode( tpxtoXMLCh );
232  s.clear(); s.str( c );
233  s >> me.xto;
234  xercesc::XMLString::release( &c );
235 
236  const XMLCh* tpybinsXMLCh = tpElement->getAttribute( tags_->ATTR_YBINS ) ;
237  c = xercesc::XMLString::transcode( tpybinsXMLCh );
238  s.clear(); s.str( c );
239  s >> me.ybins;
240  xercesc::XMLString::release( &c );
241 
242  const XMLCh* tpyfromXMLCh = tpElement->getAttribute( tags_->ATTR_YFROM ) ;
243  c = xercesc::XMLString::transcode( tpyfromXMLCh );
244  s.clear(); s.str( c );
245  s >> me.yfrom;
246  xercesc::XMLString::release( &c );
247 
248  const XMLCh* tpytoXMLCh = tpElement->getAttribute( tags_->ATTR_YTO ) ;
249  c = xercesc::XMLString::transcode( tpytoXMLCh );
250  s.clear(); s.str( c );
251  s >> me.yto;
252  xercesc::XMLString::release( &c );
253 
254  const XMLCh* tpncycleXMLCh = tpElement->getAttribute( tags_->ATTR_NCYCLE ) ;
255  c = xercesc::XMLString::transcode( tpncycleXMLCh );
256  s.clear(); s.str( c );
257  s >> me.ncycle;
258  xercesc::XMLString::release( &c );
259 
260  const XMLCh* tploopXMLCh = tpElement->getAttribute( tags_->ATTR_LOOP ) ;
261  c = xercesc::XMLString::transcode( tploopXMLCh );
262  s.clear(); s.str( c );
263  s >> me.loop;
264  xercesc::XMLString::release( &c );
265 
266  me.zbins = 0;
267  me.zfrom = 0.0;
268  me.zto = 0.0;
269 
270  }
271 
272  xercesc::DOMNodeList* tp2dNodes = element->getElementsByTagName( tags_->TAG_TPROFILE2D );
273  const XMLSize_t tp2dCount = tp2dNodes->getLength();
274 
275  for( XMLSize_t tp2dIndex = 0; tp2dIndex < tp2dCount; ++tp2dIndex ){
276 
277  xercesc::DOMNode* tp2dNode = tp2dNodes->item( tp2dIndex ) ;
278 
279  xercesc::DOMElement* tp2dElement = dynamic_cast< xercesc::DOMElement* >( tp2dNode ) ;
280 
281  const XMLCh* tp2dtitleXMLCh = tp2dElement->getAttribute( tags_->ATTR_TITLE ) ;
282  c = xercesc::XMLString::transcode( tp2dtitleXMLCh );
283  me.type = "tprofile2d";
284  me.title = c;
285  meok = true;
286  xercesc::XMLString::release( &c );
287 
288  const XMLCh* tp2dxbinsXMLCh = tp2dElement->getAttribute( tags_->ATTR_XBINS ) ;
289  c = xercesc::XMLString::transcode( tp2dxbinsXMLCh );
290  s.clear(); s.str( c );
291  s >> me.xbins;
292  xercesc::XMLString::release( &c );
293 
294  const XMLCh* tp2dxfromXMLCh = tp2dElement->getAttribute( tags_->ATTR_XFROM ) ;
295  c = xercesc::XMLString::transcode( tp2dxfromXMLCh );
296  s.clear(); s.str( c );
297  s >> me.xfrom;
298  xercesc::XMLString::release( &c );
299 
300  const XMLCh* tp2dxtoXMLCh = tp2dElement->getAttribute( tags_->ATTR_XTO ) ;
301  c = xercesc::XMLString::transcode( tp2dxtoXMLCh );
302  s.clear(); s.str( c );
303  s >> me.xto;
304  xercesc::XMLString::release( &c );
305 
306  const XMLCh* tp2dybinsXMLCh = tp2dElement->getAttribute( tags_->ATTR_YBINS ) ;
307  c = xercesc::XMLString::transcode( tp2dybinsXMLCh );
308  s.clear(); s.str( c );
309  s >> me.ybins;
310  xercesc::XMLString::release( &c );
311 
312  const XMLCh* tp2dyfromXMLCh = tp2dElement->getAttribute( tags_->ATTR_YFROM ) ;
313  c = xercesc::XMLString::transcode( tp2dyfromXMLCh );
314  s.clear(); s.str( c );
315  s >> me.yfrom;
316  xercesc::XMLString::release( &c );
317 
318  const XMLCh* tp2dytoXMLCh = tp2dElement->getAttribute( tags_->ATTR_YTO ) ;
319  c = xercesc::XMLString::transcode( tp2dytoXMLCh );
320  s.clear(); s.str( c );
321  s >> me.yto;
322  xercesc::XMLString::release( &c );
323 
324  const XMLCh* tp2dzbinsXMLCh = tp2dElement->getAttribute( tags_->ATTR_ZBINS ) ;
325  c = xercesc::XMLString::transcode( tp2dzbinsXMLCh );
326  s.clear(); s.str( c );
327  s >> me.zbins;
328  xercesc::XMLString::release( &c );
329 
330  const XMLCh* tp2dzfromXMLCh = tp2dElement->getAttribute( tags_->ATTR_ZFROM ) ;
331  c = xercesc::XMLString::transcode( tp2dzfromXMLCh );
332  s.clear(); s.str( c );
333  s >> me.zfrom;
334  xercesc::XMLString::release( &c );
335 
336  const XMLCh* tp2dztoXMLCh = tp2dElement->getAttribute( tags_->ATTR_ZTO ) ;
337  c = xercesc::XMLString::transcode( tp2dztoXMLCh );
338  s.clear(); s.str( c );
339  s >> me.zto;
340  xercesc::XMLString::release( &c );
341 
342  const XMLCh* tp2dncycleXMLCh = tp2dElement->getAttribute( tags_->ATTR_NCYCLE ) ;
343  c = xercesc::XMLString::transcode( tp2dncycleXMLCh );
344  s.clear(); s.str( c );
345  s >> me.ncycle;
346  xercesc::XMLString::release( &c );
347 
348  const XMLCh* tp2dloopXMLCh = tp2dElement->getAttribute( tags_->ATTR_LOOP ) ;
349  c = xercesc::XMLString::transcode( tp2dloopXMLCh );
350  s.clear(); s.str( c );
351  s >> me.loop;
352  xercesc::XMLString::release( &c );
353 
354  }
355 
356 
357  xercesc::DOMNodeList* qNodes = element->getElementsByTagName( tags_->TAG_QUERY );
358  const XMLSize_t qCount = qNodes->getLength();
359 
360  for( XMLSize_t qIndex = 0; qIndex < qCount; ++qIndex ){
361 
362  xercesc::DOMNode* qNode = qNodes->item( qIndex ) ;
363 
364  xercesc::DOMElement* qElement = dynamic_cast< xercesc::DOMElement* >( qNode ) ;
365 
366  const XMLCh* nameXMLCh = qElement->getAttribute( tags_->ATTR_NAME ) ;
367  c = xercesc::XMLString::transcode( nameXMLCh );
368 
369  const XMLCh* argXMLCh = qElement->getAttribute( tags_->ATTR_ARG ) ;
370  char* d = xercesc::XMLString::transcode( argXMLCh );
371 
372  const XMLCh* aliasXMLCh = qElement->getAttribute( tags_->ATTR_ALIAS ) ;
373  char* e = xercesc::XMLString::transcode( aliasXMLCh );
374 
375  DbQuery tmpQuery;
376  tmpQuery.query = c;
377  tmpQuery.arg = d;
378  tmpQuery.alias = e;
379 
380  me.queries.push_back( tmpQuery );
381 
382  xercesc::XMLString::release( &c );
383  xercesc::XMLString::release( &d );
384  xercesc::XMLString::release( &e );
385 
386 
387  }
388 
389  if( meok ) DBMonitoringElements_.push_back( me );
390 
391  }
392 } // handleElement()
TagNames::TAG_ME
XMLCh * TAG_ME
Definition: MonitorXMLParser.h:52
DB_ME::type
std::string type
Definition: MonitorXMLParser.h:37
DB_ME::zbins
int zbins
Definition: MonitorXMLParser.h:41
TagNames::TAG_QUERY
XMLCh * TAG_QUERY
Definition: MonitorXMLParser.h:57
TagNames::ATTR_YTO
XMLCh * ATTR_YTO
Definition: MonitorXMLParser.h:65
TagNames::ATTR_ZBINS
XMLCh * ATTR_ZBINS
Definition: MonitorXMLParser.h:66
TagNames::ATTR_XBINS
XMLCh * ATTR_XBINS
Definition: MonitorXMLParser.h:60
fetchall_from_DQM_v2.release
tuple release
Definition: fetchall_from_DQM_v2.py:110
TagNames::ATTR_ARG
XMLCh * ATTR_ARG
Definition: MonitorXMLParser.h:72
DbQuery::alias
std::string alias
Definition: MonitorXMLParser.h:35
TagNames::TAG_2D
XMLCh * TAG_2D
Definition: MonitorXMLParser.h:54
DB_ME::xto
double xto
Definition: MonitorXMLParser.h:39
DB_ME::ncycle
unsigned int ncycle
Definition: MonitorXMLParser.h:42
DB_ME::yfrom
double yfrom
Definition: MonitorXMLParser.h:40
TagNames::ATTR_YFROM
XMLCh * ATTR_YFROM
Definition: MonitorXMLParser.h:64
DB_ME::yto
double yto
Definition: MonitorXMLParser.h:40
DB_ME::queries
std::vector< DbQuery > queries
Definition: MonitorXMLParser.h:44
DB_ME::ybins
int ybins
Definition: MonitorXMLParser.h:40
MonitorXMLParser::DBMonitoringElements_
std::vector< DB_ME > DBMonitoringElements_
Definition: MonitorXMLParser.h:166
TagNames::ATTR_ZTO
XMLCh * ATTR_ZTO
Definition: MonitorXMLParser.h:68
DB_ME
Definition: MonitorXMLParser.h:37
TagNames::TAG_1D
XMLCh * TAG_1D
Definition: MonitorXMLParser.h:53
TagNames::ATTR_YBINS
XMLCh * ATTR_YBINS
Definition: MonitorXMLParser.h:63
DB_ME::xbins
int xbins
Definition: MonitorXMLParser.h:39
DB_ME::zfrom
double zfrom
Definition: MonitorXMLParser.h:41
TagNames::ATTR_NAME
XMLCh * ATTR_NAME
Definition: MonitorXMLParser.h:71
DB_ME::title
std::string title
Definition: MonitorXMLParser.h:38
TagNames::ATTR_XTO
XMLCh * ATTR_XTO
Definition: MonitorXMLParser.h:62
DB_ME::loop
unsigned int loop
Definition: MonitorXMLParser.h:43
TagNames::TAG_TPROFILE2D
XMLCh * TAG_TPROFILE2D
Definition: MonitorXMLParser.h:56
TagNames::ATTR_ALIAS
XMLCh * ATTR_ALIAS
Definition: MonitorXMLParser.h:73
DbQuery::arg
std::string arg
Definition: MonitorXMLParser.h:34
TagNames::ATTR_NCYCLE
XMLCh * ATTR_NCYCLE
Definition: MonitorXMLParser.h:69
DB_ME::zto
double zto
Definition: MonitorXMLParser.h:41
TagNames::ATTR_TITLE
XMLCh * ATTR_TITLE
Definition: MonitorXMLParser.h:59
TagNames::ATTR_LOOP
XMLCh * ATTR_LOOP
Definition: MonitorXMLParser.h:70
DbQuery::query
std::string query
Definition: MonitorXMLParser.h:33
TagNames::ATTR_XFROM
XMLCh * ATTR_XFROM
Definition: MonitorXMLParser.h:61
TagNames::TAG_TPROFILE
XMLCh * TAG_TPROFILE
Definition: MonitorXMLParser.h:55
DB_ME::xfrom
double xfrom
Definition: MonitorXMLParser.h:39
TagNames::ATTR_ZFROM
XMLCh * ATTR_ZFROM
Definition: MonitorXMLParser.h:67
void MonitorXMLParser::load ( )
throw (std::runtime_error
)

Definition at line 397 of file MonitorXMLParser.cc.

References alignCSCRings::e, handleElement(), python.rootplot.argparse::message, NULL, parser_, fetchall_from_DQM_v2::release, TagNames::TAG_DBE, tags_, and xmlFile_.

Referenced by MonitorElementsDb::MonitorElementsDb().

397  {
398 
399  parser_->setValidationScheme( xercesc::XercesDOMParser::Val_Never );
400  parser_->setDoNamespaces( false );
401  parser_->setDoSchema( false );
402  parser_->setLoadExternalDTD( false );
403 
404  try{
405 
406  parser_->parse( xmlFile_.c_str() );
407 
408  xercesc::DOMDocument* xmlDoc = parser_->getDocument();
409 
410  xercesc::DOMElement* dbe = xmlDoc->getDocumentElement();
411 
412  if( NULL == dbe ){
413  throw( std::runtime_error( "empty XML document" ) ) ;
414  }
415 
416  if( xercesc::XMLString::equals( tags_->TAG_DBE, dbe->getTagName() ) ) {
417 
418  xercesc::DOMNodeList* children = dbe->getChildNodes();
419  const XMLSize_t nodeCount = children->getLength();
420 
421  for( XMLSize_t ix = 0 ; ix < nodeCount ; ++ix ){
422  xercesc::DOMNode* currentNode = children->item( ix );
423  if( NULL == currentNode ){
424  // null node...
425  continue;
426  }
427 
428  if( xercesc::DOMNode::ELEMENT_NODE != currentNode->getNodeType() ){
429  continue;
430  }
431 
432  xercesc::DOMElement* currentElement = dynamic_cast< xercesc::DOMElement* >( currentNode );
433 
434  handleElement( currentElement );
435 
436  }
437  }
438 
439  }catch( xercesc::XMLException& e ){
440 
441  char* message = xercesc::XMLString::transcode( e.getMessage() );
442 
443  std::ostringstream buf ;
444  buf << "Error parsing file: " << message << std::endl;
445 
446  xercesc::XMLString::release( &message );
447 
448  throw( std::runtime_error( buf.str() ) );
449 
450  }catch( const xercesc::DOMException& e ){
451 
452  char* message = xercesc::XMLString::transcode( e.getMessage() );
453 
454  std::ostringstream buf;
455  buf << "Encountered DOM Exception: " << message << std::endl;
456 
457  xercesc::XMLString::release( &message );
458 
459  throw( std::runtime_error( buf.str() ) );
460 
461  }
462 
463  return;
464 
465 } // load()
MonitorXMLParser::xmlFile_
std::string xmlFile_
Definition: MonitorXMLParser.h:167
fetchall_from_DQM_v2.release
tuple release
Definition: fetchall_from_DQM_v2.py:110
NULL
#define NULL
Definition: scimark2.h:8
MonitorXMLParser::handleElement
void handleElement(xercesc::DOMElement *element)
Definition: MonitorXMLParser.cc:66
MonitorXMLParser::parser_
xercesc::XercesDOMParser * parser_
Definition: MonitorXMLParser.h:168
TagNames::TAG_DBE
XMLCh * TAG_DBE
Definition: MonitorXMLParser.h:51

Member Data Documentation

std::vector< DB_ME > MonitorXMLParser::DBMonitoringElements_
private

Definition at line 166 of file MonitorXMLParser.h.

Referenced by getDB_ME(), and handleElement().

xercesc::XercesDOMParser* MonitorXMLParser::parser_
private

Definition at line 168 of file MonitorXMLParser.h.

Referenced by load(), MonitorXMLParser(), and ~MonitorXMLParser().

TagNames* MonitorXMLParser::tags_
private

Definition at line 169 of file MonitorXMLParser.h.

Referenced by handleElement(), load(), MonitorXMLParser(), and ~MonitorXMLParser().

std::string MonitorXMLParser::xmlFile_
private

Definition at line 167 of file MonitorXMLParser.h.

Referenced by load(), and MonitorXMLParser().

Generated for CMSSW Reference Manual by doxygen 1.8.5