DDLParser is the main class of Detector Description Language Parser. More...

#include <DDLParser.h>

Public Types
typedef std::map< int, std::pair< std::string, std::string > >	FileNameHolder

typedef XERCES_CPP_NAMESPACE::SAX2XMLReader	SAX2XMLReader

Public Member Functions
void	clearFiles ()
	Clear the file list - see Warning! More...

	DDLParser (DDCompactView &cpv)
	Constructor MUST associate a DDCompactView storage. More...

	DDLParser ()=delete

DDLSAX2FileHandler *	getDDLSAX2FileHandler ()
	To get the parent this class allows access to the handler. More...

SAX2XMLReader *	getXMLParser ()
	Get the SAX2Parser from the DDLParser. USE WITH CAUTION. Set your own handler, etc. More...

int	parse (const DDLDocumentProvider &dp)
	Parse all files. Return is meaningless. More...

void	parse (const std::vector< unsigned char > &ablob, unsigned int bsize)

bool	parseOneFile (const std::string &filename)
	Process a single files. More...

	~DDLParser ()
	Destructor terminates the XMLPlatformUtils (as required by Xerces) More...

Private Member Functions
std::string const	extractFileName (const std::string &fullname)

std::string const	getNameSpace (const std::string &fname)

size_t	isFound (const std::string &filename)
	Is the file already known by the DDLParser? Returns 0 if not found, and index if found. More...

bool	isParsed (const std::string &filename)
	Is the file already parsed? More...

void	parseFile (const int &numtoproc)
	Parse File. Just to hold some common looking code. More...

Private Attributes
DDCompactView &	cpv_
	reference to storage More...

std::string	currFileName_
	Which file is currently being processed. More...

DDLElementRegistry *	elementRegistry_

DDLSAX2Handler *	errHandler_

DDLSAX2ExpressionHandler *	expHandler_

DDLSAX2FileHandler *	fileHandler_

FileNameHolder	fileNames_
	List of files to be processed, obtained from the DDLDocumentProvider. More...

size_t	nFiles_
	Number of files + 1. More...

std::map< int, bool >	parsed_
	Parse status of a given file. More...

SAX2XMLReader *	SAX2Parser_
	SAX2XMLReader is one way of parsing. More...

Detailed Description

DDLParser is the main class of Detector Description Language Parser.

Author: Michael Case

DDLParser.h - description

begin: Mon Oct 22 2001 email: case@.nosp@m.ucdh.nosp@m.ep.uc.nosp@m.davi.nosp@m.s.edu

Singleton which controls the parsing of XML files (DDL). It guarantees that a given filename will only be parsed once regardless of its path. It now relies on a DDLDocumentProvider class which provides a list of file names and URLs to be parsed.

It uses the Xerces C++ Parser from the Apache Group straight-forwardly. One main thing to note is that only one DDLParser can ever be made. This allows for sub-components of the parser to easily find out information from the parser during run-time.

There is an interface to parse just one file. If one uses this method and does not use the default DDLDocumentProvider user is responsible for also setting the DDRootDef.

Modification: 2003-02-13: Michael Case, Stepan Wynhoff and Martin Liendl 2003-02-24: same. DDLParser will use DDLDocumentProvider (abstract). One of these and will be defaulted to DDLConfiguration. This will read the "configuration.xml" file provided and will be used by the Parser to "get" the files. 2005-11-13: Michael Case removed some of the un-necessary methods that were deprecated. 2010-01 to 2010-04 sometime: Michael Case removed singleton-ness. MUST have a DDCompactView to refer to and no more default constructor at the moment. 2010-07-29: removed DDLConfiguration; use FIPConfiguration, it is easier. for CMSSW Framework example see XMLIdealGeometryESSource (different DDLDocumentProvider completely

Definition at line 63 of file DDLParser.h.

Member Typedef Documentation

typedef std::map<int, std::pair<std::string, std::string> > DDLParser::FileNameHolder

Definition at line 67 of file DDLParser.h.

typedef XERCES_CPP_NAMESPACE::SAX2XMLReader DDLParser::SAX2XMLReader

Definition at line 65 of file DDLParser.h.

Constructor & Destructor Documentation

DDLParser::DDLParser ( DDCompactView & cpv )

Constructor MUST associate a DDCompactView storage.

Definition at line 22 of file DDLParser.cc.

References elementRegistry_, errHandler_, expHandler_, fileHandler_, SAX2Parser_, and cms::concurrency::xercesInitialize().

                                        : cpv_(cpv), nFiles_(0) {
   cms::concurrency::xercesInitialize();
   SAX2Parser_ = XMLReaderFactory::createXMLReader();
 
   SAX2Parser_->setFeature(XMLUni::fgSAX2CoreValidation, false);  // optional
   SAX2Parser_->setFeature(XMLUni::fgSAX2CoreNameSpaces, false);  // optional
 
   elementRegistry_ = new DDLElementRegistry();
   expHandler_ = new DDLSAX2ExpressionHandler(cpv, *elementRegistry_);
   fileHandler_ = new DDLSAX2FileHandler(cpv, *elementRegistry_);
   errHandler_ = new DDLSAX2Handler();
   SAX2Parser_->setErrorHandler(errHandler_);
   SAX2Parser_->setContentHandler(fileHandler_);
 }

DDLParser::DDLParser ( )

delete

DDLParser::~DDLParser ( void )

Destructor terminates the XMLPlatformUtils (as required by Xerces)

Definition at line 38 of file DDLParser.cc.

References elementRegistry_, errHandler_, expHandler_, fileHandler_, and cms::concurrency::xercesTerminate().

                           {
   // clean up and leave
   delete expHandler_;
   delete fileHandler_;
   delete errHandler_;
   delete elementRegistry_;
   cms::concurrency::xercesTerminate();
 }

Member Function Documentation

void DDLParser::clearFiles ( void )

Clear the file list - see Warning!

This could result in mangled geometry if the Core has not been cleared.

Definition at line 208 of file DDLParser.cc.

References fileNames_, and parsed_.

Referenced by XMLIdealMagneticFieldGeometryESProducer::produce(), and magneticfield::VolumeBasedMagneticFieldESProducerFromDB::produce().

                                {
   fileNames_.clear();
   parsed_.clear();
 }

std::string const DDLParser::extractFileName ( const std::string & fullname )

private

Definition at line 213 of file DDLParser.cc.

Referenced by parse(), and parseOneFile().

                                                                     {
   return (fullname.substr(fullname.rfind('/') + 1));
 }

DDLSAX2FileHandler * DDLParser::getDDLSAX2FileHandler ( void )

To get the parent this class allows access to the handler.

In order to retrieve the name of the parent element from DDLSAX2Handlers.

Definition at line 53 of file DDLParser.cc.

References fileHandler_.

Referenced by XMLIdealGeometryESSource::produce(), XMLIdealMagneticFieldGeometryESProducer::produce(), and magneticfield::VolumeBasedMagneticFieldESProducerFromDB::produce().

53 { return fileHandler_; }

DDLParser::fileHandler_

DDLSAX2FileHandler * fileHandler_

Definition: DDLParser.h:154

std::string const DDLParser::getNameSpace ( const std::string & fname )

private

Definition at line 217 of file DDLParser.cc.

References dqmiolumiharvest::j, runTheMatrix::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parse(), and parseOneFile().

                                                               {
   size_t j = 0;
   std::string ret = "";
   while (j < fname.size() && fname[j] != '.')
     ++j;
   if (j < fname.size() && fname[j] == '.')
     ret = fname.substr(0, j);
   return ret;
 }

SAX2XMLReader * DDLParser::getXMLParser ( void )

Get the SAX2Parser from the DDLParser. USE WITH CAUTION. Set your own handler, etc.

This method allows external "users" to use the current DDLParser on their own. by giving them access to the SAX2XMLReader. This may not be a good idea! The reason that I

Definition at line 51 of file DDLParser.cc.

References SAX2Parser_.

Referenced by FIPConfiguration::readConfig().

51 { return SAX2Parser_; }

DDLParser::SAX2Parser_

SAX2XMLReader * SAX2Parser_

SAX2XMLReader is one way of parsing.

Definition: DDLParser.h:151

size_t DDLParser::isFound ( const std::string & filename )

private

Is the file already known by the DDLParser? Returns 0 if not found, and index if found.

Definition at line 55 of file DDLParser.cc.

References fileNames_, and mps_fire::i.

Referenced by isParsed(), parse(), and parseOneFile().

                                                    {
   FileNameHolder::const_iterator it = fileNames_.begin();
   size_t i = 1;
   bool foundFile = false;
   while (it != fileNames_.end() && !foundFile) {
     if (it->second.first == filename) {
       foundFile = true;
     } else
       ++i;
     ++it;
   }
   if (foundFile)
     return i;
   return 0;
 }

bool DDLParser::isParsed ( const std::string & filename )

private

Is the file already parsed?

Definition at line 71 of file DDLParser.cc.

References newFWLiteAna::found, isFound(), and parsed_.

                                                   {
   size_t found = isFound(filename);
   if (found)
     return parsed_[found];
   return false;
 }

int DDLParser::parse ( const DDLDocumentProvider & dp )

Parse all files. Return is meaningless.

Definition at line 123 of file DDLParser.cc.

References cms::cuda::assert(), DDLSAX2FileHandler::createDDConstants(), currFileName_, expHandler_, extractFileName(), fileHandler_, fileNames_, DDLDocumentProvider::getFileList(), getNameSpace(), DDLDocumentProvider::getURLList(), mps_fire::i, isFound(), LogDebug, nFiles_, parsed_, parseFile(), SAX2Parser_, DDLSAX2Handler::setNameSpace(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by output(), XMLIdealGeometryESSource::produce(), XMLIdealMagneticFieldGeometryESProducer::produce(), magneticfield::VolumeBasedMagneticFieldESProducerFromDB::produce(), and testParser().

                                                   {
   edm::LogInfo("DDLParser") << "Start Parsing.  Validation is set off for the time being." << std::endl;
   // prep for pass 1 through DDD XML
   SAX2Parser_->setFeature(XMLUni::fgSAX2CoreValidation, false);
   SAX2Parser_->setFeature(XMLUni::fgSAX2CoreNameSpaces, false);
 
   //  This need be only done once, so might as well to it here.
   size_t fileIndex = 0;
   std::vector<std::string> fullFileName;
   const std::vector<std::string>& fileList = dp.getFileList();
   const std::vector<std::string>& urlList = dp.getURLList();
 
   for (; fileIndex < fileList.size(); ++fileIndex) {
     std::string ts = urlList[fileIndex];
     std::string tf = fileList[fileIndex];
     if (!ts.empty()) {
       if (ts[ts.size() - 1] == '/') {
         fullFileName.emplace_back(ts + tf);
       } else {
         fullFileName.emplace_back(ts + "/" + tf);
       }
     } else {
       fullFileName.emplace_back(tf);
     }
   }
 
   for (const auto& fnit : fullFileName) {
     size_t foundFile = isFound(extractFileName(fnit));
 
     if (!foundFile) {
       pair<std::string, std::string> pss;
       pss.first = extractFileName(fnit);
       pss.second = fnit;
       fileNames_[nFiles_++] = pss;
       parsed_[nFiles_ - 1] = false;
     }
   }
 
   // Start processing the files found in the config file.
   assert(fileNames_.size() == nFiles_);
 
   // PASS 1:  This was added later (historically) to implement the DDD
   // requirement for Expressions.
 
   SAX2Parser_->setContentHandler(expHandler_);
   for (size_t i = 0; i < nFiles_; ++i) {
     if (!parsed_[i]) {
       currFileName_ = fileNames_[i].second;
       expHandler_->setNameSpace(getNameSpace(extractFileName(currFileName_)));
       parseFile(i);
     }
   }
   expHandler_->createDDConstants();
 
   // PASS 2:
 
   SAX2Parser_->setContentHandler(fileHandler_);
 
   // No need to validate (regardless of user's doValidation
   // because the files have already been validated on the first pass.
   // This optimization suggested by Martin Liendl.
 
   // Process files again.
   for (size_t i = 0; i < nFiles_; ++i) {
     if (!parsed_[i]) {
       currFileName_ = fileNames_[i].second;
       fileHandler_->setNameSpace(getNameSpace(extractFileName(currFileName_)));
       parseFile(i);
       parsed_[i] = true;
       pair<std::string, std::string> namePair = fileNames_[i];
       LogDebug("DDLParser") << "Completed parsing file " << namePair.second << std::endl;
     }
   }
   return 0;
 }

void DDLParser::parse	(	const std::vector< unsigned char > &	ablob,
		unsigned int	bsize
	)

Definition at line 116 of file DDLParser.cc.

References DDLSAX2FileHandler::createDDConstants(), expHandler_, and SAX2Parser_.

                                                                                {
   char* dummy(nullptr);
   MemBufInputSource mbis(&*ablob.begin(), bsize, dummy);
   SAX2Parser_->parse(mbis);
   expHandler_->createDDConstants();
 }

void DDLParser::parseFile ( const int & numtoproc )

private

Parse File. Just to hold some common looking code.

Definition at line 199 of file DDLParser.cc.

References currFileName_, fileNames_, alignmentValidation::fname, parsed_, SAX2Parser_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parse(), and parseOneFile().

                                               {
   if (!parsed_[numtoproc]) {
     const std::string& fname = fileNames_[numtoproc].second;
 
     currFileName_ = fname;
     SAX2Parser_->parse(currFileName_.c_str());
   }
 }

bool DDLParser::parseOneFile ( const std::string & filename )

Process a single files.

This method allows a user to add to an existing DDD by parsing a new XML file. Ideally, these would be in addition to an existing DDD configuration which was processed using Parse(...).

The idea is based on whether users decide that the configuration will only hold "standard geometry files" and that any ancillary parameter files, filters and so forth will be unknown to the main configuration file. For me, this seems to go against the principle of knowing what files are relevant because now, there is no central way to find out (externally) what XML files generate the DDD in memory.

On the other hand, if on any run, a dumpFileList is run, then the user will at least know what files were used from where in a given run.

2007-04-06: filename is now relative to src directory of checkout (or share). edm:FileInPath used internally.

Definition at line 80 of file DDLParser.cc.

References DDLSAX2FileHandler::createDDConstants(), currFileName_, expHandler_, extractFileName(), fileHandler_, lut2db_cfg::filename, fileNames_, personalPlayback::fp, edm::FileInPath::fullPath(), getNameSpace(), isFound(), LogDebug, nFiles_, parsed_, parseFile(), SAX2Parser_, DDLSAX2Handler::setNameSpace(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by CompareDDCompactViews::beginRun().

                                                       {
   std::string filename = extractFileName(fullname);
   edm::FileInPath fp(fullname);
   std::string absoluteFileName = fp.fullPath();
   size_t foundFile = isFound(filename);
   if (!foundFile) {
     pair<std::string, std::string> pss;
     pss.first = filename;
     pss.second = absoluteFileName;  //url+filename;
     int fIndex = nFiles_;
     fileNames_[nFiles_] = pss;
     ++nFiles_;
     parsed_[fIndex] = false;
 
     currFileName_ = fileNames_[fIndex].second;
 
     SAX2Parser_->setContentHandler(expHandler_);
     expHandler_->setNameSpace(getNameSpace(filename));
 
     LogDebug("DDLParser") << "ParseOneFile() Parsing: " << fileNames_[fIndex].second << std::endl;
     parseFile(fIndex);
     expHandler_->createDDConstants();
     // PASS 2:
 
     SAX2Parser_->setContentHandler(fileHandler_);
     fileHandler_->setNameSpace(getNameSpace(extractFileName(currFileName_)));
     parseFile(fIndex);
     parsed_[fIndex] = true;
   } else  // was found and is parsed...
   {
     return true;
   }
   return false;
 }