FWXMLConfigParser Class Reference

#include <FWXMLConfigParser.h>

Inheritance diagram for FWXMLConfigParser:

Public Member Functions
FWConfiguration *	config (void)
void	data (const std::string &data) override
void	debug_config_state_machine (const char *where, const std::string &tag, int state)
void	endElement (const std::string &tag) override
	FWXMLConfigParser (std::istream &f)
void	pushConfig (Attributes &attributes)
void	startElement (const std::string &tag, Attributes &attributes) override
Public Member Functions inherited from SimpleSAXParser
void	parse (void)
	SimpleSAXParser (std::istream &f)
virtual	~SimpleSAXParser ()

Private Types
enum	STATES {   IN_BEGIN_DOCUMENT, IN_PUSHED_CONFIG, IN_POPPED_CONFIG, IN_BEGIN_STRING,   IN_STORED_STRING }

Private Attributes
std::vector< std::pair< std::string, FWConfiguration * > >	m_configs
std::string	m_currentConfigName
std::unique_ptr< FWConfiguration >	m_first
enum STATES	m_state

Additional Inherited Members
Public Types inherited from SimpleSAXParser
typedef std::vector< Attribute >	Attributes
enum	PARSER_STATES {   IN_DOCUMENT, IN_BEGIN_TAG, IN_DONE, IN_BEGIN_ELEMENT,   IN_ELEMENT_WHITESPACE, IN_END_ELEMENT, IN_ATTRIBUTE_KEY, IN_END_TAG,   IN_DATA, IN_BEGIN_ATTRIBUTE_VALUE, IN_STRING, IN_END_ATTRIBUTE_VALUE,   IN_STRING_ENTITY, IN_DATA_ENTITY }

Detailed Description

Helper class which reads the XML configuration and constructs the FWConfiguration classes.

State machine for the parser can be found by cut and pasting the following in graphviz.

digraph { IN_BEGIN_DOCUMENT->IN_PUSHED_CONFIG [label = "beginElement(config)"]

IN_PUSHED_CONFIG->IN_PUSHED_CONFIG [label = "beginElement(config)"] IN_PUSHED_CONFIG->IN_POPPED_CONFIG [label = "endElement(config)"] IN_PUSHED_CONFIG->IN_BEGIN_STRING [label = "beginElement(string)"]

IN_POPPED_CONFIG->IN_PUSHED_CONFIG [label = "beginElement(config)"] IN_POPPED_CONFIG->IN_POPPED_CONFIG [label = "endElement(config)"] IN_POPPED_CONFIG->DONE [label = "top level config popped"]

IN_BEGIN_STRING->IN_STORED_STRING [label = "data()"]; IN_BEGIN_STRING->IN_PUSHED_CONFIG [label = "endElement(string)"]

IN_STORED_STRING->IN_PUSHED_CONFIG [label = "endElement(string)"] }

Definition at line 32 of file FWXMLConfigParser.h.

Member Enumeration Documentation

STATES

enum FWXMLConfigParser::STATES

private

Enumerator
IN_BEGIN_DOCUMENT
IN_PUSHED_CONFIG
IN_POPPED_CONFIG
IN_BEGIN_STRING
IN_STORED_STRING

Definition at line 33 of file FWXMLConfigParser.h.

{ IN_BEGIN_DOCUMENT, IN_PUSHED_CONFIG, IN_POPPED_CONFIG, IN_BEGIN_STRING, IN_STORED_STRING };

Constructor & Destructor Documentation

FWXMLConfigParser()

FWXMLConfigParser::FWXMLConfigParser ( std::istream &  f )

inline

Definition at line 36 of file FWXMLConfigParser.h.

: SimpleSAXParser(f), m_state(IN_BEGIN_DOCUMENT), m_first(nullptr) {}

Member Function Documentation

config()

FWConfiguration* FWXMLConfigParser::config ( void  )

inline

The parsed configuration. Notice that the parser owns it and destroys it when destroyed.

Definition at line 132 of file FWXMLConfigParser.h.

{ return m_first.get(); }

References m_first.

data()

void FWXMLConfigParser::data ( const std::string &  data )

inlineoverridevirtual

Executes any transaction in the state machine which happens when the xml parser finds some data (i.e. text) between tags This is mainly used to handle <string> element contents but also whitespace between tags.

Reimplemented from SimpleSAXParser.

Definition at line 118 of file FWXMLConfigParser.h.

                                            {
    debug_config_state_machine("data", data, m_state);
    // We ignore whitespace but complain about any text which is not
    // in the <string> tag.
    if (m_state == IN_BEGIN_STRING) {
      m_configs.back().second->addValue(data);
      m_state = IN_STORED_STRING;
    } else if (strspn(data.c_str(), " \t\n") != data.size())
      throw ParserError("Unexpected text " + data);
  }

References debug_config_state_machine(), IN_BEGIN_STRING, IN_STORED_STRING, m_configs, and m_state.

debug_config_state_machine()

void FWXMLConfigParser::debug_config_state_machine ( const char *  where, const std::string &  tag, int  state  )

inline

Definition at line 134 of file FWXMLConfigParser.h.

                                                                                      {
#ifdef FW_CONFIG_PARSER_DEBUG
    static char *debug_states[] = {
        "IN_BEGIN_DOCUMENT", "IN_PUSHED_CONFIG", "IN_POPPED_CONFIG", "IN_BEGIN_STRING", "IN_STORED_STRING"};
 
    std::cerr << "  " << where << " tag/data " << tag << "in state " << debug_states[state] << std::endl;
#endif
  }

References beam_dqm_sourceclient-live_cfg::cerr, and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by data(), endElement(), and startElement().

endElement()

void FWXMLConfigParser::endElement ( const std::string &  tag )

inlineoverridevirtual

Executes any transaction in the state machine which happens when the xml parser closes an element.

Notice that we need to do addKeyValue on endElement (and carry around the FWConfigutation name) because of the "copy by value" policy of addKeyValue addition which would add empty FWConfiguration objects if done on startElement.

Reimplemented from SimpleSAXParser.

Definition at line 92 of file FWXMLConfigParser.h.

                                                 {
    debug_config_state_machine("end", tag, m_state);
    if (m_state == IN_PUSHED_CONFIG || m_state == IN_POPPED_CONFIG) {
      if (tag != "config")
        throw ParserError("Wrong closing tag found " + tag);
 
      FWConfiguration *current = m_configs.back().second;
      std::string key = m_configs.back().first;
      m_configs.pop_back();
      if (!m_configs.empty())
        m_configs.back().second->addKeyValue(key, *current);
      m_state = IN_POPPED_CONFIG;
    } else if (m_state == IN_BEGIN_STRING && tag == "string") {
      m_configs.back().second->addValue("");
      m_state = IN_PUSHED_CONFIG;
    } else if (m_state == IN_STORED_STRING && tag == "string")
      m_state = IN_PUSHED_CONFIG;
    else
      throw ParserError("Wrong closing tag found " + tag);
  }

References debug_config_state_machine(), IN_BEGIN_STRING, IN_POPPED_CONFIG, IN_PUSHED_CONFIG, IN_STORED_STRING, crabWrapper::key, m_configs, m_state, AlCaHLTBitMon_QueryRunRegistry::string, and GlobalPosition_Frontier_DevDB_cff::tag.

pushConfig()

void FWXMLConfigParser::pushConfig ( Attributes &  attributes )

inline

Pushes the configuration on stack eventually

Definition at line 39 of file FWXMLConfigParser.h.

                                          {
    std::string name;
    int version = 0;
    for (size_t i = 0, e = attributes.size(); i != e; ++i) {
      Attribute &attr = attributes[i];
      if (attr.key == "name")
        name = attr.value;
      else if (attr.key == "version") {
        char *endptr;
        version = strtol(attr.value.c_str(), &endptr, 10);
        if (endptr == attr.value.c_str())
          throw ParserError("Version must be an integer.");
      } else
        throw ParserError("Unexpected attribute " + attr.key);
    }
    m_configs.push_back(std::make_pair(name, new FWConfiguration(version)));
  }

References MillePedeFileConverter_cfg::e, mps_fire::i, SimpleSAXParser::Attribute::key, m_configs, Skims_PA_cff::name, AlCaHLTBitMon_QueryRunRegistry::string, SimpleSAXParser::Attribute::value, and BeamSplash_cfg::version.

Referenced by startElement().

startElement()

void FWXMLConfigParser::startElement ( const std::string &  tag, Attributes &  attributes  )

inlineoverridevirtual

Executes any transaction in the state machine which happens when the xml parser finds an new element.

Reimplemented from SimpleSAXParser.

Definition at line 60 of file FWXMLConfigParser.h.

                                                                           {
    debug_config_state_machine("start", tag, m_state);
    if (m_state == IN_BEGIN_DOCUMENT) {
      if (tag != "config")
        throw ParserError("Expecting toplevel <config> tag");
      pushConfig(attributes);
      m_first.reset(m_configs.back().second);
      m_state = IN_PUSHED_CONFIG;
    } else if (m_state == IN_PUSHED_CONFIG) {
      if (tag == "config")
        pushConfig(attributes);
      else if (tag == "string")
        m_state = IN_BEGIN_STRING;
      else
        throw ParserError("Unexpected element " + tag);
    } else if (m_state == IN_POPPED_CONFIG) {
      if (tag != "config")
        throw ParserError("Unexpected element " + tag);
      pushConfig(attributes);
      m_state = IN_PUSHED_CONFIG;
    } else
      throw ParserError("Wrong opening tag found " + tag);
  }

References debug_config_state_machine(), IN_BEGIN_DOCUMENT, IN_BEGIN_STRING, IN_POPPED_CONFIG, IN_PUSHED_CONFIG, m_configs, m_first, m_state, pushConfig(), and GlobalPosition_Frontier_DevDB_cff::tag.

Member Data Documentation

m_configs

std::vector<std::pair<std::string, FWConfiguration *> > FWXMLConfigParser::m_configs

private

Definition at line 144 of file FWXMLConfigParser.h.

Referenced by data(), endElement(), pushConfig(), and startElement().

m_currentConfigName

std::string FWXMLConfigParser::m_currentConfigName

private

Definition at line 148 of file FWXMLConfigParser.h.

m_first

std::unique_ptr<FWConfiguration> FWXMLConfigParser::m_first

private

Definition at line 146 of file FWXMLConfigParser.h.

Referenced by config(), and startElement().

m_state

enum STATES FWXMLConfigParser::m_state

private

Definition at line 145 of file FWXMLConfigParser.h.

Referenced by data(), endElement(), and startElement().