Changeset 270 in pacpusframework

Timestamp:

03/13/14 10:41:30 (10 years ago)

Author:

Marek Kurdej

Message:

Major: DomElementParser (direct parsing of XML attributes).

Location:

trunk

Files:

• include/Pacpus/kernel/XmlComponentConfig.h (modified) (1 diff)
• src/PacpusLib/ComponentBase.cpp (modified) (3 diffs)
• src/PacpusLib/ComponentManager.cpp (modified) (2 diffs)
• src/PacpusLib/XmlComponentConfig.cpp (modified) (1 diff)

trunk/include/Pacpus/kernel/XmlComponentConfig.h

@@ -94 +94 @@
 public:
     // Returns the local QDomElement.
-    QDomElement qDomElement() const;
+    QDomElement const& getDomElement() const;
     
 private:

trunk/src/PacpusLib/ComponentBase.cpp

@@ -244 +244 @@
 }
 
-void ComponentBase::parseParameters(const XmlComponentConfig & cfg)
+class DomElementParser
+{
+public:
+    DomElementParser(QDomElement const& args);
+    
+    /** Sets options descriptions to use. */
+    DomElementParser& options(const boost::program_options::options_description& desc);
+    
+    /** Parses the options and returns the result of parsing.
+        Throws on error.
+    */
+    boost::program_options::basic_parsed_options<char> run();
+
+    /** Specifies that unregistered options are allowed and should
+        be passed though. For each command like token that looks
+        like an option but does not contain a recognized name, an
+        instance of basic_option<charT> will be added to result,
+        with 'unrecognized' field set to 'true'. It's possible to
+        collect all unrecognized options with the 'collect_unrecognized'
+        funciton. 
+    */
+    DomElementParser& allow_unregistered();
+    
+private:
+    boost::program_options::basic_parsed_options<char> parseDomElement(
+        const QDomElement& dom_element,
+        const boost::program_options::options_description& desc,
+        bool allow_unregistered = false);
+
+private:
+    const boost::program_options::options_description* m_desc;
+    const QDomElement& m_dom_element;
+    bool m_allow_unregistered;
+};
+
+DomElementParser::DomElementParser(const QDomElement& dom_element)
+    : m_dom_element(dom_element)
+    , m_allow_unregistered(false)
+{
+}
+
+DomElementParser& DomElementParser::options(const boost::program_options::options_description& desc)
+{
+    m_desc = &desc;
+    return *this;
+}
+
+DomElementParser& DomElementParser::allow_unregistered()
+{
+    m_allow_unregistered = true;
+    return *this;
+}
+
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/program_options/errors.hpp>
+
+namespace detail
+{
+template <typename charT>
+class basic_dom_element_iterator
+    : public boost::iterator_facade<
+        basic_dom_element_iterator<charT>
+        , const boost::program_options::option
+        , boost::random_access_traversal_tag
+    >
+{
+public:
+    typedef boost::program_options::option ValueType;
+
+    basic_dom_element_iterator<charT>()
+        : m_dom_element(NULL)
+        , m_at_eof(true)
+    {
+    }
+
+    basic_dom_element_iterator<charT>(const QDomElement& dom_element,
+            const std::set<std::string>& allowed_options,
+            bool allow_unregistered = false)
+        : m_dom_element(&dom_element)
+        , m_allowed_options(allowed_options)
+        , m_allow_unregistered(false)
+        , m_i(0)
+    {
+        m_attrs = m_dom_element->attributes();
+        m_at_eof = !(m_i < m_attrs.size());
+        if (!m_at_eof) {
+            get();
+        }
+    }
+    
+//private:
+    friend class iterator_core_access;
+
+    bool equal(const basic_dom_element_iterator<charT>& other) const
+    {
+        if (m_at_eof && other.m_at_eof) {
+            return true;
+        }
+        return false;
+    }
+    
+    void increment() 
+    {
+        ++m_i;
+        m_at_eof = !(m_i < m_attrs.size());
+        if (!m_at_eof) {
+            get();
+        }
+    }
+    
+    const ValueType& dereference() const
+    {
+        return m_value;
+    }
+    
+    difference_type distance_to(const basic_dom_element_iterator<charT>& other) const
+    {
+        return other.m_i - this->m_i;
+    }
+
+private:
+    ValueType& value()
+    {
+        return m_value;
+    }
+    
+    void get()
+    {
+        using namespace boost::program_options;
+
+        QDomNode node = m_attrs.item(m_i);
+        QDomAttr attr = node.toAttr();
+
+        string name = attr.name().toStdString();
+        string value = attr.value().toStdString();
+
+        bool registered = allowed_option(name);
+        if (!registered && !m_allow_unregistered) {
+            boost::throw_exception(unknown_option(name));
+        }
+
+        this->value().string_key = name;
+        this->value().value.clear();
+        this->value().value.push_back(value);
+        this->value().unregistered = !registered;
+        this->value().original_tokens.push_back(name);
+        this->value().original_tokens.push_back(value);
+    }
+
+    bool allowed_option(const std::string& s) const
+    {
+        set<string>::const_iterator i = m_allowed_options.find(s);
+        if (i != m_allowed_options.end()) {
+            return true;        
+        }
+        return false;
+    }
+
+private:
+    const QDomElement* m_dom_element;
+    std::set<std::string> m_allowed_options;
+    bool m_allow_unregistered;
+
+    QDomNamedNodeMap m_attrs;
+    int m_i;
+    bool m_at_eof;
+    ValueType m_value;
+};
+
+typedef basic_dom_element_iterator<char> dom_element_iterator;
+typedef basic_dom_element_iterator<wchar_t> wdom_element_iterator;
+
+}
+
+boost::program_options::basic_parsed_options<char> DomElementParser::run()
+{
+    assert(m_desc);
+    return parseDomElement(m_dom_element, *m_desc, m_allow_unregistered);
+}
+
+boost::program_options::basic_parsed_options<char> DomElementParser::parseDomElement(
+        const QDomElement& dom_element,
+        const boost::program_options::options_description& desc,
+        bool allow_unregistered)
+{
+    typedef char charT;
+
+    using boost::program_options::error;
+    using boost::shared_ptr;
+    using namespace boost::program_options;
+    using ::detail::basic_dom_element_iterator;
+    
+    set<string> allowed_options;
+
+    const vector<shared_ptr<option_description> >& options = desc.options();
+    for (unsigned i = 0; i < options.size(); ++i) {
+        const option_description& d = *options[i];
+
+        if (d.long_name().empty()) {
+            boost::throw_exception(
+                error("abbreviated option names are not permitted when parsing DOM elements"));
+        }
+        
+        allowed_options.insert(d.long_name());
+    }
+    
+    // Parser returns char strings
+    parsed_options result(&desc);        
+    copy(basic_dom_element_iterator<charT>(dom_element, allowed_options, allow_unregistered),
+            basic_dom_element_iterator<charT>(),
+            back_inserter(result.options));
+
+    // Convert char strings into desired type.
+    return basic_parsed_options<charT>(result);
+}
+
+DomElementParser parseDomElement();
+
+/** Creates instance of 'command_line_parser', passes parameters to it,
+    and returns the result of calling the 'run' method.        
+    */
+boost::program_options::basic_parsed_options<char> 
+parseDomElement(QDomElement const& domElement, const boost::program_options::options_description&);
+
+boost::program_options::basic_parsed_options<char> 
+parseDomElement(QDomElement const& domElement, const boost::program_options::options_description& desc)
+{
+    return DomElementParser(domElement)
+        .options(desc)
+        .run();
+}
+
+void ComponentBase::parseParameters(XmlComponentConfig const& cfg)
 {
     LOG_INFO("Parsing parameters...");
@@ -254 +486 @@
     try {
         po::store(
-            po::command_line_parser(xargs)
+            DomElementParser(cfg.getDomElement())
+            //po::command_line_parser(xargs)
                 .options(mOptionsDescription)
                 .allow_unregistered()   // FIXME: temporary only, at term all the components specify all parameters
@@ -260 +493 @@
         , vm);
         po::notify(vm);
-    } catch (po::error & e) {
+    } catch (po::error& e) {
         LOG_WARN(e.what());
         throw PacpusException(e.what());

trunk/src/PacpusLib/ComponentManager.cpp

@@ -340 +340 @@
         }
 
-        component->param.localCopy(cfg.qDomElement());
+        component->param.localCopy(cfg.getDomElement());
         try {
             component->parseParameters(cfg);
@@ -373 +373 @@
 
             // copy locally the config parameters of the component
-            component->param.localCopy(cfg.qDomElement());
+            component->param.localCopy(cfg.getDomElement());
             component->setConfigurationState(component->configureComponent(cfg));
         }

trunk/src/PacpusLib/XmlComponentConfig.cpp

@@ -126 +126 @@
 }
 
-QDomElement XmlComponentConfig::qDomElement() const
+QDomElement const& XmlComponentConfig::getDomElement() const
 {
     return component_;