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(*configuration, version);
220 std::string configFile = getXMLFileName(configuration, version);
222 __COUT__ <<
"Reading: " << configFile << std::endl;
223 __COUT__ <<
"Into View with Table Name: " << configuration.getViewP()->getTableName()
225 __COUT__ <<
"Into View with version: " << configuration.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 configuration.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, configuration.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, configuration.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 configuration.getViewP()->setVersion(
380 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()));
382 xercesc::DOMNode* commentDescriptionNode =
383 getNode(commentDescriptionTag_, datasetElement, 0);
384 if(commentDescriptionNode->getFirstChild() != 0)
385 configuration.getViewP()->setComment(
386 XML_TO_CHAR(commentDescriptionNode->getFirstChild()->getNodeValue()));
388 xercesc::DOMNode* createdByUserNode =
389 getNode(createdByUserTag_, datasetElement, 0);
390 if(createdByUserNode->getFirstChild() != 0)
391 configuration.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 configuration.getViewP()->resizeDataView(
417 dataNodeList->getLength(), configuration.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(configuration.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 << configuration.getView()
448 .getColumnInfo(colNumber)
450 <<
" defined in the view "
451 << configuration.getView().getTableName()
452 <<
" doesn't match the file column order, since the "
456 : (colNumber == 1 ?
"nd"
457 : (colNumber == 2 ?
"rd" :
"th")))
458 <<
" element found in the file at " << XML_TO_CHAR(dataTag_)
459 <<
" tag number " << row <<
" is "
460 << XML_TO_CHAR(columnElement->getTagName());
461 __MOUT_ERR__ << error.str();
462 throw(std::runtime_error(error.str()));
472 configuration.getViewP()->setValueAsString(
474 columnNodeList->item(col)->getFirstChild()->getNodeValue()),
483 catch(xercesc::XMLException& e)
485 __COUT__ <<
"Error parsing file: " << configFile << std::endl;
486 std::ostringstream errBuf;
487 errBuf <<
"Error parsing file: " << XML_TO_CHAR(e.getMessage()) << std::flush;
490 __COUT__ <<
"Done with configuration file: " << configFile << std::endl;
498 std::string ConfigurationHandler::writeXML(
const TableBase& configuration)
502 std::string configFile = getXMLFileName(
508 xercesc::DOMImplementation* implementation =
509 xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML(
"Core"));
510 if(implementation != 0)
515 xercesc::DOMDocument* document =
516 implementation->createDocument(0,
520 xercesc::DOMElement* rootElement = document->getDocumentElement();
521 rootElement->setAttribute(
522 CONVERT_TO_XML(
"xmlns:xsi"),
523 CONVERT_TO_XML(
"http://www.w3.org/2001/XMLSchema-instance"));
524 rootElement->setAttribute(
525 CONVERT_TO_XML(
"xsi:noNamespaceSchemaLocation"),
533 xercesc::DOMElement* headerElement = document->createElement(headerTag_);
534 rootElement->appendChild(headerElement);
537 xercesc::DOMElement* typeElement = document->createElement(typeTag_);
538 headerElement->appendChild(typeElement);
540 xercesc::DOMElement* extensionTableNameElement =
541 document->createElement(extensionTableNameTag_);
542 typeElement->appendChild(extensionTableNameElement);
543 xercesc::DOMText* extensionTableNameValue = document->createTextNode(
544 CONVERT_TO_XML(configuration.getView().getTableName().c_str()));
545 extensionTableNameElement->appendChild(extensionTableNameValue);
547 xercesc::DOMElement* nameElement = document->createElement(nameTag_);
548 typeElement->appendChild(nameElement);
549 xercesc::DOMText* nameValue = document->createTextNode(
550 CONVERT_TO_XML(configuration.getTableName().c_str()));
551 nameElement->appendChild(nameValue);
555 xercesc::DOMElement* runElement = document->createElement(runTag_);
556 headerElement->appendChild(runElement);
558 xercesc::DOMElement* runTypeElement = document->createElement(runTypeTag_);
559 runElement->appendChild(runTypeElement);
560 xercesc::DOMText* runTypeValue = document->createTextNode(
561 CONVERT_TO_XML(configuration.getTableName().c_str()));
562 runTypeElement->appendChild(runTypeValue);
564 xercesc::DOMElement* runNumberElement =
565 document->createElement(runNumberTag_);
566 runElement->appendChild(runNumberElement);
567 xercesc::DOMText* runNumberValue = document->createTextNode(CONVERT_TO_XML(
569 runNumberElement->appendChild(runNumberValue);
571 xercesc::DOMElement* runBeginTimestampElement =
572 document->createElement(runBeginTimestampTag_);
573 runElement->appendChild(runBeginTimestampElement);
574 xercesc::DOMText* runBeginTimestampValue = document->createTextNode(
575 CONVERT_TO_XML(TimeFormatter::getTime().c_str()));
579 runBeginTimestampElement->appendChild(runBeginTimestampValue);
581 xercesc::DOMElement* locationElement = document->createElement(locationTag_);
582 runElement->appendChild(locationElement);
583 xercesc::DOMText* locationValue = document->createTextNode(
584 CONVERT_TO_XML(
"CERN P5"));
586 locationElement->appendChild(locationValue);
589 xercesc::DOMElement* datasetElement = document->createElement(datasetTag_);
590 rootElement->appendChild(datasetElement);
592 xercesc::DOMElement* partElement = document->createElement(partTag_);
593 datasetElement->appendChild(partElement);
595 xercesc::DOMElement* nameLabelElement =
596 document->createElement(nameLabelTag_);
597 partElement->appendChild(nameLabelElement);
598 xercesc::DOMText* nameLabelValue =
599 document->createTextNode(CONVERT_TO_XML(
"CMS--ROOT"));
600 nameLabelElement->appendChild(nameLabelValue);
602 xercesc::DOMElement* kindOfPartElement =
603 document->createElement(kindOfPartTag_);
604 partElement->appendChild(kindOfPartElement);
605 xercesc::DOMText* kindOfPartValue =
606 document->createTextNode(CONVERT_TO_XML(
"Detector ROOT"));
607 kindOfPartElement->appendChild(kindOfPartValue);
609 xercesc::DOMElement* versionElement = document->createElement(versionTag_);
610 datasetElement->appendChild(versionElement);
611 xercesc::DOMText* versionValue = document->createTextNode(
612 CONVERT_TO_XML(configuration.getView().getVersion().version()));
613 versionElement->appendChild(versionValue);
615 xercesc::DOMElement* commentDescriptionElement =
616 document->createElement(commentDescriptionTag_);
617 datasetElement->appendChild(commentDescriptionElement);
618 xercesc::DOMText* commentDescriptionValue = document->createTextNode(
619 CONVERT_TO_XML(configuration.getView().getComment().c_str()));
620 commentDescriptionElement->appendChild(commentDescriptionValue);
622 xercesc::DOMElement* createdByUserElement =
623 document->createElement(createdByUserTag_);
624 datasetElement->appendChild(createdByUserElement);
625 xercesc::DOMText* createdByUserValue = document->createTextNode(
626 CONVERT_TO_XML(configuration.getView().getAuthor().c_str()));
627 createdByUserElement->appendChild(createdByUserValue);
631 for(
unsigned int row = 0; row < configuration.getView().getNumberOfRows();
634 xercesc::DOMElement* dataElement = document->createElement(dataTag_);
635 datasetElement->appendChild(dataElement);
637 for(
unsigned int col = 0;
638 col < configuration.getView().getNumberOfColumns();
641 xercesc::DOMElement* element =
642 document->createElement(CONVERT_TO_XML(configuration.getView()
646 dataElement->appendChild(element);
647 xercesc::DOMText* value = document->createTextNode(CONVERT_TO_XML(
648 configuration.getView().getDataView()[row][col].c_str()));
649 element->appendChild(value);
653 outputXML(document, configFile);
657 catch(
const xercesc::OutOfMemoryException&)
659 XERCES_STD_QUALIFIER cerr <<
"OutOfMemoryException"
660 << XERCES_STD_QUALIFIER endl;
663 catch(
const xercesc::DOMException& e)
665 XERCES_STD_QUALIFIER cerr <<
"DOMException code is: " << e.code
666 << XERCES_STD_QUALIFIER endl;
669 catch(
const xercesc::XMLException& e)
671 std::string message = XML_TO_STRING(e.getMessage());
672 __COUT__ <<
"Error Message: " << message << std::endl;
678 XERCES_STD_QUALIFIER cerr <<
"An error occurred creating the document"
679 << XERCES_STD_QUALIFIER endl;
685 XERCES_STD_QUALIFIER cerr <<
"Requested implementation is not supported"
686 << XERCES_STD_QUALIFIER endl;
697 void ConfigurationHandler::outputXML(xercesc::DOMDocument* pmyDOMDocument,
698 std::string fileName)
700 std::string directory = fileName.substr(0, fileName.rfind(
"/") + 1);
701 __COUT__ <<
"Saving XML to " << fileName <<
" in directory: " << directory
704 mkdir(directory.c_str(), 0755);
710 xercesc::DOMImplementation* implementation =
711 xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML(
"LS"));
713 #if _XERCES_VERSION >= 30000
716 xercesc::DOMLSSerializer* serializer =
717 ((xercesc::DOMImplementationLS*)implementation)->createLSSerializer();
721 if(serializer->getDomConfig()->canSetParameter(
722 xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true))
723 serializer->getDomConfig()->setParameter(
724 xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true);
732 xercesc::XMLFormatTarget* formatTarget =
733 new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName));
736 xercesc::DOMLSOutput* output =
737 ((xercesc::DOMImplementationLS*)implementation)->createLSOutput();
740 output->setByteStream(formatTarget);
743 serializer->write(pmyDOMDocument, output);
746 xercesc::DOMWriter* serializer =
747 ((xercesc::DOMImplementationLS*)implementation)->createDOMWriter();
749 serializer->setFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true);
761 xercesc::XMLFormatTarget* formatTarget =
762 new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName.c_str()));
765 serializer->writeNode(formatTarget, *pmyDOMDocument);
770 serializer->release();
774 #if _XERCES_VERSION >= 30000
779 __COUT__ <<
"Done writing " << std::endl;
783 std::string ConfigurationHandler::writeXML(
const TableBase* configuration)
785 return writeXML(*configuration);
789 std::string ConfigurationHandler::getXMLFileName(
const TableBase& configuration,
792 std::stringstream fileName;
793 fileName << getXMLDir(&configuration) << version <<
'/'
794 << configuration.getTableName() <<
"_v" << version <<
".xml";
795 return fileName.str();
799 std::string ConfigurationHandler::getXMLDir(
const TableBase* configuration)
801 return std::string(getenv(
"CONFIGURATION_DATA_PATH")) +
'/' +
802 configuration->getTableName() +
'/';