| The Gaudi Framework v27r1

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

XMLFileCatalog.cpp
Go to the documentation of this file.
1 #include "xercesc/framework/LocalFileFormatTarget.hpp"
2 #include "xercesc/framework/MemBufInputSource.hpp"
3 #include "xercesc/sax/SAXParseException.hpp"
4 #include "xercesc/sax/EntityResolver.hpp"
5 #include "xercesc/sax/InputSource.hpp"
6 #include "xercesc/parsers/XercesDOMParser.hpp"
7 #include "xercesc/util/PlatformUtils.hpp"
8 #include "xercesc/util/XercesDefs.hpp"
9 #include "xercesc/util/XMLUni.hpp"
10 #include "xercesc/util/XMLURL.hpp"
11 #include "xercesc/util/XMLString.hpp"
12 #include "xercesc/dom/DOM.hpp"
13
14 #include "GaudiKernel/MsgStream.h"
15 #include "GaudiKernel/Service.h"
16 #include <Gaudi/PluginService.h>
17
18 #include "XMLFileCatalog.h"
19
20 #include <fstream>
21 #include <iostream>
22 #include <stdexcept>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include "uuid/uuid.h"
26
27 #include <boost/format.hpp>
28
29 using namespace xercesc;
30 using namespace Gaudi;
31 using namespace std;
32
33 #if _XERCES_VERSION <= 30000
34 // API change between XercesC 2 and 3
35 #define setIdAttribute(a, b) setIdAttribute(a)
36 #endif
37
38
39 DECLARE_FACTORY(XMLFileCatalog, IFileCatalog::Factory)
40
41 namespace {
42
43 typedef const string& CSTR;
44 inline string _toString(const XMLCh *toTranscode) {
45 char * buff = XMLString::transcode(toTranscode);
46 string tmp(buff==0 ? "" : buff);
47 XMLString::release(&buff);
48 return tmp;
49 }
50 struct __Init {
51 __Init() {
52 try { XMLPlatformUtils::Initialize(); }
53 catch (const XMLException& e) {
54 cout << "Xerces-c error in initialization:" << _toString(e.getMessage()) << endl;
55 }
56 }
57 ~__Init() {
58 XMLPlatformUtils::Terminate();
59 }
60 };
61 __Init __In__;
62
63 struct XMLStr {
64 XMLCh* m_xml;
65 XMLStr(CSTR c) { m_xml=XMLString::transcode(c.c_str()); }
66 ~XMLStr() { if (m_xml) XMLString::release(&m_xml); }
67 operator const XMLCh*() const { return m_xml; }
68 };
69 struct XMLTag : public XMLStr {
70 string m_str;
71 XMLTag(CSTR s) : XMLStr(s), m_str(s) { }
72 ~XMLTag() { }
73 operator CSTR () const { return m_str; }
74 };
75 // bool operator==(const XMLTag& b, CSTR c) { return c==b.m_str; }
76 bool operator==(CSTR c, const XMLTag& b) { return c==b.m_str; }
77 struct XMLCollection {
78 DOMElement* m_node;
79 XMLCollection(DOMNode* n, bool use_children=true) : m_node((DOMElement*)n) {
80 if ( use_children ) {
81 if ( m_node ) m_node = (DOMElement*)m_node->getFirstChild();
82 if ( m_node && m_node->getNodeType() != DOMNode::ELEMENT_NODE ) ++(*this);
83 }
84 }
85 operator bool() const { return m_node; }
86 operator DOMNode* () const { return m_node; }
87 operator DOMElement* () const { return m_node; }
88 DOMElement* operator->() const { return m_node; }
89 string attr(const XMLTag& tag) const { return _toString(m_node->getAttribute(tag));}
90 string attr(CSTR tag) const { return attr(XMLTag(tag)); }
91 string tag() const { return _toString(m_node->getTagName()); }
92 void operator++() {
93 while(m_node) {
94 m_node = (DOMElement*)m_node->getNextSibling();
95 if ( m_node && m_node->getNodeType() == DOMNode::ELEMENT_NODE ) {
96 return;
97 }
98 }
99 }
100 };
101 struct ErrHandler : public ErrorHandler {
103 IMessageSvc* m_msg;
105 ErrHandler(IMessageSvc* m) : m_msg(m) {}
107 void resetErrors() { }
109 void warning(const SAXParseException& /* e */) { }
111 void error(const SAXParseException& e);
113 void fatalError(const SAXParseException& e);
114 virtual ~ErrHandler() {}
115 };
116 struct DTDRedirect : public EntityResolver {
117 InputSource* resolveEntity(const XMLCh* const /* pubId */, const XMLCh* const /* sysId */) {
118 static const char* dtdID = "redirectinmem.dtd";
119 static const char* dtd = \
120 "\
121 <!ELEMENT POOLFILECATALOG (META*,File*)>\
122 <!ELEMENT META EMPTY>\
123 <!ELEMENT File (physical,logical,metadata*)>\
124 <!ATTLIST META name CDATA #REQUIRED>\
125 <!ATTLIST META type CDATA #REQUIRED>\
126 <!ELEMENT physical (pfn)+>\
127 <!ELEMENT logical (lfn)*>\
128 <!ELEMENT metadata EMPTY>\
129 <!ELEMENT lfn EMPTY>\
130 <!ELEMENT pfn EMPTY>\
131 <!ATTLIST File ID ID #REQUIRED>\
132 <!ATTLIST pfn name ID #REQUIRED>\
133 <!ATTLIST pfn filetype CDATA #IMPLIED>\
134 <!ATTLIST pfn se CDATA #IMPLIED>\
135 <!ATTLIST lfn name ID #REQUIRED>\
136 <!ATTLIST metadata att_name CDATA #REQUIRED>\
137 <!ATTLIST metadata att_value CDATA #REQUIRED>\
138 ";
139 static const size_t len = strlen(dtd);
140 return new MemBufInputSource((const XMLByte*)dtd,len,dtdID,false);
141 }
142 virtual ~DTDRedirect() = default;
143 };
144
145 void ErrHandler::error(const SAXParseException& e) {
146 string m(_toString(e.getMessage()));
147 if (m.find("The values for attribute 'name' must be names or name tokens")!=string::npos ||
148 m.find("The values for attribute 'ID' must be names or name tokens")!=string::npos ||
149 m.find("for attribute 'name' must be Name or Nmtoken")!=string::npos ||
150 m.find("for attribute 'ID' must be Name or Nmtoken")!=string::npos ||
151 m.find("for attribute 'name' is invalid Name or NMTOKEN value")!=string::npos ||
152 m.find("for attribute 'ID' is invalid Name or NMTOKEN value")!=string::npos )
153 return;
154 string sys(_toString(e.getSystemId()));
155 MsgStream log(m_msg,"XMLCatalog");
156 log << MSG::ERROR << "Error at file \"" << sys
157 << "\", line " << e.getLineNumber() << ", column " << e.getColumnNumber() << endmsg
158 << "Message: " << m << endmsg;
159 }
160 void ErrHandler::fatalError(const SAXParseException& e) {
161 MsgStream log(m_msg,"XMLCatalog");
162 string m(_toString(e.getMessage()));
163 string sys(_toString(e.getSystemId()));
164 log << MSG::ERROR << "Fatal Error at file \"" << sys
165 << "\", line " << e.getLineNumber() << ", column " << e.getColumnNumber() << endmsg
166 << "Message: " << m << endmsg;
167 throw runtime_error( "Standard pool exception : Fatal Error on the DOM Parser" );
168 }
169
170 const XMLTag EmptyCatalog("<!-- Edited By POOL -->\n"
171 "<!DOCTYPE POOLFILECATALOG SYSTEM \"InMemory\">\n"
172 "<POOLFILECATALOG>\n"
173 "</POOLFILECATALOG>\n");
174 const XMLTag PFNCOLL ("physical");
175 const XMLTag LFNCOLL ("logical");
176 const XMLTag PFNNODE ( "pfn");
177 const XMLTag LFNNODE ( "lfn");
178 const XMLTag Attr_type ( "type");
179 const XMLTag Attr_ID ( "ID");
180 const XMLTag Attr_name ( "name");
181 const XMLTag Attr_ftype ( "filetype");
182 const XMLTag MetaNode ( "metadata");
183 const XMLTag Attr_metaName ( "att_name");
184 const XMLTag Attr_metaValue ( "att_value");
185 }
186
188 std::string Gaudi::createGuidAsString() {
189 uuid_t uuid;
190 ::uuid_generate_time(uuid);
191 struct Guid {
192 unsigned int Data1;
193 unsigned short Data2;
194 unsigned short Data3;
195 unsigned char Data4[8];
196 } *g = (Guid*)&uuid;
197
198 boost::format text("%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X");
199 text % g->Data1 % g->Data2 % g->Data3;
200 for (int i = 0; i < 8; ++i)
201 text % (unsigned short)g->Data4[i];
202 return text.str();
203 }
204 // ----------------------------------------------------------------------------
205 XMLFileCatalog::XMLFileCatalog(CSTR uri, IMessageSvc* m)
206 : m_rdOnly(false),m_update(false),m_doc(0),
207 m_file(uri), m_msgSvc(m)
208 {
209 }
210 // ----------------------------------------------------------------------------
212 std::string XMLFileCatalog::createFID() const {
213 return createGuidAsString();
214 }
215 // ----------------------------------------------------------------------------
216 DOMDocument* XMLFileCatalog::getDoc(bool throw_if_no_exists) const {
217 if ( !m_doc && throw_if_no_exists )
218 printError("The XML catalog was not started.",true);
219 return m_doc;
220 }
221 // ----------------------------------------------------------------------------
222 void XMLFileCatalog::printError(CSTR msg, bool rethrow) const {
223 MsgStream log(m_msgSvc,"XMLCatalog");
224 log << MSG::FATAL << msg << endmsg;
225 if ( rethrow ) {
226 throw runtime_error("XMLFileCatalog> "+msg);
227 }
228 }
229 // ----------------------------------------------------------------------------
230 void XMLFileCatalog::init() {
231 string xmlFile = getfile(false);
232 try{
233 m_parser.reset( new XercesDOMParser );
234 m_parser->setValidationScheme(XercesDOMParser::Val_Auto);
235 m_parser->setDoNamespaces(false);
236 DTDRedirect dtdinmem;
237 m_parser->setEntityResolver(&dtdinmem);
238 if ( ! m_errHdlr ) m_errHdlr.reset( new ErrHandler(m_msgSvc) );
239 m_parser->setErrorHandler(m_errHdlr.get());
240 if ( !xmlFile.empty() ) {
241 m_parser->parse(xmlFile.c_str());
242 }
243 else {
244 const std::string& s = EmptyCatalog;
245 MemBufInputSource src((const XMLByte*)s.c_str(),s.length(),"MemCatalog");
246 m_parser->parse(src);
247 }
248 m_doc = m_parser->getDocument();
249 }
250 catch (const XMLException& e) {
251 printError("XML parse error["+xmlFile+"]: "+_toString(e.getMessage()));
252 }
253 catch (const DOMException& e) {
254 printError("XML parse error["+xmlFile+"]: "+_toString(e.getMessage()));
255 }
256 catch (...) {
257 printError("UNKNOWN XML parse error in file "+xmlFile);
258 }
259 }
260 // ----------------------------------------------------------------------------
261 string XMLFileCatalog::lookupFID(const std::string& fid) const {
262 std::string result;
263 DOMNode* e = element(fid,false);
264 e = e ? e->getParentNode() : 0; // Mode up to <logical>
265 e = e ? e->getParentNode() : 0; // Mode up to <File>
266 if ( e ) {
267 if ( e->getAttributes() ) { // Need to check this. The node may be no DOMElement
268 char* nam = XMLString::transcode(((DOMElement*)e)->getAttribute(Attr_ID));
269 if ( nam ) result = nam;
270 XMLString::release(&nam);
271 }
272 }
273 return result;
274 }
275 // ----------------------------------------------------------------------------
276 void XMLFileCatalog::getFID(Strings& fids) const {
277 fids.clear();
278 DOMNode* fde = getDoc(true)->getElementsByTagName(XMLStr("*"))->item(0);
279 for(XMLCollection c(child(fde,"File"), false); c; ++c)
280 fids.push_back(c.attr(Attr_ID));
281 }
282 // ----------------------------------------------------------------------------
283 void XMLFileCatalog::getPFN(CSTR fid, Files& files) const {
284 files.clear();
285 for(XMLCollection c(child(child(element(fid,false),PFNCOLL),PFNNODE), false); c; ++c)
286 files.emplace_back(c.attr(Attr_name),c.attr(Attr_ftype));
287 }
288 // ----------------------------------------------------------------------------
289 void XMLFileCatalog::getLFN(CSTR fid, Files& files) const {
290 files.clear();
291 for(XMLCollection c(child(child(element(fid,false),LFNCOLL),LFNNODE), false); c; ++c)
292 files.emplace_back(c.attr(Attr_name),fid);
293 }
294 // ----------------------------------------------------------------------------
295 void XMLFileCatalog::getMetaData(CSTR fid, Attributes& attr) const {
296 attr.clear();
297 for(XMLCollection c(child(element(fid),MetaNode), false); c; ++c)
298 attr.emplace_back(c.attr(Attr_metaName),c.attr(Attr_metaValue));
299 if ( attr.size() > 0 )
300 attr.emplace_back("guid",fid);
301 }
302 // ----------------------------------------------------------------------------
303 DOMNode* XMLFileCatalog::child(DOMNode* par,CSTR tag,CSTR attr,CSTR val) const {
304 for(XMLCollection c(par); c; ++c ) {
305 if( c.tag() == tag ) {
306 if( !attr.empty() && c.attr(attr) != val) continue;
307 return c;
308 }
309 }
310 return 0;
311 }
312 // ----------------------------------------------------------------------------
313 void XMLFileCatalog::setMetaData(CSTR fid, CSTR attr, CSTR val) const {
314 if ( !readOnly() ) {
315 DOMNode* node = element(fid);
316 DOMElement* mnod = (DOMElement*)child(node,MetaNode,Attr_metaName,attr);
317 if (!mnod){
318 mnod = getDoc(true)->createElement(MetaNode);
319 node->appendChild(mnod);
320 mnod->setAttribute(Attr_metaName,XMLStr(attr));
321 }
322 mnod->setAttribute(Attr_metaValue,XMLStr(val));
323 m_update = true;
324 return;
325 }
326 printError("Cannot update readonly catalog!");
327 }
328 // ----------------------------------------------------------------------------
329 string XMLFileCatalog::getMetaDataItem(CSTR fid,CSTR attr) const {
330 XMLCollection c(child(getDoc(true)->getElementById(XMLStr(fid)),MetaNode,Attr_metaName,attr));
331 return c ? c.attr(attr) : string("");
332 }
333 // ----------------------------------------------------------------------------
334 void XMLFileCatalog::dropMetaData(CSTR fid,CSTR attr) const {
335 vector<DOMNode*> gbc;
336 DOMNode* fn = getDoc(true)->getElementById(XMLStr(fid));
337 for(XMLCollection c{child(fn,MetaNode)}; c; ++c)
338 if ( attr[0]=='*' || !c.attr(attr).empty() ) gbc.push_back(c);
339 for(const auto &i : gbc)
340 fn->removeChild(i);
341 }
342 // ----------------------------------------------------------------------------
343 DOMNode* XMLFileCatalog::element(CSTR element_name,bool print_err) const {
344 DOMNode* node = getDoc(true)->getElementById(XMLStr(element_name));
345 if ( !node && print_err ) printError("Cannot find element:"+element_name);
346 return node;
347 }
348 // ----------------------------------------------------------------------------
349 void XMLFileCatalog::deleteFID(CSTR fid) const {
350 DOMNode *pn = nullptr, *fn = element(fid);
351 if ( fn ) pn = fn->getParentNode();
352 if ( pn ) pn->removeChild(fn);
353 }
354 // ----------------------------------------------------------------------------
355 void XMLFileCatalog::registerFID(CSTR fid) const {
356 if ( !fid.empty() ) {
357 std::pair<DOMElement*, DOMElement*> res = i_registerFID(fid);
358 if ( res.first == 0 || res.second == 0 ) {
359 printError("Failed to register FID:"+fid);
360 }
361 return;
362 }
363 throw runtime_error("XMLFileCatalog> Cannot register LFN for invalid FID:"+fid);
364 }
365 // ----------------------------------------------------------------------------
366 std::pair<DOMElement*,DOMElement*> XMLFileCatalog::i_registerFID(CSTR fid) const {
367 if ( readOnly() ) {
368 printError("Cannot update readonly catalog!");
369 return { nullptr, nullptr};
370 }
371
373 DOMElement *file = (DOMElement*)element(fid,false), *phyelem = 0, *logelem = 0;
374 DOMDocument* doc = getDoc(true);
375 if ( !file ) {
376 DOMNode* fde = doc->getElementsByTagName(XMLStr("*"))->item(0);
377 file = m_doc->createElement(XMLStr("File"));
378 file->setAttribute(Attr_ID, XMLStr(fid));
379 file->setIdAttribute(Attr_ID, true);
380 fde->appendChild(file);
381 m_update = true;
382 }
383 for(XMLCollection c1(file); c1; ++c1 ) {
384 char* nam = XMLString::transcode(c1->getNodeName());
385 if ( nam == PFNCOLL ) phyelem = c1;
386 if ( nam == LFNCOLL ) logelem = c1;
387 XMLString::release(&nam);
388 }
389 if ( !phyelem ) {
390 phyelem = doc->createElement(PFNCOLL);
391 file->appendChild(phyelem);
392 m_update = true;
393 }
394 if ( !logelem ) {
395 logelem = doc->createElement(LFNCOLL);
396 file->appendChild(logelem);
397 m_update = true;
398 }
399 return {logelem,phyelem};
400 }
401 // ----------------------------------------------------------------------------
402 void XMLFileCatalog::registerPFN(CSTR fid, CSTR pfn, CSTR ftype) const {
403 if ( !fid.empty() ) {
404 std::pair<DOMElement*,DOMElement*> res = i_registerFID(fid);
405 DOMElement* phyelem = res.second, *fnelem = 0;
406 for(XMLCollection c(phyelem); c; ++c ) {
407 char* nam = XMLString::transcode(c->getNodeName());
408 if ( nam == PFNNODE ) {
409 XMLString::release(&nam);
410 nam = XMLString::transcode(c->getAttribute(Attr_name));
411 if ( nam == pfn ) {
412 XMLString::release(&nam);
413 fnelem = c;
414 break;
415 }
416 }
417 XMLString::release(&nam);
418 }
419 if ( !fnelem ) {
420 fnelem = getDoc(true)->createElement(PFNNODE);
421 phyelem->appendChild(fnelem);
422 fnelem->setAttribute(Attr_ftype,XMLStr(ftype));
423 fnelem->setAttribute(Attr_name,XMLStr(pfn));
424 fnelem->setIdAttribute(Attr_name, true);
425 m_update = true;
426 }
427 return;
428 }
429 throw runtime_error("XMLFileCatalog> Cannot register PFN for invalid FID:"+fid);
430 }
431 // ----------------------------------------------------------------------------
432 void XMLFileCatalog::registerLFN(CSTR fid, CSTR lfn) const {
433 if ( !fid.empty() ) {
434 std::pair<DOMElement*, DOMElement*> res = i_registerFID(fid);
435 DOMElement* logelem = res.first, *fnelem = 0;
436 for(XMLCollection c(logelem); c; ++c ) {
437 char* nam = XMLString::transcode(c->getNodeName());
438 if ( nam == LFNNODE ) {
439 XMLString::release(&nam);
440 nam = XMLString::transcode(c->getAttribute(Attr_name));
441 if ( nam == lfn ) {
442 XMLString::release(&nam);
443 fnelem = c;
444 break;
445 }
446 }
447 }
448 if ( !fnelem ) {
449 fnelem = getDoc(true)->createElement(LFNNODE);
450 logelem->appendChild(fnelem);
451 fnelem->setAttribute(Attr_name,XMLStr(lfn));
452 fnelem->setIdAttribute(Attr_name, true);
453 m_update = true;
454 }
455 return;
456 }
457 throw runtime_error("XMLFileCatalog> Cannot register LFN for invalid FID:"+fid);
458 }
459 // ----------------------------------------------------------------------------
460 void XMLFileCatalog::commit() {
461 try {
462 if ( dirty() && !readOnly() ) {
463 string xmlfile = getfile(true);
464 XMLStr ii("LS");
465 DOMImplementation *imp = DOMImplementationRegistry::getDOMImplementation(ii);
466 std::unique_ptr<XMLFormatTarget> tar{ new LocalFileFormatTarget(xmlfile.c_str()) };
467 #if _XERCES_VERSION <= 30000
468 DOMWriter *wr = imp->createDOMWriter();
469 wr->setFeature(XMLUni::fgDOMWRTFormatPrettyPrint, true);
470 wr->writeNode(tar.get(), *m_doc);
471 wr->release();
472 #else
473 DOMLSOutput *output = imp->createLSOutput();
474 output->setByteStream(tar.get());
475 DOMLSSerializer *wr = imp->createLSSerializer();
476 wr->getDomConfig()->setParameter(XMLStr("format-pretty-print"), true);
477 wr->write(m_doc, output);
478 output->release();
479 wr->release();
480 #endif
481 }
482 }
483 catch ( exception& e ) {
484 printError(string("Cannot open output file:")+e.what());
485 }
486 catch (...) {
487 printError("Unknown IO rrror.");
488 }
489 }
490 // ----------------------------------------------------------------------------
491 string XMLFileCatalog::getfile(bool create) {
492 string protocol, path;
493 XMLURL xerurl;
494 try{
495 xerurl = (const XMLCh*)XMLStr(m_file);
496 protocol = _toString(xerurl.getProtocolName());
497 path = _toString(xerurl.getPath());
498 }
499 catch (const XMLException& e ) {
500 printError(_toString(e.getMessage()));
501 }
502 if ( protocol.empty() ) {
503 printError("Missing protocol.");
504 }
505 else if ( protocol == "http" || protocol == "ftp" ) {
506 m_rdOnly = true;
507 }
508 else if ( protocol == "file" ) {
509 m_rdOnly = false;
510 struct stat buff;
511 int exist = ::stat(path.c_str(),&buff) != -1;
512 if ( create && !exist ) {
513 MsgStream log(m_msgSvc,"XMLCatalog");
514 log << MSG::INFO << "File '" << path << "' does not exist. New file created." << endmsg;
515 ofstream out{path};
516 if( !m_rdOnly && out.is_open() ) {
517 out << (CSTR)EmptyCatalog << endl;
518 }
519 else {
520 printError("Problem creating file "+path);
521 }
522 out.close();
523 }
524 else if ( exist ) {
525 return path;
526 }
527 else if ( !create ) {
528 return "";
529 }
530 }
531 else {
532 printError(protocol + ": protocol not supported.");
533 }
534 return path;
535 }
Gaudi::XMLFileCatalog::m_file
std::string m_file
Definition: XMLFileCatalog.h:97
MsgStream
Definition of the MsgStream class used to transmit messages.
Definition: MsgStream.h:24
std::string::empty
T empty(T...args)
xercesc
format
GAUDI_API std::string format(const char *,...)
MsgStream format utility "a la sprintf(...)".
Definition: MsgStream.cpp:119
GaudiMP.FdsRegistry.msg
tuple msg
Definition: FdsRegistry.py:8
MsgStream.h
Gaudi::XMLFileCatalog::readOnly
virtual bool readOnly() const
Check if the catalog is read-only.
Definition: XMLFileCatalog.h:47
Gaudi.Configuration.log
tuple log
Definition: Configuration.py:13
DECLARE_FACTORY
#define DECLARE_FACTORY(type, factory)
Definition: PluginService.h:25
gaudirun.c
tuple c
Definition: gaudirun.py:391
std::endl
T endl(T...args)
Gaudi::XMLFileCatalog::lookupFID
std::string lookupFID(CSTR lfn) const
Definition: XMLFileCatalog.cpp:261
Gaudi::IFileCatalog::Factory
Gaudi::PluginService::Factory< IInterface *, const std::string &, IMessageSvc * > Factory
Definition: IFileCatalog.h:33
std
STL namespace.
Gaudi::XMLFileCatalog::getfile
std::string getfile(bool create)
Definition: XMLFileCatalog.cpp:491
Gaudi::XMLFileCatalog::getMetaDataItem
virtual std::string getMetaDataItem(CSTR fid, CSTR name) const
Access metadata item.
Definition: XMLFileCatalog.cpp:329
Gaudi::XMLFileCatalog::dropMetaData
virtual void dropMetaData(CSTR fid) const
Drop all metadata of one FID.
Definition: XMLFileCatalog.h:81
Gaudi::XMLFileCatalog::element
xercesc::DOMNode * element(CSTR fid, bool print_err=true) const
Definition: XMLFileCatalog.cpp:343
Gaudi::XMLFileCatalog::setMetaData
virtual void setMetaData(CSTR fid, CSTR name, CSTR value) const
Insert/update metadata item.
Definition: XMLFileCatalog.cpp:313
Gaudi::XMLFileCatalog::m_parser
std::unique_ptr< xercesc::XercesDOMParser > m_parser
Definition: XMLFileCatalog.h:95
GaudiPluginService.cpluginsvc.n
list n
Definition: cpluginsvc.py:217
Gaudi::XMLFileCatalog::registerPFN
virtual void registerPFN(CSTR fid, CSTR pfn, CSTR ftype) const
Create a FileID and Node of the physical file name with all the attributes.
Definition: XMLFileCatalog.cpp:402
std::unique_ptr::release
T release(T...args)
XMLFileCatalog.h
std::string
STL class.
Service.h
MSG::FATAL
Definition: IMessageSvc.h:22
std::vector::push_back
T push_back(T...args)
std::ofstream
STL class.
Gaudi::XMLFileCatalog::CSTR
const std::string & CSTR
Definition: XMLFileCatalog.h:27
Gaudi::XMLFileCatalog::init
virtual void init()
Parse the DOM tree of the XML catalog.
Definition: XMLFileCatalog.cpp:230
compareOutputFiles.par
string par
Definition: compareOutputFiles.py:386
Gaudi::XMLFileCatalog::dirty
virtual bool dirty() const
Check if the catalog should be updated.
Definition: XMLFileCatalog.h:49
std::exception::what
T what(T...args)
std::strlen
T strlen(T...args)
Gaudi::XMLFileCatalog::child
xercesc::DOMNode * child(xercesc::DOMNode *par, CSTR tag, CSTR attr="", CSTR val="") const
Definition: XMLFileCatalog.cpp:303
operator==
bool operator==(const GaudiUtils::Allocator< T1 > &, const GaudiUtils::Allocator< T2 > &)
Definition: Allocator.h:249
Gaudi::Units::m
constexpr double m
Definition: SystemOfUnits.h:93
Gaudi::XMLFileCatalog::printError
void printError(CSTR msg, bool throw_exc=true) const
Definition: XMLFileCatalog.cpp:222
Gaudi::XMLFileCatalog::getFID
virtual void getFID(Strings &fids) const
Dump all file Identifiers.
Definition: XMLFileCatalog.cpp:276
std::runtime_error
STL class.
Gaudi::XMLFileCatalog::m_errHdlr
std::unique_ptr< xercesc::ErrorHandler > m_errHdlr
Definition: XMLFileCatalog.h:96
IMessageSvc
The IMessage is the interface implemented by the message service.
Definition: IMessageSvc.h:57
Gaudi::XMLFileCatalog::m_doc
xercesc::DOMDocument * m_doc
Definition: XMLFileCatalog.h:94
Gaudi::XMLFileCatalog::getDoc
xercesc::DOMDocument * getDoc(bool throw_if_no_exists=true) const
Definition: XMLFileCatalog.cpp:216
CSTR
const std::string CSTR
Definition: MultiStoreSvc.cpp:40
std::unique_ptr::reset
T reset(T...args)
ana.file
list file
Definition: ana.py:160
Gaudi::XMLFileCatalog::getLFN
virtual void getLFN(CSTR fid, Files &files) const
Dump all logical file names of the catalog associate to the FileID.
Definition: XMLFileCatalog.cpp:289
Gaudi::XMLFileCatalog::deleteFID
virtual void deleteFID(CSTR FileID) const
Delete FileID Node from the catalog.
Definition: XMLFileCatalog.cpp:349
std::exception
STL class.
Gaudi::Utils::Histos::path
GAUDI_API std::string path(const AIDA::IBaseHistogram *aida)
get the path in THS for AIDA histogram
Definition: HistoTableFormat.cpp:191
Gaudi::XMLFileCatalog::m_rdOnly
bool m_rdOnly
Definition: XMLFileCatalog.h:92
std::pair
std::unique_ptr::get
T get(T...args)
PluginService.h
HiveAlgSequencer.c1
tuple c1
Definition: HiveAlgSequencer.py:25
std::string::find
T find(T...args)
std::string::length
T length(T...args)
std::vector
STL class.
std::unique_ptr
STL class.
Gaudi::createGuidAsString
std::string createGuidAsString()
Create file identifier using UUID mechanism.
Definition: XMLFileCatalog.cpp:188
Gaudi::XMLFileCatalog::commit
virtual void commit()
Save DOM catalog to file.
Definition: XMLFileCatalog.cpp:460
std::string::c_str
T c_str(T...args)
Gaudi::XMLFileCatalog::getPFN
virtual void getPFN(CSTR fid, Files &files) const
Dump all physical file names of the catalog and their attributes associate to the FileID...
Definition: XMLFileCatalog.cpp:283
gaudirun.g
dictionary g
Definition: gaudirun.py:420
gaudirun.s
string s
Definition: gaudirun.py:245
Gaudi::XMLFileCatalog::i_registerFID
std::pair< xercesc::DOMElement *, xercesc::DOMElement * > i_registerFID(CSTR fid) const
Definition: XMLFileCatalog.cpp:366
MSG::ERROR
Definition: IMessageSvc.h:21
Gaudi::XMLFileCatalog::m_msgSvc
IMessageSvc * m_msgSvc
Definition: XMLFileCatalog.h:98
Gaudi::XMLFileCatalog::getMetaData
virtual void getMetaData(CSTR fid, Attributes &attr) const
Dump all MetaData of the catalog for a given file ID.
Definition: XMLFileCatalog.cpp:295
Gaudi::XMLFileCatalog::registerFID
virtual void registerFID(CSTR fid) const
Create a FileID and Node.
Definition: XMLFileCatalog.cpp:355
MSG::INFO
Definition: IMessageSvc.h:19
Gaudi::XMLFileCatalog
This class constitutes the core of the XML based FileCatalog API for POOL.
Definition: XMLFileCatalog.h:25
Gaudi::XMLFileCatalog::createFID
virtual std::string createFID() const
Catalog interface.
Definition: XMLFileCatalog.cpp:212
Gaudi::XMLFileCatalog::registerLFN
virtual void registerLFN(CSTR fid, CSTR lfn) const
Create a FileID and Node of the logical file name with all the attributes.
Definition: XMLFileCatalog.cpp:432
ana.i
list i
Definition: ana.py:128
std::cout
Gaudi::XMLFileCatalog::m_update
bool m_update
Definition: XMLFileCatalog.h:93
Gaudi
Helper functions to set/get the application return code.
Definition: __init__.py:1
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:244