$treeview $search $mathjax $extrastylesheet
otsdaq
v2_03_00
$projectbrief
|
$projectbrief
|
$searchbox |
00001 #include "otsdaq-core/ConfigurationInterface/ConfigurationHandler.h" 00002 #include "otsdaq-core/ConfigurationInterface/TimeFormatter.h" 00003 00004 #include "otsdaq-core/Macros/CoutMacros.h" 00005 #include "otsdaq-core/XmlUtilities/ConvertFromXML.h" 00006 #include "otsdaq-core/XmlUtilities/ConvertToXML.h" 00007 #include "otsdaq-core/XmlUtilities/DOMTreeErrorReporter.h" 00008 00009 #include <xercesc/dom/DOMElement.hpp> 00010 #include <xercesc/dom/DOMImplementation.hpp> 00011 #include <xercesc/dom/DOMImplementationRegistry.hpp> 00012 #include <xercesc/dom/DOMLSOutput.hpp> 00013 #include <xercesc/dom/DOMLSSerializer.hpp> 00014 #include <xercesc/dom/DOMNodeList.hpp> 00015 #include <xercesc/dom/DOMText.hpp> 00016 #include <xercesc/parsers/XercesDOMParser.hpp> 00017 #include <xercesc/util/XMLUni.hpp> 00018 //#include <xercesc/dom/DOMWriter.hpp> 00019 00020 #include <xercesc/framework/LocalFileFormatTarget.hpp> 00021 #include <xercesc/util/OutOfMemoryException.hpp> 00022 00023 #include <sys/types.h> 00024 #include <iostream> 00025 #include <sstream> 00026 #include <stdexcept> 00027 00028 #include <errno.h> 00029 #include <sys/stat.h> 00030 00031 #include "otsdaq-core/TableCore/TableBase.h" 00032 00033 using namespace ots; 00034 00035 #undef __COUT_HDR__ 00036 #define __COUT_HDR__ "ConfigHandler" 00037 00038 // The tag values must be given after the XML platform is initialized so they are defined 00039 // in initPlatform 00040 XMLCh* ConfigurationHandler::rootTag_ = 0; 00041 XMLCh* ConfigurationHandler::headerTag_ = 0; 00042 XMLCh* ConfigurationHandler::typeTag_ = 0; 00043 XMLCh* ConfigurationHandler::extensionTableNameTag_ = 0; 00044 XMLCh* ConfigurationHandler::nameTag_ = 0; 00045 XMLCh* ConfigurationHandler::runTag_ = 0; 00046 XMLCh* ConfigurationHandler::runTypeTag_ = 0; 00047 XMLCh* ConfigurationHandler::runNumberTag_ = 0; 00048 XMLCh* ConfigurationHandler::runBeginTimestampTag_ = 0; 00049 XMLCh* ConfigurationHandler::locationTag_ = 0; 00050 XMLCh* ConfigurationHandler::datasetTag_ = 0; 00051 XMLCh* ConfigurationHandler::versionTag_ = 0; 00052 XMLCh* ConfigurationHandler::commentDescriptionTag_ = 0; 00053 XMLCh* ConfigurationHandler::createdByUserTag_ = 0; 00054 XMLCh* ConfigurationHandler::partTag_ = 0; 00055 XMLCh* ConfigurationHandler::nameLabelTag_ = 0; 00056 XMLCh* ConfigurationHandler::kindOfPartTag_ = 0; 00057 XMLCh* ConfigurationHandler::dataTag_ = 0; 00058 00059 //============================================================================== 00060 ConfigurationHandler::ConfigurationHandler(void) {} 00061 00062 //============================================================================== 00063 ConfigurationHandler::~ConfigurationHandler(void) {} 00064 00065 //============================================================================== 00066 void ConfigurationHandler::initPlatform(void) 00067 { 00068 try 00069 { 00070 xercesc::XMLPlatformUtils::Initialize(); // Initialize Xerces infrastructure 00071 } 00072 catch(xercesc::XMLException& e) 00073 { 00074 __MOUT_ERR__ << "XML toolkit initialization error: " 00075 << XML_TO_CHAR(e.getMessage()) << std::endl; 00076 // throw exception here to return ERROR_XERCES_INIT 00077 } 00078 00079 rootTag_ = xercesc::XMLString::transcode("ROOT"); 00080 headerTag_ = xercesc::XMLString::transcode("HEADER"); 00081 typeTag_ = xercesc::XMLString::transcode("TYPE"); 00082 extensionTableNameTag_ = xercesc::XMLString::transcode("EXTENSION_TABLE_NAME"); 00083 nameTag_ = xercesc::XMLString::transcode("NAME"); 00084 runTag_ = xercesc::XMLString::transcode("RUN"); 00085 runTypeTag_ = xercesc::XMLString::transcode("RUN_TYPE"); 00086 runNumberTag_ = xercesc::XMLString::transcode("RUN_NUMBER"); 00087 runBeginTimestampTag_ = xercesc::XMLString::transcode("RUN_BEGIN_TIMESTAMP"); 00088 locationTag_ = xercesc::XMLString::transcode("LOCATION"); 00089 datasetTag_ = xercesc::XMLString::transcode("DATA_SET"); 00090 versionTag_ = xercesc::XMLString::transcode("VERSION"); 00091 commentDescriptionTag_ = xercesc::XMLString::transcode("COMMENT_DESCRIPTION"); 00092 createdByUserTag_ = xercesc::XMLString::transcode("CREATED_BY_USER"); 00093 partTag_ = xercesc::XMLString::transcode("PART"); 00094 nameLabelTag_ = xercesc::XMLString::transcode("NAME_LABEL"); 00095 kindOfPartTag_ = xercesc::XMLString::transcode("KIND_OF_PART"); 00096 dataTag_ = xercesc::XMLString::transcode("DATA"); 00097 } 00098 00099 //============================================================================== 00100 void ConfigurationHandler::terminatePlatform(void) 00101 { 00102 try 00103 { 00104 xercesc::XMLString::release(&rootTag_); 00105 xercesc::XMLString::release(&headerTag_); 00106 xercesc::XMLString::release(&typeTag_); 00107 xercesc::XMLString::release(&extensionTableNameTag_); 00108 xercesc::XMLString::release(&nameTag_); 00109 xercesc::XMLString::release(&runTag_); 00110 xercesc::XMLString::release(&runTypeTag_); 00111 xercesc::XMLString::release(&runNumberTag_); 00112 xercesc::XMLString::release(&runBeginTimestampTag_); 00113 xercesc::XMLString::release(&locationTag_); 00114 xercesc::XMLString::release(&datasetTag_); 00115 xercesc::XMLString::release(&versionTag_); 00116 xercesc::XMLString::release(&commentDescriptionTag_); 00117 xercesc::XMLString::release(&createdByUserTag_); 00118 xercesc::XMLString::release(&partTag_); 00119 xercesc::XMLString::release(&nameLabelTag_); 00120 xercesc::XMLString::release(&kindOfPartTag_); 00121 xercesc::XMLString::release(&dataTag_); 00122 } 00123 catch(...) 00124 { 00125 __MOUT_ERR__ << "Unknown exception encountered in TagNames destructor" 00126 << std::endl; 00127 } 00128 00129 try 00130 { 00131 xercesc::XMLPlatformUtils::Terminate(); // Terminate after release of memory 00132 } 00133 catch(xercesc::XMLException& e) 00134 { 00135 __MOUT_ERR__ << "XML ttolkit teardown error: " << XML_TO_CHAR(e.getMessage()) 00136 << std::endl; 00137 } 00138 } 00139 00140 //============================================================================== 00141 bool ConfigurationHandler::validateNode(XMLCh* tagName, 00142 xercesc::DOMNode* node, 00143 const std::string& expectedValue) 00144 { 00145 if(node->getFirstChild() == 0) 00146 { 00147 __COUT__ << "Tag " << XML_TO_CHAR(tagName) << " doesn't have a value!" 00148 << std::endl; 00149 return false; 00150 } 00151 00152 if(XML_TO_STRING(node->getFirstChild()->getNodeValue()) != expectedValue) 00153 { 00154 __COUT__ << "The tag " << XML_TO_CHAR(tagName) << " with value " 00155 << XML_TO_CHAR(node->getFirstChild()->getNodeValue()) 00156 << " doesn't match the expected value " << expectedValue << std::endl; 00157 return false; 00158 } 00159 00160 return true; 00161 } 00162 00163 //============================================================================== 00164 xercesc::DOMNode* ConfigurationHandler::getNode(XMLCh* tagName, 00165 xercesc::DOMNode* parent, 00166 unsigned int itemNumber) 00167 { 00168 return getNode(tagName, dynamic_cast<xercesc::DOMElement*>(parent), itemNumber); 00169 } 00170 00171 //============================================================================== 00172 xercesc::DOMNode* ConfigurationHandler::getNode(XMLCh* tagName, 00173 xercesc::DOMElement* parent, 00174 unsigned int itemNumber) 00175 { 00176 xercesc::DOMNodeList* nodeList = parent->getElementsByTagName(tagName); 00177 00178 if(!nodeList) 00179 { 00180 throw(std::runtime_error(std::string("Can't find ") + XML_TO_STRING(tagName) + 00181 " tag!")); 00182 __COUT__ << (std::string("Can't find ") + XML_TO_STRING(tagName) + " tag!") 00183 << std::endl; 00184 } 00185 00186 // __COUT__<< "Name: " << XML_TO_CHAR(nodeList->item(itemNumber)->getNodeName()) 00187 // << std::endl; if( nodeList->item(itemNumber)->getFirstChild() != 0 ) 00188 // __COUT__<< "Value: " << 00189 // XML_TO_CHAR(nodeList->item(itemNumber)->getFirstChild()->getNodeValue()) << 00190 // std::endl; 00191 return nodeList->item(itemNumber); 00192 } 00193 00194 //============================================================================== 00195 xercesc::DOMElement* ConfigurationHandler::getElement(XMLCh* tagName, 00196 xercesc::DOMNode* parent, 00197 unsigned int itemNumber) 00198 { 00199 return dynamic_cast<xercesc::DOMElement*>(getNode(tagName, parent, itemNumber)); 00200 } 00201 00202 //============================================================================== 00203 xercesc::DOMElement* ConfigurationHandler::getElement(XMLCh* tagName, 00204 xercesc::DOMElement* parent, 00205 unsigned int itemNumber) 00206 { 00207 return dynamic_cast<xercesc::DOMElement*>(getNode(tagName, parent, itemNumber)); 00208 } 00209 00210 //============================================================================== 00211 void ConfigurationHandler::readXML(TableBase* configuration, TableVersion version) 00212 { 00213 readXML(*configuration, version); 00214 } 00215 00216 //============================================================================== 00217 void ConfigurationHandler::readXML(TableBase& configuration, TableVersion version) 00218 { 00219 initPlatform(); 00220 std::string configFile = getXMLFileName(configuration, version); 00221 00222 __COUT__ << "Reading: " << configFile << std::endl; 00223 __COUT__ << "Into View with Table Name: " << configuration.getViewP()->getTableName() 00224 << std::endl; 00225 __COUT__ << "Into View with version: " << configuration.getViewP()->getVersion() 00226 << " and version-to-read: " << version << std::endl; 00227 00228 struct stat fileStatus; 00229 // stat returns -1 on error, status in errno 00230 if(stat(configFile.c_str(), &fileStatus) < 0) 00231 { 00232 __COUT__ << "Error reading path: " << configFile << std::endl; 00233 std::stringstream ss; 00234 ss << __COUT_HDR__; 00235 if(errno == ENOENT) 00236 ss << ("Path file_name does not exist."); 00237 else if(errno == ENOTDIR) 00238 ss << ("A component of the path is not a directory."); 00239 else if(errno == ELOOP) 00240 ss << ("Too many symbolic links encountered while traversing the path."); 00241 else if(errno == EACCES) 00242 ss << ("Permission denied."); 00243 else if(errno == ENAMETOOLONG) 00244 ss << ("File name too long."); 00245 else 00246 ss << ("File can not be read."); 00247 ss << std::endl; 00248 __COUT_ERR__ << ss.str(); 00249 __SS_THROW__; 00250 } 00251 00252 xercesc::XercesDOMParser* parser = new xercesc::XercesDOMParser; 00253 00254 // Configure DOM parser. 00255 parser->setValidationScheme(xercesc::XercesDOMParser::Val_Auto); // Val_Never 00256 parser->setDoNamespaces(true); 00257 parser->setDoSchema( 00258 false); // RAR set to false to get rid of "error reading primary document *.xsd" 00259 // uses if true: 00260 // rootElement->setAttribute(CONVERT_TO_XML("xsi:noNamespaceSchemaLocation"),CONVERT_TO_XML("TableBase.xsd")); 00261 parser->useCachedGrammarInParse(false); 00262 DOMTreeErrorReporter* errorHandler = new DOMTreeErrorReporter(); 00263 parser->setErrorHandler(errorHandler); 00264 00265 //__COUT__ << configFile << std::endl; 00266 try 00267 { 00268 //__COUT__ << "Parsing" << std::endl; 00269 parser->parse(configFile.c_str()); 00270 //__COUT__ << "Parsed" << std::endl; 00271 00272 // no need to free this pointer - owned by the parent parser object 00273 xercesc::DOMDocument* document = parser->getDocument(); 00274 00275 // Get the top-level element: Name is "root". No attributes for "root" 00276 xercesc::DOMElement* elementRoot = document->getDocumentElement(); 00277 00278 if(!elementRoot) 00279 throw(std::runtime_error("empty XML document")); 00280 //<HEADER> 00281 //__COUT__ << "Reading header" << std::endl; 00282 xercesc::DOMNode* headerNode = getNode(headerTag_, elementRoot, 0); 00283 if(!headerNode) 00284 throw(std::runtime_error( 00285 std::string("The document is missing the mandatory tag: ") + 00286 XML_TO_STRING(headerTag_))); 00287 00288 //<TYPE> 00289 //__COUT__ << "Reading type" << std::endl; 00290 xercesc::DOMElement* typeElement = getElement(typeTag_, headerNode, 0); 00291 if(!typeElement) 00292 throw(std::runtime_error( 00293 std::string("The document is missing the mandatory tag: ") + 00294 XML_TO_STRING(typeTag_))); 00295 xercesc::DOMNode* extensionTableNameNode = 00296 getNode(extensionTableNameTag_, typeElement, 0); 00297 if(!validateNode(extensionTableNameTag_, 00298 extensionTableNameNode, 00299 configuration.getView().getTableName())) 00300 throw(std::runtime_error( 00301 std::string("The document is missing the mandatory tag: ") + 00302 XML_TO_STRING(extensionTableNameTag_))); 00303 xercesc::DOMNode* nameNode = getNode(nameTag_, typeElement, 0); 00304 if(!validateNode(nameTag_, nameNode, configuration.getTableName())) 00305 throw(std::runtime_error( 00306 std::string("The document is missing the mandatory tag: ") + 00307 XML_TO_STRING(nameTag_))); 00308 00309 //__COUT__ << configFile << std::endl; 00310 //</TYPE> 00311 //<RUN> 00312 //__COUT__ << "Reading run" << std::endl; 00313 xercesc::DOMElement* runElement = getElement(runTag_, headerNode, 0); 00314 if(!runElement) 00315 throw(std::runtime_error( 00316 std::string("The document is missing the mandatory tag: ") + 00317 XML_TO_STRING(runTag_))); 00318 xercesc::DOMNode* runTypeNode = getNode(runTypeTag_, runElement, 0); 00319 assert(validateNode(runTypeTag_, runTypeNode, configuration.getTableName())); 00320 xercesc::DOMNode* runNumberNode = getNode(runNumberTag_, runElement, 0); 00321 if(!runNumberNode) 00322 throw(std::runtime_error( 00323 std::string("The document is missing the mandatory tag: ") + 00324 XML_TO_STRING(runNumberTag_))); 00325 xercesc::DOMNode* runBeginTimestampNode = 00326 getNode(runBeginTimestampTag_, runElement, 0); 00327 if(!runBeginTimestampNode) 00328 throw(std::runtime_error( 00329 std::string("The document is missing the mandatory tag: ") + 00330 XML_TO_STRING(runBeginTimestampTag_))); 00331 xercesc::DOMNode* locationNode = getNode(locationTag_, runElement, 0); 00332 if(!locationNode) 00333 throw(std::runtime_error( 00334 std::string("The document is missing the mandatory tag: ") + 00335 XML_TO_STRING(locationTag_))); 00336 00337 //__COUT__ << configFile << std::endl; 00338 //</RUN> 00339 //</HEADER> 00340 00341 //<DATA_SET> 00342 //__COUT__ << "Reading Data Set" << std::endl; 00343 xercesc::DOMElement* datasetElement = getElement(datasetTag_, elementRoot, 0); 00344 if(!datasetElement) 00345 throw(std::runtime_error( 00346 std::string("The document is missing the mandatory tag: ") + 00347 XML_TO_STRING(datasetTag_))); 00348 00349 // <PART> 00350 //__COUT__ << "Reading Part" << std::endl; 00351 xercesc::DOMNode* partNode = getNode(partTag_, datasetElement, 0); 00352 xercesc::DOMNode* nameLabelNode = getNode(nameLabelTag_, partNode, 0); 00353 xercesc::DOMNode* kindOfPartNode = getNode(kindOfPartTag_, partNode, 0); 00354 00355 // </PART> 00356 xercesc::DOMNode* versionNode = getNode(versionTag_, datasetElement, 0); 00357 00358 if(versionNode->getFirstChild() == 0) // if version tag is missing 00359 { 00360 throw(std::runtime_error( 00361 std::string("Missing version tag: ") + 00362 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()))); 00363 } 00364 else // else verify version tag matches parameter version 00365 { 00366 char tmpVersionStr[100]; 00367 sprintf(tmpVersionStr, "%d", version.version()); 00368 __COUT__ << version << "-" 00369 << XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()) 00370 << std::endl; 00371 if(strcmp(tmpVersionStr, 00372 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())) != 0) 00373 throw(std::runtime_error( 00374 std::string("Mis-matched version tag: ") + 00375 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue()) + " vs " + 00376 tmpVersionStr)); 00377 } 00378 // version is valid 00379 configuration.getViewP()->setVersion( 00380 XML_TO_CHAR(versionNode->getFirstChild()->getNodeValue())); 00381 00382 xercesc::DOMNode* commentDescriptionNode = 00383 getNode(commentDescriptionTag_, datasetElement, 0); 00384 if(commentDescriptionNode->getFirstChild() != 0) 00385 configuration.getViewP()->setComment( 00386 XML_TO_CHAR(commentDescriptionNode->getFirstChild()->getNodeValue())); 00387 00388 xercesc::DOMNode* createdByUserNode = 00389 getNode(createdByUserTag_, datasetElement, 0); 00390 if(createdByUserNode->getFirstChild() != 0) 00391 configuration.getViewP()->setAuthor( 00392 XML_TO_CHAR(createdByUserNode->getFirstChild()->getNodeValue())); 00393 00394 //<DATA> 00395 //__COUT__ << "Reading Data" << std::endl; 00396 xercesc::DOMNodeList* dataNodeList = 00397 datasetElement->getElementsByTagName(dataTag_); 00398 00399 if(!dataNodeList) 00400 throw(std::runtime_error(std::string("Can't find ") + 00401 XML_TO_STRING(dataTag_) + " tag!")); 00402 00403 //__COUT__ << "Number of data nodes: " << dataNodeList->getLength() << std::endl; 00404 // First I need to setup the data container which is a [row][col] matrix where 00405 // each <dataTag_> is a row and row 0 has the names of the column which will go 00406 // in the columnInfo container 00407 if(!dataNodeList->getLength()) // I must have at least 1 data! 00408 { 00409 __SS__ << "Must be non-empty data set!"; 00410 __SS_THROW__; 00411 } 00412 00413 //__COUT__ << configuration.getView().getColumnsInfo().size() << std::endl; 00414 // First I can build the matrix and then fill it since I know the number of rows 00415 // and columns 00416 configuration.getViewP()->resizeDataView( 00417 dataNodeList->getLength(), configuration.getView().getNumberOfColumns()); 00418 00419 for(XMLSize_t row = 0; row < dataNodeList->getLength(); row++) 00420 { 00421 // DOMElement* dataElement = dynamic_cast< xercesc::DOMElement* >( 00422 // dataNodeList->item(row) ); 00423 xercesc::DOMNodeList* columnNodeList = 00424 dataNodeList->item(row)->getChildNodes(); 00425 unsigned int colNumber = 0; 00426 00427 //__COUT__ << "Row: " << row << " w " << columnNodeList->getLength() << 00428 // std::endl; 00429 for(XMLSize_t col = 0; col < columnNodeList->getLength(); col++) 00430 { 00431 //__COUT__ << "Col: " << col << std::endl; 00432 00433 if(!columnNodeList->item(col)->getNodeType() || 00434 columnNodeList->item(col)->getNodeType() != 00435 xercesc::DOMNode::ELEMENT_NODE) // true is not 0 && is element 00436 continue; 00437 00438 xercesc::DOMElement* columnElement = 00439 dynamic_cast<xercesc::DOMElement*>(columnNodeList->item(col)); 00440 00441 if(configuration.getView().getColumnInfo(colNumber).getStorageName() != 00442 XML_TO_STRING(columnElement->getTagName())) 00443 { 00444 std::stringstream error; 00445 error << __COUT_HDR__ << std::endl 00446 << "The column number " << colNumber << " named " 00447 << configuration.getView() 00448 .getColumnInfo(colNumber) 00449 .getStorageName() 00450 << " defined in the view " 00451 << configuration.getView().getTableName() 00452 << " doesn't match the file column order, since the " 00453 << colNumber + 1 00454 << (colNumber == 0 00455 ? "st" 00456 : (colNumber == 1 ? "nd" 00457 : (colNumber == 2 ? "rd" : "th"))) 00458 << " element found in the file at " << XML_TO_CHAR(dataTag_) 00459 << " tag number " << row << " is " 00460 << XML_TO_CHAR(columnElement->getTagName()); 00461 __MOUT_ERR__ << error.str(); 00462 throw(std::runtime_error(error.str())); 00463 } 00464 00465 // if( row==0 ) 00466 // { 00467 // configuration.getViewP()->getDataViewP()->push_back(vector<string>(dataNodeList->getLength()+1));//# 00468 // of data + names 00469 // (*configuration.getViewP()->getDataViewP())[colNumber][0] 00470 // = XML_TO_STRING(columnElement->getTagName()); 00471 // } 00472 configuration.getViewP()->setValueAsString( 00473 XML_TO_STRING( 00474 columnNodeList->item(col)->getFirstChild()->getNodeValue()), 00475 row, 00476 colNumber); 00477 //(*configuration.getViewP()->getDataViewP())[row][colNumber] = 00478 // XML_TO_STRING(columnNodeList->item(col)->getFirstChild()->getNodeValue()); 00479 ++colNumber; 00480 } 00481 } 00482 } 00483 catch(xercesc::XMLException& e) 00484 { 00485 __COUT__ << "Error parsing file: " << configFile << std::endl; 00486 std::ostringstream errBuf; 00487 errBuf << "Error parsing file: " << XML_TO_CHAR(e.getMessage()) << std::flush; 00488 } 00489 00490 __COUT__ << "Done with configuration file: " << configFile << std::endl; 00491 00492 delete parser; 00493 delete errorHandler; 00494 terminatePlatform(); 00495 } 00496 00497 //============================================================================== 00498 std::string ConfigurationHandler::writeXML(const TableBase& configuration) 00499 { 00500 initPlatform(); 00501 00502 std::string configFile = getXMLFileName( 00503 configuration, 00504 configuration 00505 .getViewVersion()); // std::string(getenv("CONFIGURATION_DATA_PATH")) + "/" + 00506 // configuration.getTableName() + "_write.xml"; 00507 00508 xercesc::DOMImplementation* implementation = 00509 xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML("Core")); 00510 if(implementation != 0) 00511 { 00512 try 00513 { 00514 //<ROOT> 00515 xercesc::DOMDocument* document = 00516 implementation->createDocument(0, // root element namespace URI. 00517 rootTag_, // root element name 00518 0); // document type object (DTD). 00519 00520 xercesc::DOMElement* rootElement = document->getDocumentElement(); 00521 rootElement->setAttribute( 00522 CONVERT_TO_XML("xmlns:xsi"), 00523 CONVERT_TO_XML("http://www.w3.org/2001/XMLSchema-instance")); 00524 rootElement->setAttribute( 00525 CONVERT_TO_XML("xsi:noNamespaceSchemaLocation"), 00526 CONVERT_TO_XML( 00527 "TableBase.xsd")); // configFile.substr(configFile.rfind("/")+1).c_str())); 00528 // //put the file name here..? TableBase.xsd")); 00529 //${OTSDAQ_DIR}/otsdaq/ConfigurationDataFormats/TableInfo.xsd 00530 // now moved to $USER_DATA/TableInfo/TableInfo.xsd 00531 00532 //<HEADER> 00533 xercesc::DOMElement* headerElement = document->createElement(headerTag_); 00534 rootElement->appendChild(headerElement); 00535 00536 //<TYPE> 00537 xercesc::DOMElement* typeElement = document->createElement(typeTag_); 00538 headerElement->appendChild(typeElement); 00539 00540 xercesc::DOMElement* extensionTableNameElement = 00541 document->createElement(extensionTableNameTag_); 00542 typeElement->appendChild(extensionTableNameElement); 00543 xercesc::DOMText* extensionTableNameValue = document->createTextNode( 00544 CONVERT_TO_XML(configuration.getView().getTableName().c_str())); 00545 extensionTableNameElement->appendChild(extensionTableNameValue); 00546 00547 xercesc::DOMElement* nameElement = document->createElement(nameTag_); 00548 typeElement->appendChild(nameElement); 00549 xercesc::DOMText* nameValue = document->createTextNode( 00550 CONVERT_TO_XML(configuration.getTableName().c_str())); 00551 nameElement->appendChild(nameValue); 00552 //</TYPE> 00553 00554 //<RUN> 00555 xercesc::DOMElement* runElement = document->createElement(runTag_); 00556 headerElement->appendChild(runElement); 00557 00558 xercesc::DOMElement* runTypeElement = document->createElement(runTypeTag_); 00559 runElement->appendChild(runTypeElement); 00560 xercesc::DOMText* runTypeValue = document->createTextNode( 00561 CONVERT_TO_XML(configuration.getTableName().c_str())); 00562 runTypeElement->appendChild(runTypeValue); 00563 00564 xercesc::DOMElement* runNumberElement = 00565 document->createElement(runNumberTag_); 00566 runElement->appendChild(runNumberElement); 00567 xercesc::DOMText* runNumberValue = document->createTextNode(CONVERT_TO_XML( 00568 "1")); // This is dynamic and need to be created when I write the file 00569 runNumberElement->appendChild(runNumberValue); 00570 00571 xercesc::DOMElement* runBeginTimestampElement = 00572 document->createElement(runBeginTimestampTag_); 00573 runElement->appendChild(runBeginTimestampElement); 00574 xercesc::DOMText* runBeginTimestampValue = document->createTextNode( 00575 CONVERT_TO_XML(TimeFormatter::getTime().c_str())); // This is dynamic and 00576 // need to be created 00577 // when I write the 00578 // files 00579 runBeginTimestampElement->appendChild(runBeginTimestampValue); 00580 00581 xercesc::DOMElement* locationElement = document->createElement(locationTag_); 00582 runElement->appendChild(locationElement); 00583 xercesc::DOMText* locationValue = document->createTextNode( 00584 CONVERT_TO_XML("CERN P5")); // This is dynamic and need to be created 00585 // when I write the file 00586 locationElement->appendChild(locationValue); 00587 //</RUN> 00588 00589 xercesc::DOMElement* datasetElement = document->createElement(datasetTag_); 00590 rootElement->appendChild(datasetElement); 00591 //<PART> 00592 xercesc::DOMElement* partElement = document->createElement(partTag_); 00593 datasetElement->appendChild(partElement); 00594 00595 xercesc::DOMElement* nameLabelElement = 00596 document->createElement(nameLabelTag_); 00597 partElement->appendChild(nameLabelElement); 00598 xercesc::DOMText* nameLabelValue = 00599 document->createTextNode(CONVERT_TO_XML("CMS--ROOT")); 00600 nameLabelElement->appendChild(nameLabelValue); 00601 00602 xercesc::DOMElement* kindOfPartElement = 00603 document->createElement(kindOfPartTag_); 00604 partElement->appendChild(kindOfPartElement); 00605 xercesc::DOMText* kindOfPartValue = 00606 document->createTextNode(CONVERT_TO_XML("Detector ROOT")); 00607 kindOfPartElement->appendChild(kindOfPartValue); 00608 00609 xercesc::DOMElement* versionElement = document->createElement(versionTag_); 00610 datasetElement->appendChild(versionElement); 00611 xercesc::DOMText* versionValue = document->createTextNode( 00612 CONVERT_TO_XML(configuration.getView().getVersion().version())); 00613 versionElement->appendChild(versionValue); 00614 00615 xercesc::DOMElement* commentDescriptionElement = 00616 document->createElement(commentDescriptionTag_); 00617 datasetElement->appendChild(commentDescriptionElement); 00618 xercesc::DOMText* commentDescriptionValue = document->createTextNode( 00619 CONVERT_TO_XML(configuration.getView().getComment().c_str())); 00620 commentDescriptionElement->appendChild(commentDescriptionValue); 00621 00622 xercesc::DOMElement* createdByUserElement = 00623 document->createElement(createdByUserTag_); 00624 datasetElement->appendChild(createdByUserElement); 00625 xercesc::DOMText* createdByUserValue = document->createTextNode( 00626 CONVERT_TO_XML(configuration.getView().getAuthor().c_str())); 00627 createdByUserElement->appendChild(createdByUserValue); 00628 // for(TableView::iterator it=configuration.getView().begin(); 00629 // it!=configuration.getView().end(); it++) 00630 00631 for(unsigned int row = 0; row < configuration.getView().getNumberOfRows(); 00632 row++) 00633 { 00634 xercesc::DOMElement* dataElement = document->createElement(dataTag_); 00635 datasetElement->appendChild(dataElement); 00636 00637 for(unsigned int col = 0; 00638 col < configuration.getView().getNumberOfColumns(); 00639 col++) 00640 { 00641 xercesc::DOMElement* element = 00642 document->createElement(CONVERT_TO_XML(configuration.getView() 00643 .getColumnInfo(col) 00644 .getStorageName() 00645 .c_str())); 00646 dataElement->appendChild(element); 00647 xercesc::DOMText* value = document->createTextNode(CONVERT_TO_XML( 00648 configuration.getView().getDataView()[row][col].c_str())); 00649 element->appendChild(value); 00650 } 00651 } 00652 00653 outputXML(document, configFile); 00654 00655 document->release(); 00656 } 00657 catch(const xercesc::OutOfMemoryException&) 00658 { 00659 XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" 00660 << XERCES_STD_QUALIFIER endl; 00661 // errorCode = 5; 00662 } 00663 catch(const xercesc::DOMException& e) 00664 { 00665 XERCES_STD_QUALIFIER cerr << "DOMException code is: " << e.code 00666 << XERCES_STD_QUALIFIER endl; 00667 // errorCode = 2; 00668 } 00669 catch(const xercesc::XMLException& e) 00670 { 00671 std::string message = XML_TO_STRING(e.getMessage()); 00672 __COUT__ << "Error Message: " << message << std::endl; 00673 // return 1; 00674 return message; 00675 } 00676 catch(...) 00677 { 00678 XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" 00679 << XERCES_STD_QUALIFIER endl; 00680 // errorCode = 3; 00681 } 00682 } // (inpl != 0) 00683 else 00684 { 00685 XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" 00686 << XERCES_STD_QUALIFIER endl; 00687 // errorCode = 4; 00688 } 00689 00690 terminatePlatform(); 00691 return configFile; 00692 } 00693 00694 // return errorCode; 00695 00696 //============================================================================== 00697 void ConfigurationHandler::outputXML(xercesc::DOMDocument* pmyDOMDocument, 00698 std::string fileName) 00699 { 00700 std::string directory = fileName.substr(0, fileName.rfind("/") + 1); 00701 __COUT__ << "Saving XML to " << fileName << " in directory: " << directory 00702 << std::endl; 00703 00704 mkdir(directory.c_str(), 0755); 00705 00706 // Return the first registered implementation that has the desired features. In this 00707 // case, we are after a DOM implementation that has the LS feature... or Load/Save. 00708 // DOMImplementation *implementation = 00709 // DOMImplementationRegistry::getDOMImplementation(L"LS"); 00710 xercesc::DOMImplementation* implementation = 00711 xercesc::DOMImplementationRegistry::getDOMImplementation(CONVERT_TO_XML("LS")); 00712 00713 #if _XERCES_VERSION >= 30000 00714 // Create a DOMLSSerializer which is used to serialize a DOM tree into an XML 00715 // document. 00716 xercesc::DOMLSSerializer* serializer = 00717 ((xercesc::DOMImplementationLS*)implementation)->createLSSerializer(); 00718 00719 // Make the output more human readable by inserting line feeds. 00720 00721 if(serializer->getDomConfig()->canSetParameter( 00722 xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true)) 00723 serializer->getDomConfig()->setParameter( 00724 xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true); 00725 00726 // The end-of-line sequence of characters to be used in the XML being written out. 00727 // serializer->setNewLine(CONVERT_TO_XML("\r\n")); 00728 00729 // Convert the path into Xerces compatible XMLCh*. 00730 00731 // Specify the target for the XML output. 00732 xercesc::XMLFormatTarget* formatTarget = 00733 new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName)); 00734 00735 // Create a new empty output destination object. 00736 xercesc::DOMLSOutput* output = 00737 ((xercesc::DOMImplementationLS*)implementation)->createLSOutput(); 00738 00739 // Set the stream to our target. 00740 output->setByteStream(formatTarget); 00741 00742 // Write the serialized output to the destination. 00743 serializer->write(pmyDOMDocument, output); 00744 00745 #else 00746 xercesc::DOMWriter* serializer = 00747 ((xercesc::DOMImplementationLS*)implementation)->createDOMWriter(); 00748 00749 serializer->setFeature(xercesc::XMLUni::fgDOMWRTFormatPrettyPrint, true); 00750 00751 /* 00752 Choose a location for the serialized output. The 3 options are: 00753 1) StdOutFormatTarget (std output stream - good for debugging) 00754 2) MemBufFormatTarget (to Memory) 00755 3) LocalFileFormatTarget (save to file) 00756 (Note: You'll need a different header file for each one) 00757 */ 00758 // XMLFormatTarget* pTarget = new StdOutFormatTarget(); 00759 // Convert the path into Xerces compatible XMLCh*. 00760 00761 xercesc::XMLFormatTarget* formatTarget = 00762 new xercesc::LocalFileFormatTarget(CONVERT_TO_XML(fileName.c_str())); 00763 00764 // Write the serialized output to the target. 00765 serializer->writeNode(formatTarget, *pmyDOMDocument); 00766 00767 #endif 00768 00769 // Cleanup. 00770 serializer->release(); 00771 00772 delete formatTarget; 00773 00774 #if _XERCES_VERSION >= 30000 00775 00776 output->release(); 00777 00778 #endif 00779 __COUT__ << "Done writing " << std::endl; 00780 } 00781 00782 //============================================================================== 00783 std::string ConfigurationHandler::writeXML(const TableBase* configuration) 00784 { 00785 return writeXML(*configuration); 00786 } 00787 00788 //============================================================================== 00789 std::string ConfigurationHandler::getXMLFileName(const TableBase& configuration, 00790 TableVersion version) 00791 { 00792 std::stringstream fileName; 00793 fileName << getXMLDir(&configuration) << version << '/' 00794 << configuration.getTableName() << "_v" << version << ".xml"; 00795 return fileName.str(); 00796 } 00797 00798 //============================================================================== 00799 std::string ConfigurationHandler::getXMLDir(const TableBase* configuration) 00800 { 00801 return std::string(getenv("CONFIGURATION_DATA_PATH")) + '/' + 00802 configuration->getTableName() + '/'; 00803 }