DDLParser Class Reference

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 ()=delete
	DDLParser (DDCompactView &cpv)
	Constructor MUST associate a DDCompactView storage. More...
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
const std::string	extractFileName (const std::string &fullname)
const std::string	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

FileNameHolder

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

Definition at line 67 of file DDLParser.h.

SAX2XMLReader

typedef XERCES_CPP_NAMESPACE::SAX2XMLReader DDLParser::SAX2XMLReader

Definition at line 65 of file DDLParser.h.

Constructor & Destructor Documentation

DDLParser() [1/2]

DDLParser::DDLParser

(

DDCompactView &

cpv

)

Constructor MUST associate a DDCompactView storage.

Definition at line 22 of file DDLParser.cc.

                                       : 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_);
}

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

DDLParser() [2/2]

DDLParser::DDLParser ( )

delete

~DDLParser()

DDLParser::~DDLParser

(

void

)

Destructor terminates the XMLPlatformUtils (as required by Xerces)

Definition at line 38 of file DDLParser.cc.

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

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

Member Function Documentation

clearFiles()

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.

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

References fileNames_, and parsed_.

extractFileName()

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

private

Definition at line 213 of file DDLParser.cc.

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

Referenced by parse(), and parseOneFile().

getDDLSAX2FileHandler()

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.

{ return fileHandler_; }

References fileHandler_.

getNameSpace()

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

private

Definition at line 217 of file DDLParser.cc.

                                                              {
  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;
}

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

Referenced by parse(), and parseOneFile().

getXMLParser()

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.

{ return SAX2Parser_; }

References SAX2Parser_.

Referenced by FIPConfiguration::readConfig().

isFound()

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.

                                                   {
  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;
}

References corrVsCorr::filename, fileNames_, and mps_fire::i.

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

isParsed()

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

private

Is the file already parsed?

Definition at line 71 of file DDLParser.cc.

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

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

parse() [1/2]

int DDLParser::parse

(

const DDLDocumentProvider &

dp

)

Parse all files. Return is meaningless.

Definition at line 123 of file DDLParser.cc.

                                                  {
  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;
}

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

Referenced by output(), and testParser().

parse() [2/2]

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

Definition at line 116 of file DDLParser.cc.

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

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

parseFile()

void DDLParser::parseFile ( const int &  numtoproc )

private

Parse File. Just to hold some common looking code.

Definition at line 199 of file DDLParser.cc.

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

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

Referenced by parse(), and parseOneFile().

parseOneFile()

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.

                                                      {
  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;
}

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

Referenced by CompareDDCompactViews::beginRun().

Member Data Documentation

cpv_

DDCompactView& DDLParser::cpv_

private

reference to storage

Definition at line 136 of file DDLParser.h.

currFileName_

std::string DDLParser::currFileName_

private

Which file is currently being processed.

Definition at line 148 of file DDLParser.h.

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

elementRegistry_

DDLElementRegistry* DDLParser::elementRegistry_

private

Definition at line 153 of file DDLParser.h.

Referenced by DDLParser(), and ~DDLParser().

errHandler_

DDLSAX2Handler* DDLParser::errHandler_

private

Definition at line 156 of file DDLParser.h.

Referenced by DDLParser(), and ~DDLParser().

expHandler_

DDLSAX2ExpressionHandler* DDLParser::expHandler_

private

Definition at line 155 of file DDLParser.h.

Referenced by DDLParser(), parse(), parseOneFile(), and ~DDLParser().

fileHandler_

DDLSAX2FileHandler* DDLParser::fileHandler_

private

Definition at line 154 of file DDLParser.h.

Referenced by DDLParser(), getDDLSAX2FileHandler(), parse(), parseOneFile(), and ~DDLParser().

fileNames_

FileNameHolder DDLParser::fileNames_

private

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

Definition at line 139 of file DDLParser.h.

Referenced by clearFiles(), isFound(), parse(), parseFile(), and parseOneFile().

nFiles_

size_t DDLParser::nFiles_

private

Number of files + 1.

Definition at line 145 of file DDLParser.h.

Referenced by parse(), and parseOneFile().

parsed_

std::map<int, bool> DDLParser::parsed_

private

Parse status of a given file.

Definition at line 142 of file DDLParser.h.

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

SAX2Parser_

SAX2XMLReader* DDLParser::SAX2Parser_

private

SAX2XMLReader is one way of parsing.

Definition at line 151 of file DDLParser.h.

Referenced by DDLParser(), getXMLParser(), parse(), parseFile(), and parseOneFile().