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...

std::string	extractFileName (std::string fullname)

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

std::vector< std::string >	getFileList ()
	Return list of files. More...

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

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

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...

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...

Protected Member Functions
	DDLParser ()

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...

DDLSAX2Handler *	errHandler_

DDLSAX2ExpressionHandler *	expHandler_

DDLSAX2FileHandler *	fileHandler_

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

int	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 64 of file DDLParser.h.

Member Typedef Documentation

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

Definition at line 70 of file DDLParser.h.

typedef XERCES_CPP_NAMESPACE::SAX2XMLReader DDLParser::SAX2XMLReader

Definition at line 68 of file DDLParser.h.

Constructor & Destructor Documentation

DDLParser::DDLParser ( DDCompactView & cpv )

Constructor MUST associate a DDCompactView storage.

Definition at line 30 of file DDLParser.cc.

References DCOUT_V, 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
   // Specify other parser features, e.g.
   //  SAX2Parser_->setFeature(XMLUni::fgXercesSchemaFullChecking, false);
   
   expHandler_  = new DDLSAX2ExpressionHandler(cpv);
   fileHandler_ = new DDLSAX2FileHandler(cpv);
   errHandler_  = new DDLSAX2Handler();
   SAX2Parser_->setErrorHandler(errHandler_); 
   SAX2Parser_->setContentHandler(fileHandler_); 
   
   DCOUT_V('P', "DDLParser::DDLParser(): new (and only) DDLParser"); 
 }

DDLParser::DDLParser ( )

protected

DDLParser::~DDLParser ( void )

Destructor terminates the XMLPlatformUtils (as required by Xerces)

Definition at line 52 of file DDLParser.cc.

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

 { 
   // clean up and leave
   delete expHandler_;
   delete fileHandler_;
   delete errHandler_;
   cms::concurrency::xercesTerminate();
   DCOUT_V('P', "DDLParser::~DDLParser(): destruct DDLParser"); 
 }

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 373 of file DDLParser.cc.

References fileNames_, and parsed_.

Referenced by XMLIdealMagneticFieldGeometryESProducer::produce(), and XMLIdealGeometryESProducer::produce().

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

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

Definition at line 380 of file DDLParser.cc.

References run_regression::ret, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parse(), and parseOneFile().

 {
   std::string ret = "";
   size_t bit = fullname.rfind('/');
   if ( bit < fullname.size() - 2 ) {
     ret=fullname.substr(bit+1);
   }
   return ret;
 }

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 73 of file DDLParser.cc.

References fileHandler_.

Referenced by XMLIdealGeometryESSource::produce(), XMLIdealMagneticFieldGeometryESProducer::produce(), and XMLIdealGeometryESProducer::produce().

 { 
   return fileHandler_; 
 }

std::vector< std::string > DDLParser::getFileList ( void )

Return list of files.

Definition at line 193 of file DDLParser.cc.

References fileNames_.

 {
   std::vector<std::string> flist;
   for (FileNameHolder::const_iterator fit = fileNames_.begin(); fit != fileNames_.end(); ++fit)
   {
     flist.push_back(fit->second.first); // was .second (mec: 2003:02:19
   }
   return flist;
 }

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

Definition at line 391 of file DDLParser.cc.

References j, run_regression::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 67 of file DDLParser.cc.

References SAX2Parser_.

Referenced by FIPConfiguration::readConfig().

 {
   return SAX2Parser_;
 }

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

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

Definition at line 79 of file DDLParser.cc.

References fileNames_, and 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 )

Is the file already parsed?

Definition at line 99 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 204 of file DDLParser.cc.

References currFileName_, DCOUT, DDLSAX2FileHandler::dumpElementTypeCounter(), expHandler_, extractFileName(), fileHandler_, fileNames_, DDLDocumentProvider::getFileList(), getNameSpace(), DDLDocumentProvider::getURLList(), i, isFound(), LogDebug, nFiles_, parsed_, parseFile(), SAX2Parser_, DDLSAX2Handler::setNameSpace(), findQualityFiles::size, and AlCaHLTBitMon_QueryRunRegistry::string.

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

 {
   //  edm::LogInfo ("DDLParser") << "Start Parsing.  Validation is set to " << dp.doValidation() << "." << std::endl;
   edm::LogInfo ("DDLParser") << "Start Parsing.  Validation is set off for the time being." << std::endl;
   // prep for pass 1 through DDD XML
   //   // Since this block does nothing for CMSSW right now, I have taken it all out
   //   This clean-up involves interface changes such as the removal of doValidation() everywhere (OR NOT 
   //   if I decide to keep it for other testing reasons.)
   //    if (dp.doValidation())
   //      { 
   // //       DCOUT_V('P', "WARNING:  PARSER VALIDATION IS TURNED OFF REGARDLESS OF <Schema... ELEMENT");
   //   SAX2Parser_->setFeature(XMLUni::fgSAX2CoreValidation, true);
   //   SAX2Parser_->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
   // //       //  SAX2Parser_->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
   //      }
   //    else
   //     {
   SAX2Parser_->setFeature(XMLUni::fgSAX2CoreValidation, false);
   SAX2Parser_->setFeature(XMLUni::fgSAX2CoreNameSpaces, false);
   //       //  SAX2Parser_->setFeature(XMLUni::fgXercesSchemaFullChecking, false);
 
   //     }
 
   //  This need be only done once, so might as well to it here.
   size_t fileIndex = 0;
   std::vector<std::string> fullFileName;
 
   for (; fileIndex < (dp.getFileList()).size(); ++fileIndex)
   { 
     std::string ts = dp.getURLList()[fileIndex];
     std::string tf = dp.getFileList()[fileIndex];
     if ( ts.size() > 0 ) {
       if ( ts[ts.size() - 1] == '/') {
     fullFileName.push_back( ts + tf );
       } else {
     fullFileName.push_back( ts + "/" + tf );
       }
     } else {
       fullFileName.push_back( tf );
     }
   }
 
   for (std::vector<std::string>::const_iterator fnit = fullFileName.begin(); 
        fnit != fullFileName.end();
        ++fnit)
   {
     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.
   
   // PASS 1:  This was added later (historically) to implement the DDD
   // requirement for Expressions.
   DCOUT('P', "DDLParser::parse(): PASS1: Just before setting Xerces content and error handlers... ");
   
   
   // in cleaning up try-catch blocks 2007-06-26 I decided to remove
   // this because of CMSSW rules. but keep the commented way I used to
   // do it...
   //   DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! try
   //     {
   SAX2Parser_->setContentHandler(expHandler_);
   for (size_t i = 0; i < fileNames_.size(); ++i)
   {
     if (!parsed_[i])
     {
       currFileName_ = fileNames_[i].second;
       //          std::cout << "currFileName = " << currFileName_ << std::endl;
       expHandler_->setNameSpace( getNameSpace(extractFileName(currFileName_)) );
       //          std::cout << "2)  namespace = " << getNameSpace(extractFileName(currFileName_)) << std::endl;
       parseFile(i);
     }
   }
   expHandler_->dumpElementTypeCounter();
   //     }
   //   DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! catch (const XMLException& toCatch) {
   //     edm::LogInfo ("DDLParser") << "\nPASS1: XMLException while processing files... \n"
   //     << "Exception message is: \n"
   //     << StrX(toCatch.getMessage()) << "\n" ;
   //     cms::concurrency::xercesTerminate();
   //     // FIX use this after DEPRECATED stuff removed:    throw(DDException("See XML Exception above"));
   //     return -1;
   //   }
   // PASS 2:
 
   DCOUT('P', "DDLParser::parse(): PASS2: Just before setting Xerces content and error handlers... ");
 
   // in cleaning up try-catch blocks 2007-06-26 I decided to remove
   // this because of CMSSW rules. but keep the commented way I used to
   // do it...
   //   DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! try
   //     {
   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.
   //       SAX2Parser_->setFeature(StrX("http://xml.org/sax/features/validation"), false);   // optional
   //       SAX2Parser_->setFeature(StrX("http://xml.org/sax/features/namespaces"), false);   // optional
   //       SAX2Parser_->setFeature(StrX("http://apache.org/xml/features/validation/dynamic"), false);
 
 
   // Process files again.
   for (size_t i = 0; i < fileNames_.size(); ++i)
   {
     //    seal::SealTimer t("DDLParser: parsing all elements of file " +fileNames_[i].first);
     if (!parsed_[i]) {
       currFileName_ = fileNames_[i].second;
       //        std::cout << "currFileName = " << currFileName_ << std::endl;
       fileHandler_->setNameSpace( getNameSpace(extractFileName(currFileName_)) );
       //        std::cout << "3)  namespace = " << getNameSpace(extractFileName(currFileName_)) << std::endl;
       parseFile(i);
       parsed_[i] = true;
       pair<std::string, std::string> namePair = fileNames_[i];
       LogDebug ("DDLParser") << "Completed parsing file " << namePair.second << std::endl;
     }
   }
   //     }
   //   DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! catch (const XMLException& toCatch) {
   //     edm::LogError ("DDLParser") << "\nPASS2: XMLException while processing files... \n"
   //     << "Exception message is: \n"
   //     << StrX(toCatch.getMessage()) << "\n" ;
   //     cms::concurrency::xercesTerminate();
   //     return -1;
   //   }
   return 0;
 }

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

Definition at line 185 of file DDLParser.cc.

References SAX2Parser_.

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

void DDLParser::parseFile ( const int & numtoproc )

protected

Parse File. Just to hold some common looking code.

Definition at line 342 of file DDLParser.cc.

References currFileName_, DCOUT, fileNames_, first, alignmentValidation::fname, parsed_, SAX2Parser_, edm::second(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by parse(), and parseOneFile().

 {
   if (!parsed_[numtoproc])
   {
     const std::string & fname = fileNames_[numtoproc].second;
 
     // in cleaning up try-catch blocks 2007-06-26 I decided to remove
     // this because of CMSSW rules. but keep the commented way I used to
     // do it...
     //       DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! try
     //  {
     currFileName_ = fname;
     SAX2Parser_->parse(currFileName_.c_str());
     //  }
     //       DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! catch (const XMLException& toCatch)
     //  {
     //    std::string e("\nWARNING: DDLParser::parseFile, File: '");
     //    e += currFileName_ + "'\n"
     //      + "Exception message is: \n"
     //      + std::string(StrX(toCatch.getMessage()).localForm()) + "\n";
     //    throw(DDException(e));
     //  }
   }
   else
   {
     DCOUT('P', "\nWARNING: File " + fileNames_[numtoproc].first 
       + " has already been processed as " + fileNames_[numtoproc].second);
   }
 }

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 110 of file DDLParser.cc.

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

 {
   //  std::string filename = expHandler_->extractFileName(fullname);
   std::string filename = extractFileName(fullname);
   //  std::cout << "parseOneFile - fullname = " << fullname << std::endl;
   //  std::cout << "parseOneFile - filename = " << filename << std::endl;
   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;
 
     // in cleaning up try-catch blocks 2007-06-26 I decided to remove
     // this because of CMSSW rules. but keep the commented way I used to
     // do it...
     //       DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! try
     //         {
     SAX2Parser_->setContentHandler(expHandler_);
     expHandler_->setNameSpace( getNameSpace(filename) );
     //    std::cout << "0) namespace = " << getNameSpace(filename) << std::endl;
     LogDebug ("DDLParser") << "ParseOneFile() Parsing: " << fileNames_[fIndex].second << std::endl;
     parseFile ( fIndex );
 
     //         }
     //       DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! catch (const XMLException& toCatch) {
     //         edm::LogError ("DDLParser") << "\nDDLParser::ParseOneFile, PASS1: XMLException while processing files... \n"
     //              << "Exception message is: \n"
     //              << StrX(toCatch.getMessage()) << "\n" ;
     //         cms::concurrency::xercesTerminate();
     //         throw (DDException("  See XMLException above. "));
     //       }
 
     // PASS 2:
 
     DCOUT_V('P', "DDLParser::ParseOneFile(): PASS2: Just before setting Xerces content and error handlers... ");
 
     //       DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! try
     //         {
 
     SAX2Parser_->setContentHandler(fileHandler_);
     //      std::cout << "currFileName = " << currFileName_ << std::endl;
     fileHandler_->setNameSpace( getNameSpace(extractFileName(currFileName_)) );
     //      std::cout << "1)  namespace = " << getNameSpace(currFileName_) << std::endl;
     parseFile ( fIndex );
     parsed_[fIndex] = true;
 
     //         }
     //       DO NOT UNCOMMENT FOR ANY RELEASE; ONLY FOR DEBUGGING! catch (const XMLException& toCatch) {
     //         edm::LogError ("DDLParser") << "\nDDLParser::ParseOneFile, PASS2: XMLException while processing files... \n"
     //              << "Exception message is: \n"
     //              << StrX(toCatch.getMessage()) << "\n" ;
     //         cms::concurrency::xercesTerminate();
     //         throw (DDException("  See XMLException above."));
     //       }
   }
   else // was found and is parsed...
   {
     DCOUT('P', " WARNING: DDLParser::ParseOneFile() file " + filename
       + " was already parsed as " + fileNames_[foundFile].second);
     return true;
   }
   return false;
 }