FWXMLConfigParser.h

Go to the documentation of this file.

#ifndef Fireworks_Core_FWXMLConfigParser
#define Fireworks_Core_FWXMLConfigParser
#include <istream>
#include <iostream>
#include "Fireworks/Core/src/SimpleSAXParser.h"

#include "Fireworks/Core/interface/FWConfiguration.h"

class FWXMLConfigParser : public SimpleSAXParser {
  enum STATES { IN_BEGIN_DOCUMENT, IN_PUSHED_CONFIG, IN_POPPED_CONFIG, IN_BEGIN_STRING, IN_STORED_STRING };

public:
  FWXMLConfigParser(std::istream &f) : SimpleSAXParser(f), m_state(IN_BEGIN_DOCUMENT), m_first(nullptr) {}

  void pushConfig(Attributes &attributes) {
    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 startElement(const std::string &tag, Attributes &attributes) override {
    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);
  }

  void endElement(const std::string &tag) override {
    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 data(const std::string &data) override {
    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);
  }

  FWConfiguration *config(void) { return m_first.get(); }

  void debug_config_state_machine(const char *where, const std::string &tag, int state) {
#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
  }

private:
  std::vector<std::pair<std::string, FWConfiguration *> > m_configs;
  enum STATES m_state;
  std::unique_ptr<FWConfiguration> m_first;
  //   unsigned int                                            m_currentConfigVersion;
  std::string m_currentConfigName;
};
#endif