1 #include "otsdaq-core/ConfigurationInterface/ConfigurationHandler.h"
2 #include "otsdaq-core/ConfigurationInterface/TimeFormatter.h"
4 #include "otsdaq-core/XmlUtilities/DOMTreeErrorReporter.h"
5 #include "otsdaq-core/XmlUtilities/ConvertToXML.h"
6 #include "otsdaq-core/XmlUtilities/ConvertFromXML.h"
7 #include "otsdaq-core/ConfigurationDataFormats/ConfigurationBase.h"
8 #include "otsdaq-core/Macros/CoutHeaderMacros.h"
10 #include <xercesc/parsers/XercesDOMParser.hpp>
11 #include <xercesc/dom/DOMElement.hpp>
12 #include <xercesc/dom/DOMImplementation.hpp>
13 #include <xercesc/dom/DOMImplementationRegistry.hpp>
14 #include <xercesc/dom/DOMNodeList.hpp>
15 #include <xercesc/dom/DOMText.hpp>
16 #include <xercesc/dom/DOMLSSerializer.hpp>
17 #include <xercesc/dom/DOMLSOutput.hpp>
18 #include <xercesc/util/XMLUni.hpp>
21 #include <xercesc/util/OutOfMemoryException.hpp>
22 #include <xercesc/framework/LocalFileFormatTarget.hpp>
27 #include <sys/types.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)
64 ConfigurationHandler::~ConfigurationHandler(
void)
68 void ConfigurationHandler::initPlatform(
void)
72 xercesc::XMLPlatformUtils::Initialize();
74 catch( xercesc::XMLException& e )
76 mf::LogError(__FILE__) <<
"XML toolkit initialization error: " << XML_TO_CHAR(e.getMessage()) << std::endl;
80 rootTag_ = xercesc::XMLString::transcode(
"ROOT");
81 headerTag_ = xercesc::XMLString::transcode(
"HEADER");
82 typeTag_ = xercesc::XMLString::transcode(
"TYPE");
83 extensionTableNameTag_ = xercesc::XMLString::transcode(
"EXTENSION_TABLE_NAME");
84 nameTag_ = xercesc::XMLString::transcode(
"NAME");
85 runTag_ = xercesc::XMLString::transcode(
"RUN");
86 runTypeTag_ = xercesc::XMLString::transcode(
"RUN_TYPE");
87 runNumberTag_ = xercesc::XMLString::transcode(
"RUN_NUMBER");
88 runBeginTimestampTag_ = xercesc::XMLString::transcode(
"RUN_BEGIN_TIMESTAMP");
89 locationTag_ = xercesc::XMLString::transcode(
"LOCATION");
90 datasetTag_ = xercesc::XMLString::transcode(
"DATA_SET");
91 versionTag_ = xercesc::XMLString::transcode(
"VERSION");
92 commentDescriptionTag_ = xercesc::XMLString::transcode(
"COMMENT_DESCRIPTION");
93 createdByUserTag_ = xercesc::XMLString::transcode(
"CREATED_BY_USER");
94 partTag_ = xercesc::XMLString::transcode(
"PART");
95 nameLabelTag_ = xercesc::XMLString::transcode(
"NAME_LABEL");
96 kindOfPartTag_ = xercesc::XMLString::transcode(
"KIND_OF_PART");
97 dataTag_ = xercesc::XMLString::transcode(
"DATA");
101 void ConfigurationHandler::terminatePlatform(
void)
105 xercesc::XMLString::release( &rootTag_ );
106 xercesc::XMLString::release( &headerTag_ );
107 xercesc::XMLString::release( &typeTag_ );
108 xercesc::XMLString::release( &extensionTableNameTag_ );
109 xercesc::XMLString::release( &nameTag_ );
110 xercesc::XMLString::release( &runTag_ );
111 xercesc::XMLString::release( &runTypeTag_ );
112 xercesc::XMLString::release( &runNumberTag_ );
113 xercesc::XMLString::release( &runBeginTimestampTag_ );
114 xercesc::XMLString::release( &locationTag_ );
115 xercesc::XMLString::release( &datasetTag_ );
116 xercesc::XMLString::release( &versionTag_ );
117 xercesc::XMLString::release( &commentDescriptionTag_ );
118 xercesc::XMLString::release( &createdByUserTag_ );
119 xercesc::XMLString::release( &partTag_ );
120 xercesc::XMLString::release( &nameLabelTag_ );
121 xercesc::XMLString::release( &kindOfPartTag_ );
122 xercesc::XMLString::release( &dataTag_ );
126 mf::LogError(__FILE__) <<
"Unknown exception encountered in TagNames destructor" << std::endl;
131 xercesc::XMLPlatformUtils::Terminate();
133 catch( xercesc::XMLException& e )
135 mf::LogError(__FILE__) <<
"XML ttolkit teardown error: " << XML_TO_CHAR(e.getMessage()) << std::endl;
140 bool ConfigurationHandler::validateNode(XMLCh* tagName, xercesc::DOMNode* node,
const std::string& expectedValue)
142 if( node->getFirstChild() == 0 )
144 __COUT__<<
"Tag " << XML_TO_CHAR(tagName) <<
" doesn't have a value!" << std::endl;
148 if( XML_TO_STRING(node->getFirstChild()->getNodeValue()) != expectedValue)
150 __COUT__<<
"The tag " << XML_TO_CHAR(tagName) <<
" with value " << XML_TO_CHAR(node->getFirstChild()->getNodeValue())
151 <<
" doesn't match the expected value " << expectedValue << std::endl;
159 xercesc::DOMNode* ConfigurationHandler::getNode(XMLCh* tagName, xercesc::DOMNode* parent,
unsigned int itemNumber)
161 return getNode(tagName, dynamic_cast< xercesc::DOMElement* >(parent), itemNumber);
165 xercesc::DOMNode* ConfigurationHandler::getNode(XMLCh* tagName, xercesc::DOMElement* parent,
unsigned int itemNumber)
167 xercesc::DOMNodeList* nodeList = parent->getElementsByTagName(tagName);
171 throw(std::runtime_error( std::string(
"Can't find ") + XML_TO_STRING(tagName) +
" tag!"));
172 __COUT__ << (std::string(
"Can't find ") + XML_TO_STRING(tagName) +
" tag!") << std::endl;
178 return nodeList->item(itemNumber);
182 xercesc::DOMElement* ConfigurationHandler::getElement(XMLCh* tagName, xercesc::DOMNode* parent,
unsigned int itemNumber)
184 return dynamic_cast< xercesc::DOMElement*
>(getNode(tagName,parent,itemNumber));
188 xercesc::DOMElement* ConfigurationHandler::getElement(XMLCh* tagName, xercesc::DOMElement* parent,
unsigned int itemNumber)
190 return dynamic_cast< xercesc::DOMElement*
>(getNode(tagName,parent,itemNumber));
196 readXML(*configuration,version);
204 std::string configFile = getXMLFileName(configuration,version);
206 __COUT__ <<
"Reading: " << configFile << std::endl;
207 __COUT__ <<
"Into View with Table Name: " <<
208 configuration.getViewP()->getTableName() << std::endl;
209 __COUT__ <<
"Into View with version: " <<
210 configuration.getViewP()->getVersion() <<
" and version-to-read: " <<
211 version << std::endl;
213 struct stat fileStatus;
215 if(stat(configFile.c_str(), &fileStatus) < 0)
217 __COUT__ <<
"Error reading path: " << configFile << std::endl;
218 std::stringstream ss; ss << __MF_HDR__;
219 if( errno == ENOENT )
220 ss << (
"Path file_name does not exist.");
221 else if( errno == ENOTDIR )
222 ss << (
"A component of the path is not a directory.");
223 else if( errno == ELOOP )
224 ss << (
"Too many symbolic links encountered while traversing the path.");
225 else if( errno == EACCES )
226 ss << (
"Permission denied.");
227 else if( errno == ENAMETOOLONG )
228 ss << (
"File name too long.");
230 ss << (
"File can not be read.");
232 __COUT_ERR__ << ss.str();
233 throw std::runtime_error(ss.str());
236 xercesc::XercesDOMParser* parser =
new xercesc::XercesDOMParser;
239 parser->setValidationScheme(xercesc::XercesDOMParser::Val_Auto);
240 parser->setDoNamespaces (
true );
241 parser->setDoSchema (
false );
243 parser->useCachedGrammarInParse (
false );
245 parser->setErrorHandler(errorHandler);
251 parser->parse( configFile.c_str() );
255 xercesc::DOMDocument* document = parser->getDocument();
258 xercesc::DOMElement* elementRoot = document->getDocumentElement();
260 if( !elementRoot )
throw(std::runtime_error(
"empty XML document" ));
263 xercesc::DOMNode* headerNode = getNode(headerTag_, elementRoot, 0);
264 if( !headerNode )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(headerTag_ )));
268 xercesc::DOMElement* typeElement = getElement(typeTag_, headerNode, 0);
269 if( !typeElement )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(typeTag_ )));
270 xercesc::DOMNode* extensionTableNameNode = getNode (extensionTableNameTag_, typeElement, 0);
271 if(!validateNode(extensionTableNameTag_,extensionTableNameNode,configuration.getView().getTableName()))
272 throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(extensionTableNameTag_ )));
273 xercesc::DOMNode* nameNode = getNode (nameTag_, typeElement, 0);
274 if(!validateNode(nameTag_,nameNode,configuration.getConfigurationName()))
275 throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(nameTag_ )));
281 xercesc::DOMElement* runElement = getElement(runTag_, headerNode,0);
282 if( !runElement )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(runTag_ )));
283 xercesc::DOMNode* runTypeNode = getNode (runTypeTag_, runElement, 0);
284 assert(validateNode(runTypeTag_,runTypeNode,configuration.getConfigurationName()));
285 xercesc::DOMNode* runNumberNode = getNode (runNumberTag_, runElement, 0);
286 if( !runNumberNode )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(runNumberTag_ )));
287 xercesc::DOMNode* runBeginTimestampNode = getNode (runBeginTimestampTag_, runElement, 0);
288 if( !runBeginTimestampNode )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(runBeginTimestampTag_ )));
289 xercesc::DOMNode* locationNode = getNode (locationTag_, runElement, 0);
290 if( !locationNode )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(locationTag_ )));
298 xercesc::DOMElement* datasetElement = getElement(datasetTag_, elementRoot, 0);
299 if( !datasetElement )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(datasetTag_ )));
303 xercesc::DOMNode* partNode = getNode (partTag_, datasetElement, 0);
304 xercesc::DOMNode* nameLabelNode = getNode (nameLabelTag_, partNode, 0);
305 xercesc::DOMNode* kindOfPartNode = getNode (kindOfPartTag_, partNode, 0);
308 xercesc::DOMNode* versionNode = getNode (versionTag_, datasetElement, 0);
310 if(versionNode->getFirstChild() == 0)
312 throw(std::runtime_error( std::string(
"Missing version tag: ") + XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())));
316 char tmpVersionStr[100];
317 sprintf(tmpVersionStr,
"%d", version.version());
318 __COUT__ << version <<
"-" << XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()) << std::endl;
319 if(strcmp(tmpVersionStr,XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())) != 0)
320 throw(std::runtime_error( std::string(
"Mis-matched version tag: ") + XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()) +
321 " vs " + tmpVersionStr));
324 configuration.getViewP()->setVersion(XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()));
326 xercesc::DOMNode* commentDescriptionNode = getNode (commentDescriptionTag_, datasetElement, 0);
327 if(commentDescriptionNode->getFirstChild() != 0)
328 configuration.getViewP()->setComment(XML_TO_CHAR(commentDescriptionNode->getFirstChild()->getNodeValue()));
330 xercesc::DOMNode* createdByUserNode = getNode (createdByUserTag_, datasetElement, 0);
331 if(createdByUserNode->getFirstChild() != 0)
332 configuration.getViewP()->setAuthor(XML_TO_CHAR(createdByUserNode->getFirstChild()->getNodeValue()));
336 xercesc::DOMNodeList* dataNodeList = datasetElement->getElementsByTagName(dataTag_);
339 throw(std::runtime_error( std::string(
"Can't find ") + XML_TO_STRING(dataTag_) +
" tag!"));
344 if(!dataNodeList->getLength())
346 __SS__ <<
"Must be non-empty data set!";
347 throw std::runtime_error(ss.str());
352 configuration.getViewP()->resizeDataView(dataNodeList->getLength(), configuration.getView().getNumberOfColumns());
354 for( XMLSize_t row = 0; row < dataNodeList->getLength(); row++ )
357 xercesc::DOMNodeList* columnNodeList = dataNodeList->item(row)->getChildNodes();
358 unsigned int colNumber = 0;
361 for( XMLSize_t col = 0; col < columnNodeList->getLength(); col++ )
365 if( !columnNodeList->item(col)->getNodeType() || columnNodeList->item(col)->getNodeType() != xercesc::DOMNode::ELEMENT_NODE )
368 xercesc::DOMElement* columnElement =
dynamic_cast< xercesc::DOMElement*
>( columnNodeList->item(col) );
370 if( configuration.getView().getColumnInfo(colNumber).getStorageName() != XML_TO_STRING(columnElement->getTagName()))
372 std::stringstream error;
373 error << __COUT_HDR__ << std::endl
374 <<
"The column number " << colNumber
375 <<
" named " << configuration.getView().getColumnInfo(colNumber).getStorageName()
376 <<
" defined in the view " << configuration.getView().getTableName()
377 <<
" doesn't match the file column order, since the "
378 << colNumber+1 << (colNumber==0?
"st":(colNumber==1?
"nd":(colNumber==2?
"rd":
"th")))
379 <<
" element found in the file at " << XML_TO_CHAR(dataTag_) <<
" tag number " << row
380 <<
" is " << XML_TO_CHAR(columnElement->getTagName());
381 mf::LogError(__FILE__) << error.str();
382 throw(std::runtime_error( error.str() ));
390 configuration.getViewP()->setValueAsString(
391 XML_TO_STRING(columnNodeList->item(col)->getFirstChild()->getNodeValue())
399 catch( xercesc::XMLException& e )
401 __COUT__ <<
"Error parsing file: " << configFile << std::endl;
402 std::ostringstream errBuf;
403 errBuf <<
"Error parsing file: " << XML_TO_CHAR(e.getMessage()) << std::flush;
406 __COUT__ <<
"Done with configuration file: " << configFile << std::endl;
415 std::string ConfigurationHandler::writeXML(
const ConfigurationBase& configuration)
419 std::string configFile = getXMLFileName(configuration,configuration.getViewVersion());
422 xercesc::DOMImplementation* implementation = xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML(
"Core"));
423 if (implementation != 0)
428 xercesc::DOMDocument* document = implementation->createDocument(
433 xercesc::DOMElement* rootElement = document->getDocumentElement();
434 rootElement->setAttribute(CONVERT_TO_XML(
"xmlns:xsi"),CONVERT_TO_XML(
"http://www.w3.org/2001/XMLSchema-instance"));
435 rootElement->setAttribute(CONVERT_TO_XML(
"xsi:noNamespaceSchemaLocation"),CONVERT_TO_XML(
"ConfigurationBase.xsd"));
439 xercesc::DOMElement* headerElement = document->createElement(headerTag_);
440 rootElement->appendChild(headerElement);
443 xercesc::DOMElement* typeElement = document->createElement(typeTag_);
444 headerElement->appendChild(typeElement);
446 xercesc::DOMElement* extensionTableNameElement = document->createElement(extensionTableNameTag_);
447 typeElement->appendChild(extensionTableNameElement);
448 xercesc::DOMText* extensionTableNameValue = document->createTextNode(CONVERT_TO_XML(configuration.getView().getTableName().c_str()));
449 extensionTableNameElement->appendChild(extensionTableNameValue);
451 xercesc::DOMElement* nameElement = document->createElement(nameTag_);
452 typeElement->appendChild(nameElement);
453 xercesc::DOMText* nameValue = document->createTextNode(CONVERT_TO_XML(configuration.getConfigurationName().c_str()));
454 nameElement->appendChild(nameValue);
458 xercesc::DOMElement* runElement = document->createElement(runTag_);
459 headerElement->appendChild(runElement);
461 xercesc::DOMElement* runTypeElement = document->createElement(runTypeTag_);
462 runElement->appendChild(runTypeElement);
463 xercesc::DOMText* runTypeValue = document->createTextNode(CONVERT_TO_XML(configuration.getConfigurationName().c_str()));
464 runTypeElement->appendChild(runTypeValue);
466 xercesc::DOMElement* runNumberElement = document->createElement(runNumberTag_);
467 runElement->appendChild(runNumberElement);
468 xercesc::DOMText* runNumberValue = document->createTextNode(CONVERT_TO_XML(
"1"));
469 runNumberElement->appendChild(runNumberValue);
471 xercesc::DOMElement* runBeginTimestampElement = document->createElement(runBeginTimestampTag_);
472 runElement->appendChild(runBeginTimestampElement);
473 xercesc::DOMText* runBeginTimestampValue = document->createTextNode(CONVERT_TO_XML(TimeFormatter::getTime().c_str()));
474 runBeginTimestampElement->appendChild(runBeginTimestampValue);
476 xercesc::DOMElement* locationElement = document->createElement(locationTag_);
477 runElement->appendChild(locationElement);
478 xercesc::DOMText* locationValue = document->createTextNode(CONVERT_TO_XML(
"CERN P5"));
479 locationElement->appendChild(locationValue);
483 xercesc::DOMElement* datasetElement = document->createElement(datasetTag_);
484 rootElement->appendChild(datasetElement);
486 xercesc::DOMElement* partElement = document->createElement(partTag_);
487 datasetElement->appendChild(partElement);
489 xercesc::DOMElement* nameLabelElement = document->createElement(nameLabelTag_);
490 partElement->appendChild(nameLabelElement);
491 xercesc::DOMText* nameLabelValue = document->createTextNode(CONVERT_TO_XML(
"CMS--ROOT"));
492 nameLabelElement->appendChild(nameLabelValue);
494 xercesc::DOMElement* kindOfPartElement = document->createElement(kindOfPartTag_);
495 partElement->appendChild(kindOfPartElement);
496 xercesc::DOMText* kindOfPartValue = document->createTextNode(CONVERT_TO_XML(
"Detector ROOT"));
497 kindOfPartElement->appendChild(kindOfPartValue);
499 xercesc::DOMElement* versionElement = document->createElement(versionTag_);
500 datasetElement->appendChild(versionElement);
501 xercesc::DOMText* versionValue = document->createTextNode(CONVERT_TO_XML(configuration.getView().getVersion().version()));
502 versionElement->appendChild(versionValue);
504 xercesc::DOMElement* commentDescriptionElement = document->createElement(commentDescriptionTag_);
505 datasetElement->appendChild(commentDescriptionElement);
506 xercesc::DOMText* commentDescriptionValue = document->createTextNode(CONVERT_TO_XML(configuration.getView().getComment().c_str()));
507 commentDescriptionElement->appendChild(commentDescriptionValue);
509 xercesc::DOMElement* createdByUserElement = document->createElement(createdByUserTag_);
510 datasetElement->appendChild(createdByUserElement);
511 xercesc::DOMText* createdByUserValue = document->createTextNode(CONVERT_TO_XML(configuration.getView().getAuthor().c_str()));
512 createdByUserElement->appendChild(createdByUserValue);
515 for(
unsigned int row=0; row<configuration.getView().getNumberOfRows(); row++)
517 xercesc::DOMElement* dataElement = document->createElement(dataTag_);
518 datasetElement->appendChild(dataElement);
520 for(
unsigned int col=0; col<configuration.getView().getNumberOfColumns(); col++)
522 xercesc::DOMElement* element = document->createElement(CONVERT_TO_XML(configuration.getView().getColumnInfo(col).getStorageName().c_str()));
523 dataElement->appendChild(element);
524 xercesc::DOMText* value = document->createTextNode(CONVERT_TO_XML(configuration.getView().getDataView()[row][col].c_str()));
525 element->appendChild(value);
529 outputXML(document, configFile);
533 catch (
const xercesc::OutOfMemoryException&)
535 XERCES_STD_QUALIFIER cerr <<
"OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
538 catch (
const xercesc::DOMException& e)
540 XERCES_STD_QUALIFIER cerr <<
"DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl;
543 catch(
const xercesc::XMLException& e)
545 std::string message = XML_TO_STRING(e.getMessage());
546 __COUT__ <<
"Error Message: " << message << std::endl;
552 XERCES_STD_QUALIFIER cerr <<
"An error occurred creating the document" << XERCES_STD_QUALIFIER endl;
558 XERCES_STD_QUALIFIER cerr <<
"Requested implementation is not supported" << XERCES_STD_QUALIFIER endl;
569 void ConfigurationHandler::outputXML(xercesc::DOMDocument* pmyDOMDocument, std::string fileName)
571 std::string directory = fileName.substr(0,fileName.rfind(
"/")+1);
572 __COUT__ <<
"Saving Configuration to " << fileName <<
" in directory: " << directory << std::endl;
574 mkdir(directory.c_str(), 0755);
578 xercesc::DOMImplementation *implementation = xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML(
"LS"));
580 #if _XERCES_VERSION >= 30000
582 xercesc::DOMLSSerializer* serializer = ((xercesc::DOMImplementationLS*)implementation)->createLSSerializer();
586 if (serializer->getDomConfig()->canSetParameter(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true))
587 serializer->getDomConfig()->setParameter(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true);
595 xercesc::XMLFormatTarget* formatTarget =
new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName));
598 xercesc::DOMLSOutput* output = ((xercesc::DOMImplementationLS*)implementation)->createLSOutput();
601 output->setByteStream(formatTarget);
604 serializer->write(pmyDOMDocument, output);
607 xercesc::DOMWriter *serializer = ((xercesc::DOMImplementationLS*)implementation)->createDOMWriter();
609 serializer->setFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true);
621 xercesc::XMLFormatTarget* formatTarget =
new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName.c_str()));
624 serializer->writeNode(formatTarget, *pmyDOMDocument);
629 serializer->release();
633 #if _XERCES_VERSION >= 30000
638 __COUT__ <<
"Done writing " << std::endl;
642 std::string ConfigurationHandler::writeXML(
const ConfigurationBase* configuration)
644 return writeXML(*configuration);
650 std::stringstream fileName;
651 fileName << getXMLDir(&configuration)
653 << configuration.getConfigurationName() <<
"_v" << version <<
".xml";
654 return fileName.str();
659 std::string ConfigurationHandler::getXMLDir(
const ConfigurationBase* configuration)
661 return std::string(getenv(
"CONFIGURATION_DATA_PATH")) +
'/' + configuration->getConfigurationName() +
'/';