1 #include "otsdaq-core/ConfigurationInterface/ConfigurationHandler.h"
2 #include "otsdaq-core/ConfigurationInterface/TimeFormatter.h"
4 #include "otsdaq-core/Macros/CoutMacros.h"
5 #include "otsdaq-core/XmlUtilities/ConvertFromXML.h"
6 #include "otsdaq-core/XmlUtilities/ConvertToXML.h"
7 #include "otsdaq-core/XmlUtilities/DOMTreeErrorReporter.h"
9 #include <xercesc/dom/DOMElement.hpp>
10 #include <xercesc/dom/DOMImplementation.hpp>
11 #include <xercesc/dom/DOMImplementationRegistry.hpp>
12 #include <xercesc/dom/DOMLSOutput.hpp>
13 #include <xercesc/dom/DOMLSSerializer.hpp>
14 #include <xercesc/dom/DOMNodeList.hpp>
15 #include <xercesc/dom/DOMText.hpp>
16 #include <xercesc/parsers/XercesDOMParser.hpp>
17 #include <xercesc/util/XMLUni.hpp>
20 #include <xercesc/framework/LocalFileFormatTarget.hpp>
21 #include <xercesc/util/OutOfMemoryException.hpp>
23 #include <sys/types.h>
31 #include "otsdaq-core/TableCore/TableBase.h"
36 #define __COUT_HDR__ "ConfigHandler"
40 XMLCh* ConfigurationHandler::rootTag_ = 0;
41 XMLCh* ConfigurationHandler::headerTag_ = 0;
42 XMLCh* ConfigurationHandler::typeTag_ = 0;
43 XMLCh* ConfigurationHandler::extensionTableNameTag_ = 0;
44 XMLCh* ConfigurationHandler::nameTag_ = 0;
45 XMLCh* ConfigurationHandler::runTag_ = 0;
46 XMLCh* ConfigurationHandler::runTypeTag_ = 0;
47 XMLCh* ConfigurationHandler::runNumberTag_ = 0;
48 XMLCh* ConfigurationHandler::runBeginTimestampTag_ = 0;
49 XMLCh* ConfigurationHandler::locationTag_ = 0;
50 XMLCh* ConfigurationHandler::datasetTag_ = 0;
51 XMLCh* ConfigurationHandler::versionTag_ = 0;
52 XMLCh* ConfigurationHandler::commentDescriptionTag_ = 0;
53 XMLCh* ConfigurationHandler::createdByUserTag_ = 0;
54 XMLCh* ConfigurationHandler::partTag_ = 0;
55 XMLCh* ConfigurationHandler::nameLabelTag_ = 0;
56 XMLCh* ConfigurationHandler::kindOfPartTag_ = 0;
57 XMLCh* ConfigurationHandler::dataTag_ = 0;
60 ConfigurationHandler::ConfigurationHandler(
void) {}
63 ConfigurationHandler::~ConfigurationHandler(
void) {}
66 void ConfigurationHandler::initPlatform(
void)
70 xercesc::XMLPlatformUtils::Initialize();
72 catch(xercesc::XMLException& e)
74 __MOUT_ERR__ <<
"XML toolkit initialization error: "
75 << XML_TO_CHAR(e.getMessage()) << std::endl;
79 rootTag_ = xercesc::XMLString::transcode(
"ROOT");
80 headerTag_ = xercesc::XMLString::transcode(
"HEADER");
81 typeTag_ = xercesc::XMLString::transcode(
"TYPE");
82 extensionTableNameTag_ = xercesc::XMLString::transcode(
"EXTENSION_TABLE_NAME");
83 nameTag_ = xercesc::XMLString::transcode(
"NAME");
84 runTag_ = xercesc::XMLString::transcode(
"RUN");
85 runTypeTag_ = xercesc::XMLString::transcode(
"RUN_TYPE");
86 runNumberTag_ = xercesc::XMLString::transcode(
"RUN_NUMBER");
87 runBeginTimestampTag_ = xercesc::XMLString::transcode(
"RUN_BEGIN_TIMESTAMP");
88 locationTag_ = xercesc::XMLString::transcode(
"LOCATION");
89 datasetTag_ = xercesc::XMLString::transcode(
"DATA_SET");
90 versionTag_ = xercesc::XMLString::transcode(
"VERSION");
91 commentDescriptionTag_ = xercesc::XMLString::transcode(
"COMMENT_DESCRIPTION");
92 createdByUserTag_ = xercesc::XMLString::transcode(
"CREATED_BY_USER");
93 partTag_ = xercesc::XMLString::transcode(
"PART");
94 nameLabelTag_ = xercesc::XMLString::transcode(
"NAME_LABEL");
95 kindOfPartTag_ = xercesc::XMLString::transcode(
"KIND_OF_PART");
96 dataTag_ = xercesc::XMLString::transcode(
"DATA");
100 void ConfigurationHandler::terminatePlatform(
void)
104 xercesc::XMLString::release(&rootTag_);
105 xercesc::XMLString::release(&headerTag_);
106 xercesc::XMLString::release(&typeTag_);
107 xercesc::XMLString::release(&extensionTableNameTag_);
108 xercesc::XMLString::release(&nameTag_);
109 xercesc::XMLString::release(&runTag_);
110 xercesc::XMLString::release(&runTypeTag_);
111 xercesc::XMLString::release(&runNumberTag_);
112 xercesc::XMLString::release(&runBeginTimestampTag_);
113 xercesc::XMLString::release(&locationTag_);
114 xercesc::XMLString::release(&datasetTag_);
115 xercesc::XMLString::release(&versionTag_);
116 xercesc::XMLString::release(&commentDescriptionTag_);
117 xercesc::XMLString::release(&createdByUserTag_);
118 xercesc::XMLString::release(&partTag_);
119 xercesc::XMLString::release(&nameLabelTag_);
120 xercesc::XMLString::release(&kindOfPartTag_);
121 xercesc::XMLString::release(&dataTag_);
125 __MOUT_ERR__ <<
"Unknown exception encountered in TagNames destructor"
131 xercesc::XMLPlatformUtils::Terminate();
133 catch(xercesc::XMLException& e)
135 __MOUT_ERR__ <<
"XML ttolkit teardown error: " << XML_TO_CHAR(e.getMessage())
141 bool ConfigurationHandler::validateNode(XMLCh* tagName,
142 xercesc::DOMNode* node,
143 const std::string& expectedValue)
145 if(node->getFirstChild() == 0)
147 __COUT__ <<
"Tag " << XML_TO_CHAR(tagName) <<
" doesn't have a value!"
152 if(XML_TO_STRING(node->getFirstChild()->getNodeValue()) != expectedValue)
154 __COUT__ <<
"The tag " << XML_TO_CHAR(tagName) <<
" with value "
155 << XML_TO_CHAR(node->getFirstChild()->getNodeValue())
156 <<
" doesn't match the expected value " << expectedValue << std::endl;
164 xercesc::DOMNode* ConfigurationHandler::getNode(XMLCh* tagName,
165 xercesc::DOMNode* parent,
166 unsigned int itemNumber)
168 return getNode(tagName, dynamic_cast<xercesc::DOMElement*>(parent), itemNumber);
172 xercesc::DOMNode* ConfigurationHandler::getNode(XMLCh* tagName,
173 xercesc::DOMElement* parent,
174 unsigned int itemNumber)
176 xercesc::DOMNodeList* nodeList = parent->getElementsByTagName(tagName);
180 throw(std::runtime_error(std::string(
"Can't find ") + XML_TO_STRING(tagName) +
182 __COUT__ << (std::string(
"Can't find ") + XML_TO_STRING(tagName) +
" tag!")
191 return nodeList->item(itemNumber);
195 xercesc::DOMElement* ConfigurationHandler::getElement(XMLCh* tagName,
196 xercesc::DOMNode* parent,
197 unsigned int itemNumber)
199 return dynamic_cast<xercesc::DOMElement*
>(getNode(tagName, parent, itemNumber));
203 xercesc::DOMElement* ConfigurationHandler::getElement(XMLCh* tagName,
204 xercesc::DOMElement* parent,
205 unsigned int itemNumber)
207 return dynamic_cast<xercesc::DOMElement*
>(getNode(tagName, parent, itemNumber));
213 readXML(*table, version);
220 std::string configFile = getXMLFileName(table, version);
222 __COUT__ <<
"Reading: " << configFile << std::endl;
223 __COUT__ <<
"Into View with Table Name: " << table.getViewP()->getTableName()
225 __COUT__ <<
"Into View with version: " << table.getViewP()->getVersion()
226 <<
" and version-to-read: " << version << std::endl;
228 struct stat fileStatus;
230 if(stat(configFile.c_str(), &fileStatus) < 0)
232 __COUT__ <<
"Error reading path: " << configFile << std::endl;
233 std::stringstream ss;
236 ss << (
"Path file_name does not exist.");
237 else if(errno == ENOTDIR)
238 ss << (
"A component of the path is not a directory.");
239 else if(errno == ELOOP)
240 ss << (
"Too many symbolic links encountered while traversing the path.");
241 else if(errno == EACCES)
242 ss << (
"Permission denied.");
243 else if(errno == ENAMETOOLONG)
244 ss << (
"File name too long.");
246 ss << (
"File can not be read.");
248 __COUT_ERR__ << ss.str();
252 xercesc::XercesDOMParser* parser =
new xercesc::XercesDOMParser;
255 parser->setValidationScheme(xercesc::XercesDOMParser::Val_Auto);
256 parser->setDoNamespaces(
true);
261 parser->useCachedGrammarInParse(
false);
263 parser->setErrorHandler(errorHandler);
269 parser->parse(configFile.c_str());
273 xercesc::DOMDocument* document = parser->getDocument();
276 xercesc::DOMElement* elementRoot = document->getDocumentElement();
279 throw(std::runtime_error(
"empty XML document"));
282 xercesc::DOMNode* headerNode = getNode(headerTag_, elementRoot, 0);
284 throw(std::runtime_error(
285 std::string(
"The document is missing the mandatory tag: ") +
286 XML_TO_STRING(headerTag_)));
290 xercesc::DOMElement* typeElement = getElement(typeTag_, headerNode, 0);
292 throw(std::runtime_error(
293 std::string(
"The document is missing the mandatory tag: ") +
294 XML_TO_STRING(typeTag_)));
295 xercesc::DOMNode* extensionTableNameNode =
296 getNode(extensionTableNameTag_, typeElement, 0);
297 if(!validateNode(extensionTableNameTag_,
298 extensionTableNameNode,
299 table.getView().getTableName()))
300 throw(std::runtime_error(
301 std::string(
"The document is missing the mandatory tag: ") +
302 XML_TO_STRING(extensionTableNameTag_)));
303 xercesc::DOMNode* nameNode = getNode(nameTag_, typeElement, 0);
304 if(!validateNode(nameTag_, nameNode, table.getTableName()))
305 throw(std::runtime_error(
306 std::string(
"The document is missing the mandatory tag: ") +
307 XML_TO_STRING(nameTag_)));
313 xercesc::DOMElement* runElement = getElement(runTag_, headerNode, 0);
315 throw(std::runtime_error(
316 std::string(
"The document is missing the mandatory tag: ") +
317 XML_TO_STRING(runTag_)));
318 xercesc::DOMNode* runTypeNode = getNode(runTypeTag_, runElement, 0);
319 assert(validateNode(runTypeTag_, runTypeNode, table.getTableName()));
320 xercesc::DOMNode* runNumberNode = getNode(runNumberTag_, runElement, 0);
322 throw(std::runtime_error(
323 std::string(
"The document is missing the mandatory tag: ") +
324 XML_TO_STRING(runNumberTag_)));
325 xercesc::DOMNode* runBeginTimestampNode =
326 getNode(runBeginTimestampTag_, runElement, 0);
327 if(!runBeginTimestampNode)
328 throw(std::runtime_error(
329 std::string(
"The document is missing the mandatory tag: ") +
330 XML_TO_STRING(runBeginTimestampTag_)));
331 xercesc::DOMNode* locationNode = getNode(locationTag_, runElement, 0);
333 throw(std::runtime_error(
334 std::string(
"The document is missing the mandatory tag: ") +
335 XML_TO_STRING(locationTag_)));
343 xercesc::DOMElement* datasetElement = getElement(datasetTag_, elementRoot, 0);
345 throw(std::runtime_error(
346 std::string(
"The document is missing the mandatory tag: ") +
347 XML_TO_STRING(datasetTag_)));
351 xercesc::DOMNode* partNode = getNode(partTag_, datasetElement, 0);
352 xercesc::DOMNode* nameLabelNode = getNode(nameLabelTag_, partNode, 0);
353 xercesc::DOMNode* kindOfPartNode = getNode(kindOfPartTag_, partNode, 0);
356 xercesc::DOMNode* versionNode = getNode(versionTag_, datasetElement, 0);
358 if(versionNode->getFirstChild() == 0)
360 throw(std::runtime_error(
361 std::string(
"Missing version tag: ") +
362 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())));
366 char tmpVersionStr[100];
367 sprintf(tmpVersionStr,
"%d", version.version());
368 __COUT__ << version <<
"-"
369 << XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())
371 if(strcmp(tmpVersionStr,
372 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())) != 0)
373 throw(std::runtime_error(
374 std::string(
"Mis-matched version tag: ") +
375 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()) +
" vs " +
379 table.getViewP()->setVersion(
380 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()));
382 xercesc::DOMNode* commentDescriptionNode =
383 getNode(commentDescriptionTag_, datasetElement, 0);
384 if(commentDescriptionNode->getFirstChild() != 0)
385 table.getViewP()->setComment(
386 XML_TO_CHAR(commentDescriptionNode->getFirstChild()->getNodeValue()));
388 xercesc::DOMNode* createdByUserNode =
389 getNode(createdByUserTag_, datasetElement, 0);
390 if(createdByUserNode->getFirstChild() != 0)
391 table.getViewP()->setAuthor(
392 XML_TO_CHAR(createdByUserNode->getFirstChild()->getNodeValue()));
396 xercesc::DOMNodeList* dataNodeList =
397 datasetElement->getElementsByTagName(dataTag_);
400 throw(std::runtime_error(std::string(
"Can't find ") +
401 XML_TO_STRING(dataTag_) +
" tag!"));
407 if(!dataNodeList->getLength())
409 __SS__ <<
"Must be non-empty data set!";
416 table.getViewP()->resizeDataView(dataNodeList->getLength(),
417 table.getView().getNumberOfColumns());
419 for(XMLSize_t row = 0; row < dataNodeList->getLength(); row++)
423 xercesc::DOMNodeList* columnNodeList =
424 dataNodeList->item(row)->getChildNodes();
425 unsigned int colNumber = 0;
429 for(XMLSize_t col = 0; col < columnNodeList->getLength(); col++)
433 if(!columnNodeList->item(col)->getNodeType() ||
434 columnNodeList->item(col)->getNodeType() !=
435 xercesc::DOMNode::ELEMENT_NODE)
438 xercesc::DOMElement* columnElement =
439 dynamic_cast<xercesc::DOMElement*
>(columnNodeList->item(col));
441 if(table.getView().getColumnInfo(colNumber).getStorageName() !=
442 XML_TO_STRING(columnElement->getTagName()))
444 std::stringstream error;
445 error << __COUT_HDR__ << std::endl
446 <<
"The column number " << colNumber <<
" named "
447 << table.getView().getColumnInfo(colNumber).getStorageName()
448 <<
" defined in the view " << table.getView().getTableName()
449 <<
" doesn't match the file column order, since the "
453 : (colNumber == 1 ?
"nd"
454 : (colNumber == 2 ?
"rd" :
"th")))
455 <<
" element found in the file at " << XML_TO_CHAR(dataTag_)
456 <<
" tag number " << row <<
" is "
457 << XML_TO_CHAR(columnElement->getTagName());
458 __MOUT_ERR__ << error.str();
459 throw(std::runtime_error(error.str()));
469 table.getViewP()->setValueAsString(
471 columnNodeList->item(col)->getFirstChild()->getNodeValue()),
480 catch(xercesc::XMLException& e)
482 __COUT__ <<
"Error parsing file: " << configFile << std::endl;
483 std::ostringstream errBuf;
484 errBuf <<
"Error parsing file: " << XML_TO_CHAR(e.getMessage()) << std::flush;
487 __COUT__ <<
"Done with table file: " << configFile << std::endl;
495 std::string ConfigurationHandler::writeXML(
const TableBase& table)
499 std::string configFile = getXMLFileName(
501 table.getViewVersion());
504 xercesc::DOMImplementation* implementation =
505 xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML(
"Core"));
506 if(implementation != 0)
511 xercesc::DOMDocument* document =
512 implementation->createDocument(0,
516 xercesc::DOMElement* rootElement = document->getDocumentElement();
517 rootElement->setAttribute(
518 CONVERT_TO_XML(
"xmlns:xsi"),
519 CONVERT_TO_XML(
"http://www.w3.org/2001/XMLSchema-instance"));
520 rootElement->setAttribute(
521 CONVERT_TO_XML(
"xsi:noNamespaceSchemaLocation"),
529 xercesc::DOMElement* headerElement = document->createElement(headerTag_);
530 rootElement->appendChild(headerElement);
533 xercesc::DOMElement* typeElement = document->createElement(typeTag_);
534 headerElement->appendChild(typeElement);
536 xercesc::DOMElement* extensionTableNameElement =
537 document->createElement(extensionTableNameTag_);
538 typeElement->appendChild(extensionTableNameElement);
539 xercesc::DOMText* extensionTableNameValue = document->createTextNode(
540 CONVERT_TO_XML(table.getView().getTableName().c_str()));
541 extensionTableNameElement->appendChild(extensionTableNameValue);
543 xercesc::DOMElement* nameElement = document->createElement(nameTag_);
544 typeElement->appendChild(nameElement);
545 xercesc::DOMText* nameValue =
546 document->createTextNode(CONVERT_TO_XML(table.getTableName().c_str()));
547 nameElement->appendChild(nameValue);
551 xercesc::DOMElement* runElement = document->createElement(runTag_);
552 headerElement->appendChild(runElement);
554 xercesc::DOMElement* runTypeElement = document->createElement(runTypeTag_);
555 runElement->appendChild(runTypeElement);
556 xercesc::DOMText* runTypeValue =
557 document->createTextNode(CONVERT_TO_XML(table.getTableName().c_str()));
558 runTypeElement->appendChild(runTypeValue);
560 xercesc::DOMElement* runNumberElement =
561 document->createElement(runNumberTag_);
562 runElement->appendChild(runNumberElement);
563 xercesc::DOMText* runNumberValue = document->createTextNode(CONVERT_TO_XML(
565 runNumberElement->appendChild(runNumberValue);
567 xercesc::DOMElement* runBeginTimestampElement =
568 document->createElement(runBeginTimestampTag_);
569 runElement->appendChild(runBeginTimestampElement);
570 xercesc::DOMText* runBeginTimestampValue = document->createTextNode(
571 CONVERT_TO_XML(TimeFormatter::getTime().c_str()));
575 runBeginTimestampElement->appendChild(runBeginTimestampValue);
577 xercesc::DOMElement* locationElement = document->createElement(locationTag_);
578 runElement->appendChild(locationElement);
579 xercesc::DOMText* locationValue = document->createTextNode(
580 CONVERT_TO_XML(
"CERN P5"));
582 locationElement->appendChild(locationValue);
585 xercesc::DOMElement* datasetElement = document->createElement(datasetTag_);
586 rootElement->appendChild(datasetElement);
588 xercesc::DOMElement* partElement = document->createElement(partTag_);
589 datasetElement->appendChild(partElement);
591 xercesc::DOMElement* nameLabelElement =
592 document->createElement(nameLabelTag_);
593 partElement->appendChild(nameLabelElement);
594 xercesc::DOMText* nameLabelValue =
595 document->createTextNode(CONVERT_TO_XML(
"CMS--ROOT"));
596 nameLabelElement->appendChild(nameLabelValue);
598 xercesc::DOMElement* kindOfPartElement =
599 document->createElement(kindOfPartTag_);
600 partElement->appendChild(kindOfPartElement);
601 xercesc::DOMText* kindOfPartValue =
602 document->createTextNode(CONVERT_TO_XML(
"Detector ROOT"));
603 kindOfPartElement->appendChild(kindOfPartValue);
605 xercesc::DOMElement* versionElement = document->createElement(versionTag_);
606 datasetElement->appendChild(versionElement);
607 xercesc::DOMText* versionValue = document->createTextNode(
608 CONVERT_TO_XML(table.getView().getVersion().version()));
609 versionElement->appendChild(versionValue);
611 xercesc::DOMElement* commentDescriptionElement =
612 document->createElement(commentDescriptionTag_);
613 datasetElement->appendChild(commentDescriptionElement);
614 xercesc::DOMText* commentDescriptionValue = document->createTextNode(
615 CONVERT_TO_XML(table.getView().getComment().c_str()));
616 commentDescriptionElement->appendChild(commentDescriptionValue);
618 xercesc::DOMElement* createdByUserElement =
619 document->createElement(createdByUserTag_);
620 datasetElement->appendChild(createdByUserElement);
621 xercesc::DOMText* createdByUserValue = document->createTextNode(
622 CONVERT_TO_XML(table.getView().getAuthor().c_str()));
623 createdByUserElement->appendChild(createdByUserValue);
627 for(
unsigned int row = 0; row < table.getView().getNumberOfRows(); row++)
629 xercesc::DOMElement* dataElement = document->createElement(dataTag_);
630 datasetElement->appendChild(dataElement);
632 for(
unsigned int col = 0; col < table.getView().getNumberOfColumns();
635 xercesc::DOMElement* element = document->createElement(CONVERT_TO_XML(
636 table.getView().getColumnInfo(col).getStorageName().c_str()));
637 dataElement->appendChild(element);
638 xercesc::DOMText* value = document->createTextNode(
639 CONVERT_TO_XML(table.getView().getDataView()[row][col].c_str()));
640 element->appendChild(value);
644 outputXML(document, configFile);
648 catch(
const xercesc::OutOfMemoryException&)
650 XERCES_STD_QUALIFIER cerr <<
"OutOfMemoryException"
651 << XERCES_STD_QUALIFIER endl;
654 catch(
const xercesc::DOMException& e)
656 XERCES_STD_QUALIFIER cerr <<
"DOMException code is: " << e.code
657 << XERCES_STD_QUALIFIER endl;
660 catch(
const xercesc::XMLException& e)
662 std::string message = XML_TO_STRING(e.getMessage());
663 __COUT__ <<
"Error Message: " << message << std::endl;
669 XERCES_STD_QUALIFIER cerr <<
"An error occurred creating the document"
670 << XERCES_STD_QUALIFIER endl;
676 XERCES_STD_QUALIFIER cerr <<
"Requested implementation is not supported"
677 << XERCES_STD_QUALIFIER endl;
688 void ConfigurationHandler::outputXML(xercesc::DOMDocument* pmyDOMDocument,
689 std::string fileName)
691 std::string directory = fileName.substr(0, fileName.rfind(
"/") + 1);
692 __COUT__ <<
"Saving XML to " << fileName <<
" in directory: " << directory
695 mkdir(directory.c_str(), 0755);
701 xercesc::DOMImplementation* implementation =
702 xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML(
"LS"));
704 #if _XERCES_VERSION >= 30000
707 xercesc::DOMLSSerializer* serializer =
708 ((xercesc::DOMImplementationLS*)implementation)->createLSSerializer();
712 if(serializer->getDomConfig()->canSetParameter(
713 xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true))
714 serializer->getDomConfig()->setParameter(
715 xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true);
723 xercesc::XMLFormatTarget* formatTarget =
724 new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName));
727 xercesc::DOMLSOutput* output =
728 ((xercesc::DOMImplementationLS*)implementation)->createLSOutput();
731 output->setByteStream(formatTarget);
734 serializer->write(pmyDOMDocument, output);
737 xercesc::DOMWriter* serializer =
738 ((xercesc::DOMImplementationLS*)implementation)->createDOMWriter();
740 serializer->setFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true);
752 xercesc::XMLFormatTarget* formatTarget =
753 new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName.c_str()));
756 serializer->writeNode(formatTarget, *pmyDOMDocument);
761 serializer->release();
765 #if _XERCES_VERSION >= 30000
770 __COUT__ <<
"Done writing " << std::endl;
774 std::string ConfigurationHandler::writeXML(
const TableBase* table)
776 return writeXML(*table);
780 std::string ConfigurationHandler::getXMLFileName(
const TableBase& table,
783 std::stringstream fileName;
784 fileName << getXMLDir(&table) << version <<
'/' << table.getTableName() <<
"_v"
785 << version <<
".xml";
786 return fileName.str();
790 std::string ConfigurationHandler::getXMLDir(
const TableBase* table)
792 return std::string(__ENV__(
"CONFIGURATION_DATA_PATH")) +
'/' + table->getTableName() +