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 __MOUT_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 __MOUT__<<
"Tag " << XML_TO_CHAR(tagName) <<
" doesn't have a value!" << std::endl;
148 if( XML_TO_STRING(node->getFirstChild()->getNodeValue()) != expectedValue)
150 __MOUT__<<
"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 __MOUT__ << (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 __MOUT__ <<
"Reading: " << configFile << std::endl;
207 __MOUT__ <<
"Into View with Table Name: " <<
208 configuration.getViewP()->getTableName() << std::endl;
209 __MOUT__ <<
"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 __MOUT__ <<
"Error reading path: " << configFile << std::endl;
218 if( errno == ENOENT )
219 throw ( std::runtime_error(
"Path file_name does not exist.") );
220 else if( errno == ENOTDIR )
221 throw ( std::runtime_error(
"A component of the path is not a directory."));
222 else if( errno == ELOOP )
223 throw ( std::runtime_error(
"Too many symbolic links encountered while traversing the path."));
224 else if( errno == EACCES )
225 throw ( std::runtime_error(
"Permission denied."));
226 else if( errno == ENAMETOOLONG )
227 throw ( std::runtime_error(
"File name too long.\n"));
229 throw ( std::runtime_error(
"File can not be read.\n"));
232 xercesc::XercesDOMParser* parser =
new xercesc::XercesDOMParser;
235 parser->setValidationScheme(xercesc::XercesDOMParser::Val_Auto);
236 parser->setDoNamespaces (
true );
237 parser->setDoSchema (
false );
239 parser->useCachedGrammarInParse (
false );
241 parser->setErrorHandler(errorHandler);
247 parser->parse( configFile.c_str() );
251 xercesc::DOMDocument* document = parser->getDocument();
254 xercesc::DOMElement* elementRoot = document->getDocumentElement();
256 if( !elementRoot )
throw(std::runtime_error(
"empty XML document" ));
259 xercesc::DOMNode* headerNode = getNode(headerTag_, elementRoot, 0);
260 if( !headerNode )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(headerTag_ )));
264 xercesc::DOMElement* typeElement = getElement(typeTag_, headerNode, 0);
265 if( !typeElement )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(typeTag_ )));
266 xercesc::DOMNode* extensionTableNameNode = getNode (extensionTableNameTag_, typeElement, 0);
267 if(!validateNode(extensionTableNameTag_,extensionTableNameNode,configuration.getView().getTableName()))
268 throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(extensionTableNameTag_ )));
269 xercesc::DOMNode* nameNode = getNode (nameTag_, typeElement, 0);
270 if(!validateNode(nameTag_,nameNode,configuration.getConfigurationName()))
271 throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(nameTag_ )));
277 xercesc::DOMElement* runElement = getElement(runTag_, headerNode,0);
278 if( !runElement )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(runTag_ )));
279 xercesc::DOMNode* runTypeNode = getNode (runTypeTag_, runElement, 0);
280 assert(validateNode(runTypeTag_,runTypeNode,configuration.getConfigurationName()));
281 xercesc::DOMNode* runNumberNode = getNode (runNumberTag_, runElement, 0);
282 if( !runNumberNode )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(runNumberTag_ )));
283 xercesc::DOMNode* runBeginTimestampNode = getNode (runBeginTimestampTag_, runElement, 0);
284 if( !runBeginTimestampNode )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(runBeginTimestampTag_ )));
285 xercesc::DOMNode* locationNode = getNode (locationTag_, runElement, 0);
286 if( !locationNode )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(locationTag_ )));
294 xercesc::DOMElement* datasetElement = getElement(datasetTag_, elementRoot, 0);
295 if( !datasetElement )
throw(std::runtime_error( std::string(
"The document is missing the mandatory tag: ") + XML_TO_STRING(datasetTag_ )));
299 xercesc::DOMNode* partNode = getNode (partTag_, datasetElement, 0);
300 xercesc::DOMNode* nameLabelNode = getNode (nameLabelTag_, partNode, 0);
301 xercesc::DOMNode* kindOfPartNode = getNode (kindOfPartTag_, partNode, 0);
304 xercesc::DOMNode* versionNode = getNode (versionTag_, datasetElement, 0);
306 if(versionNode->getFirstChild() == 0)
308 throw(std::runtime_error( std::string(
"Missing version tag: ") + XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())));
312 char tmpVersionStr[100];
313 sprintf(tmpVersionStr,
"%d", version.version());
314 __MOUT__ << version <<
"-" << XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()) << std::endl;
315 if(strcmp(tmpVersionStr,XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())) != 0)
316 throw(std::runtime_error( std::string(
"Mis-matched version tag: ") + XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()) +
317 " vs " + tmpVersionStr));
320 configuration.getViewP()->setVersion(XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()));
322 xercesc::DOMNode* commentDescriptionNode = getNode (commentDescriptionTag_, datasetElement, 0);
323 if(commentDescriptionNode->getFirstChild() != 0)
324 configuration.getViewP()->setComment(XML_TO_CHAR(commentDescriptionNode->getFirstChild()->getNodeValue()));
326 xercesc::DOMNode* createdByUserNode = getNode (createdByUserTag_, datasetElement, 0);
327 if(createdByUserNode->getFirstChild() != 0)
328 configuration.getViewP()->setAuthor(XML_TO_CHAR(createdByUserNode->getFirstChild()->getNodeValue()));
332 xercesc::DOMNodeList* dataNodeList = datasetElement->getElementsByTagName(dataTag_);
335 throw(std::runtime_error( std::string(
"Can't find ") + XML_TO_STRING(dataTag_) +
" tag!"));
340 if(!dataNodeList->getLength())
342 __SS__ <<
"Must be non-empty data set!";
343 throw std::runtime_error(ss.str());
348 configuration.getViewP()->resizeDataView(dataNodeList->getLength(), configuration.getView().getNumberOfColumns());
350 for( XMLSize_t row = 0; row < dataNodeList->getLength(); row++ )
353 xercesc::DOMNodeList* columnNodeList = dataNodeList->item(row)->getChildNodes();
354 unsigned int colNumber = 0;
357 for( XMLSize_t col = 0; col < columnNodeList->getLength(); col++ )
361 if( !columnNodeList->item(col)->getNodeType() || columnNodeList->item(col)->getNodeType() != xercesc::DOMNode::ELEMENT_NODE )
364 xercesc::DOMElement* columnElement =
dynamic_cast< xercesc::DOMElement*
>( columnNodeList->item(col) );
366 if( configuration.getView().getColumnInfo(colNumber).getStorageName() != XML_TO_STRING(columnElement->getTagName()))
368 std::stringstream error;
369 error << __COUT_HDR__ << std::endl
370 <<
"The column number " << colNumber
371 <<
" named " << configuration.getView().getColumnInfo(colNumber).getStorageName()
372 <<
" defined in the view " << configuration.getView().getTableName()
373 <<
" doesn't match the file column order, since the "
374 << colNumber+1 << (colNumber==0?
"st":(colNumber==1?
"nd":(colNumber==2?
"rd":
"th")))
375 <<
" element found in the file at " << XML_TO_CHAR(dataTag_) <<
" tag number " << row
376 <<
" is " << XML_TO_CHAR(columnElement->getTagName());
377 mf::LogError(__FILE__) << error.str();
378 throw(std::runtime_error( error.str() ));
386 configuration.getViewP()->setValueAsString(
387 XML_TO_STRING(columnNodeList->item(col)->getFirstChild()->getNodeValue())
395 catch( xercesc::XMLException& e )
397 __MOUT__ <<
"Error parsing file: " << configFile << std::endl;
398 std::ostringstream errBuf;
399 errBuf <<
"Error parsing file: " << XML_TO_CHAR(e.getMessage()) << std::flush;
402 __MOUT__ <<
"Done with configuration file: " << configFile << std::endl;
411 std::string ConfigurationHandler::writeXML(
const ConfigurationBase& configuration)
415 std::string configFile = getXMLFileName(configuration,configuration.getViewVersion());
418 xercesc::DOMImplementation* implementation = xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML(
"Core"));
419 if (implementation != 0)
424 xercesc::DOMDocument* document = implementation->createDocument(
429 xercesc::DOMElement* rootElement = document->getDocumentElement();
430 rootElement->setAttribute(CONVERT_TO_XML(
"xmlns:xsi"),CONVERT_TO_XML(
"http://www.w3.org/2001/XMLSchema-instance"));
431 rootElement->setAttribute(CONVERT_TO_XML(
"xsi:noNamespaceSchemaLocation"),CONVERT_TO_XML(
"ConfigurationBase.xsd"));
435 xercesc::DOMElement* headerElement = document->createElement(headerTag_);
436 rootElement->appendChild(headerElement);
439 xercesc::DOMElement* typeElement = document->createElement(typeTag_);
440 headerElement->appendChild(typeElement);
442 xercesc::DOMElement* extensionTableNameElement = document->createElement(extensionTableNameTag_);
443 typeElement->appendChild(extensionTableNameElement);
444 xercesc::DOMText* extensionTableNameValue = document->createTextNode(CONVERT_TO_XML(configuration.getView().getTableName().c_str()));
445 extensionTableNameElement->appendChild(extensionTableNameValue);
447 xercesc::DOMElement* nameElement = document->createElement(nameTag_);
448 typeElement->appendChild(nameElement);
449 xercesc::DOMText* nameValue = document->createTextNode(CONVERT_TO_XML(configuration.getConfigurationName().c_str()));
450 nameElement->appendChild(nameValue);
454 xercesc::DOMElement* runElement = document->createElement(runTag_);
455 headerElement->appendChild(runElement);
457 xercesc::DOMElement* runTypeElement = document->createElement(runTypeTag_);
458 runElement->appendChild(runTypeElement);
459 xercesc::DOMText* runTypeValue = document->createTextNode(CONVERT_TO_XML(configuration.getConfigurationName().c_str()));
460 runTypeElement->appendChild(runTypeValue);
462 xercesc::DOMElement* runNumberElement = document->createElement(runNumberTag_);
463 runElement->appendChild(runNumberElement);
464 xercesc::DOMText* runNumberValue = document->createTextNode(CONVERT_TO_XML(
"1"));
465 runNumberElement->appendChild(runNumberValue);
467 xercesc::DOMElement* runBeginTimestampElement = document->createElement(runBeginTimestampTag_);
468 runElement->appendChild(runBeginTimestampElement);
469 xercesc::DOMText* runBeginTimestampValue = document->createTextNode(CONVERT_TO_XML(TimeFormatter::getTime().c_str()));
470 runBeginTimestampElement->appendChild(runBeginTimestampValue);
472 xercesc::DOMElement* locationElement = document->createElement(locationTag_);
473 runElement->appendChild(locationElement);
474 xercesc::DOMText* locationValue = document->createTextNode(CONVERT_TO_XML(
"CERN P5"));
475 locationElement->appendChild(locationValue);
479 xercesc::DOMElement* datasetElement = document->createElement(datasetTag_);
480 rootElement->appendChild(datasetElement);
482 xercesc::DOMElement* partElement = document->createElement(partTag_);
483 datasetElement->appendChild(partElement);
485 xercesc::DOMElement* nameLabelElement = document->createElement(nameLabelTag_);
486 partElement->appendChild(nameLabelElement);
487 xercesc::DOMText* nameLabelValue = document->createTextNode(CONVERT_TO_XML(
"CMS--ROOT"));
488 nameLabelElement->appendChild(nameLabelValue);
490 xercesc::DOMElement* kindOfPartElement = document->createElement(kindOfPartTag_);
491 partElement->appendChild(kindOfPartElement);
492 xercesc::DOMText* kindOfPartValue = document->createTextNode(CONVERT_TO_XML(
"Detector ROOT"));
493 kindOfPartElement->appendChild(kindOfPartValue);
495 xercesc::DOMElement* versionElement = document->createElement(versionTag_);
496 datasetElement->appendChild(versionElement);
497 xercesc::DOMText* versionValue = document->createTextNode(CONVERT_TO_XML(configuration.getView().getVersion().version()));
498 versionElement->appendChild(versionValue);
500 xercesc::DOMElement* commentDescriptionElement = document->createElement(commentDescriptionTag_);
501 datasetElement->appendChild(commentDescriptionElement);
502 xercesc::DOMText* commentDescriptionValue = document->createTextNode(CONVERT_TO_XML(configuration.getView().getComment().c_str()));
503 commentDescriptionElement->appendChild(commentDescriptionValue);
505 xercesc::DOMElement* createdByUserElement = document->createElement(createdByUserTag_);
506 datasetElement->appendChild(createdByUserElement);
507 xercesc::DOMText* createdByUserValue = document->createTextNode(CONVERT_TO_XML(configuration.getView().getAuthor().c_str()));
508 createdByUserElement->appendChild(createdByUserValue);
511 for(
unsigned int row=0; row<configuration.getView().getNumberOfRows(); row++)
513 xercesc::DOMElement* dataElement = document->createElement(dataTag_);
514 datasetElement->appendChild(dataElement);
516 for(
unsigned int col=0; col<configuration.getView().getNumberOfColumns(); col++)
518 xercesc::DOMElement* element = document->createElement(CONVERT_TO_XML(configuration.getView().getColumnInfo(col).getStorageName().c_str()));
519 dataElement->appendChild(element);
520 xercesc::DOMText* value = document->createTextNode(CONVERT_TO_XML(configuration.getView().getDataView()[row][col].c_str()));
521 element->appendChild(value);
525 outputXML(document, configFile);
529 catch (
const xercesc::OutOfMemoryException&)
531 XERCES_STD_QUALIFIER cerr <<
"OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
534 catch (
const xercesc::DOMException& e)
536 XERCES_STD_QUALIFIER cerr <<
"DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl;
539 catch(
const xercesc::XMLException& e)
541 std::string message = XML_TO_STRING(e.getMessage());
542 __MOUT__ <<
"Error Message: " << message << std::endl;
548 XERCES_STD_QUALIFIER cerr <<
"An error occurred creating the document" << XERCES_STD_QUALIFIER endl;
554 XERCES_STD_QUALIFIER cerr <<
"Requested implementation is not supported" << XERCES_STD_QUALIFIER endl;
565 void ConfigurationHandler::outputXML(xercesc::DOMDocument* pmyDOMDocument, std::string fileName)
567 std::string directory = fileName.substr(0,fileName.rfind(
"/")+1);
568 __MOUT__ <<
"Saving Configuration to " << fileName <<
" in directory: " << directory << std::endl;
570 mkdir(directory.c_str(), 0755);
574 xercesc::DOMImplementation *implementation = xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML(
"LS"));
576 #if _XERCES_VERSION >= 30000
578 xercesc::DOMLSSerializer* serializer = ((xercesc::DOMImplementationLS*)implementation)->createLSSerializer();
582 if (serializer->getDomConfig()->canSetParameter(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true))
583 serializer->getDomConfig()->setParameter(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true);
591 xercesc::XMLFormatTarget* formatTarget =
new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName));
594 xercesc::DOMLSOutput* output = ((xercesc::DOMImplementationLS*)implementation)->createLSOutput();
597 output->setByteStream(formatTarget);
600 serializer->write(pmyDOMDocument, output);
603 xercesc::DOMWriter *serializer = ((xercesc::DOMImplementationLS*)implementation)->createDOMWriter();
605 serializer->setFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint,
true);
617 xercesc::XMLFormatTarget* formatTarget =
new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName.c_str()));
620 serializer->writeNode(formatTarget, *pmyDOMDocument);
625 serializer->release();
629 #if _XERCES_VERSION >= 30000
634 __MOUT__ <<
"Done writing " << std::endl;
638 std::string ConfigurationHandler::writeXML(
const ConfigurationBase* configuration)
640 return writeXML(*configuration);
646 std::stringstream fileName;
647 fileName << getXMLDir(&configuration)
649 << configuration.getConfigurationName() <<
"_v" << version <<
".xml";
650 return fileName.str();
655 std::string ConfigurationHandler::getXMLDir(
const ConfigurationBase* configuration)
657 return std::string(getenv(
"CONFIGURATION_DATA_PATH")) +
'/' + configuration->getConfigurationName() +
'/';