#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 33 of file FWXMLConfigParser.h.

Member Enumeration Documentation

enum FWXMLConfigParser::STATES

private

Enumerator
IN_BEGIN_DOCUMENT
IN_PUSHED_CONFIG
IN_POPPED_CONFIG
IN_BEGIN_STRING
IN_STORED_STRING

Definition at line 35 of file FWXMLConfigParser.h.

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

Constructor & Destructor Documentation

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

inline

Definition at line 44 of file FWXMLConfigParser.h.

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

Member Function Documentation

FWConfiguration* FWXMLConfigParser::config ( void )

inline

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

Definition at line 164 of file FWXMLConfigParser.h.

References m_first.

Referenced by FWPartialConfigGUI::FWPartialConfigGUI(), and FWPartialConfigSaveGUI::WriteConfig().

    {
       return m_first.get();
    }

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 147 of file FWXMLConfigParser.h.

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

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

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

inline

Definition at line 171 of file FWXMLConfigParser.h.

References MessageLogger_cfi::cerr.

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

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

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 116 of file FWXMLConfigParser.h.

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

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

void FWXMLConfigParser::pushConfig ( Attributes & attributes )

inline

Pushes the configuration on stack eventually

Definition at line 51 of file FWXMLConfigParser.h.

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

Referenced by startElement().

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

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 77 of file FWXMLConfigParser.h.

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

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