Add Xml binding for Parameter framework configuration

clero · clero · commit ec67345a08b2 · 2015-05-20T18:32:47.000+02:00
TODO: UPDATE DOC, NAMESPACE OF BINDINGS
MAKE CONF A SIMPLE STRUCT

Signed-off-by: Jules Clero &lt;julesx.clero@intel.com&gt;
diff --git a/parameter/ParameterFrameworkConfiguration.cpp b/parameter/ParameterFrameworkConfiguration.cpp
@@ -28,9 +28,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include "ParameterFrameworkConfiguration.h"
-#include "XmlFileDocSource.h"
-#include "XmlMemoryDocSink.h"
-#include "XmlElement.h"
+#include "Deserializer.hpp"
+#include "ParameterFrameworkConfigurationXmlBinding.hpp"
 
 CParameterFrameworkConfiguration::CParameterFrameworkConfiguration(const std::string &configurationFile)
     : _bTuningAllowed(false), _uiServerPort(0), _configurationFile(configurationFile)
@@ -49,14 +48,14 @@ bool CParameterFrameworkConfiguration::init(std::string &error)
     }
     _schemasLocation = _configurationFolder + "/Schemas";
 
-    CXmlSerializingContext context(error);
-    CXmlFileDocSource source(_configurationFile,
-                             _schemasLocation + "/ParameterFrameworkConfiguration.xsd",
-                             "ParameterFrameworkConfiguration",
-                             false);
-
-    CXmlMemoryDocSink sink(this);
-    return sink.process(source, context);
+    try {
+        core::xml::bindings::ParameterFrameworkConfigurationXmlBinding bindings{*this};
+        core::xml::serialization::Deserializer test{_configurationFile, bindings.getBindings()};
+    } catch (std::runtime_error &e) {
+        error = e.what();
+        return false;
+    }
+    return true;
 }
 
 // System class name
@@ -76,134 +75,3 @@ uint16_t CParameterFrameworkConfiguration::getServerPort() const
 {
     return _uiServerPort;
 }
-
-bool CParameterFrameworkConfiguration::retrieveSettingsConfiguration(const CXmlElement &settingsNode,
-                                                                     CXmlSerializingContext& context)
-{
-    if (settingsNode.getNbChildElements() > 2) {
-        context.setError("too much settings node");
-        return false;
-    }
-    bool settingsChildFound = false;
-    CXmlElement childNode;
-    CXmlElement::CChildIterator childIterator(settingsNode);
-    while (childIterator.next(childNode)) {
-        if (childNode.getType() == "ConfigurableDomainsFileLocation") {
-            if(!retrievePathAttribute(childNode, _settingsFile, context)) {
-                return false;
-            }
-            settingsChildFound = true;
-        } else if (childNode.getType() == "BinarySettingsFileLocation") {
-            if (!retrievePathAttribute(childNode, _binarySettingsFile, context)) {
-                return false;
-            }
-        } else {
-            context.setError("Unknown child");
-            return false;
-        }
-    }
-    if (!settingsChildFound) {
-        context.setError("No ConfigurableDomainsFileLocation element found"
-                         " for SystemClass " + _strSystemClassName);
-        return false;
-    }
-    return true;
-}
-
-bool CParameterFrameworkConfiguration::retrievePathAttribute(const CXmlElement &xmlElement,
-                                                             std::string &path,
-                                                             CXmlSerializingContext& context)
-{
-    xmlElement.getAttribute("Path", path);
-    if (path.empty()) {
-        context.setError("Empty Path attribute in element " + xmlElement.getPath());
-        return false;
-    }
-    if (path[0] != '/') {
-        // Path is relative
-        path = _configurationFolder + "/" + path;
-    }
-    return true;
-}
-
-bool CParameterFrameworkConfiguration::retrievePluginsConfiguration(const CXmlElement &pluginNode,
-                                                                    CXmlSerializingContext& context)
-{
-    CXmlElement::CChildIterator childLocation(pluginNode);
-    CXmlElement xmlPluginLocation;
-    while (childLocation.next(xmlPluginLocation)) {
-        if (!(xmlPluginLocation.getType() == "Location")) {
-            context.setError("pas de location");
-            return false;
-        }
-        // Retrieve folder
-        std::string pluginFolder;
-        pluginNode.getAttribute("Folder", pluginFolder);
-        if (!pluginFolder.empty()) {
-            pluginFolder += "/";
-        }
-
-        // Get Info from children
-        CXmlElement::CChildIterator childIterator(xmlPluginLocation);
-        CXmlElement xmlPluginElement;
-        while (childIterator.next(xmlPluginElement)) {
-            if (!(xmlPluginElement.getType() == "Plugin")) {
-                context.setError("pas de plugin");
-                return false;
-            }
-
-            // Fill Plugin List
-            _plugins.push_back(pluginFolder + xmlPluginElement.getNameAttribute());
-        }
-    }
-    return true;
-}
-
-// From IXmlSink
-bool CParameterFrameworkConfiguration::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext)
-{
-    // System class name
-    xmlElement.getAttribute("SystemClassName", _strSystemClassName);
-
-    // Tuning allowed
-    xmlElement.getAttribute("TuningAllowed", _bTuningAllowed);
-
-    // Server port
-    xmlElement.getAttribute("ServerPort", _uiServerPort);
-
-    CXmlElement childNode;
-    CXmlElement::CChildIterator childIterator(xmlElement);
-
-    bool structureChildFound = false;
-    bool subsystemPluginsChildFound = false;
-    while (childIterator.next(childNode)) {
-        if (childNode.getType() == "SubsystemPlugins") {
-            if(!retrievePluginsConfiguration(childNode, serializingContext)) {
-                return false;
-            }
-            subsystemPluginsChildFound = true;
-        } else if (childNode.getType() == "StructureDescriptionFileLocation") {
-            if(!retrievePathAttribute(childNode, _structureFile, serializingContext)) {
-                return false;
-            }
-            structureChildFound = true;
-        } else if (childNode.getType() == "SettingsConfiguration") {
-            if (!retrieveSettingsConfiguration(childNode, serializingContext)) {
-                return false;
-            }
-        } else {
-            serializingContext.setError("Unknown child");
-            return false;
-        }
-    }
-    if (!structureChildFound) {
-        serializingContext.setError("No StructureDescriptionFileLocation element"
-                                    " found for SystemClass " + _strSystemClassName);
-    }
-    if (!subsystemPluginsChildFound) {
-        serializingContext.setError("Parameter Framework Configuration: couldn't "
-                                    "find SubsystemPlugins element");
-    }
-    return true;
-}
-
diff --git a/parameter/ParameterFrameworkConfiguration.h b/parameter/ParameterFrameworkConfiguration.h
@@ -31,9 +31,8 @@
 
 #include <string>
 #include <list>
-#include "XmlSink.h"
 
-class CParameterFrameworkConfiguration : public IXmlSink
+class CParameterFrameworkConfiguration
 {
 public:
     CParameterFrameworkConfiguration(const std::string &configurationFile);
@@ -79,14 +78,6 @@ class CParameterFrameworkConfiguration : public IXmlSink
         _schemasLocation = location;
     }
 
-private:
-    // From IXmlSink
-    virtual bool fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext);
-
-    bool retrieveSettingsConfiguration(const CXmlElement &settingsNode, CXmlSerializingContext& serializingContext);
-    bool retrievePathAttribute(const CXmlElement &xmlElement, std::string &path, CXmlSerializingContext& serializingContext);
-    bool retrievePluginsConfiguration(const CXmlElement &pluginNode, CXmlSerializingContext& serializingContext);
-
     // System class name
     std::string _strSystemClassName;
     // Tuning allowed
@@ -102,6 +93,5 @@ class CParameterFrameworkConfiguration : public IXmlSink
     std::string _settingsFile;
     std::string _binarySettingsFile;
 
-    std::string _subsystemPlugins;
     std::list<std::string> _plugins;
 };
diff --git a/parameter/ParameterFrameworkConfigurationXmlBinding.hpp b/parameter/ParameterFrameworkConfigurationXmlBinding.hpp
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2015, Intel Corporation
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation and/or
+ * other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+
+#include "Node.hpp"
+#include "ParameterFrameworkConfiguration.h"
+
+#include <string>
+#include <stdexcept>
+
+namespace core
+{
+namespace xml
+{
+namespace bindings
+{
+
+class ParameterFrameworkConfigurationXmlBinding
+{
+public:
+    /** @param[in] configuration the reference on the configuration to fill */
+    ParameterFrameworkConfigurationXmlBinding(CParameterFrameworkConfiguration &configuration)
+        : mConfiguration(configuration), mPluginFolder("")
+    {
+    }
+
+
+    /** Generate Xml bindings for a ParameterFrameworkConfiguration object
+     *
+     * return root Node of generated bindings
+     */
+    core::xml::binding::Node getBindings()
+    {
+        using namespace core::xml::binding;
+        Node plugin {
+            "Plugin",
+            Body {
+                Attributes {
+                    { "Name",
+                      Type<std::string>{},
+                      [] () { throw std::runtime_error("Unimplemented serialization behavior of"
+                                                       " ParameterFrameworkConfiguration");
+                              return ""; },
+                      [this] (std::string name) {
+                          mConfiguration._plugins.push_back(
+                                  mPluginFolder + (mPluginFolder.empty() ? "" : "/") + name);
+                      }
+                    }
+                },
+                Nodes {}
+            }
+        };
+        Node location {
+            "Location",
+            Body {
+                Attributes { { "Folder", makeAccessor(mPluginFolder) } },
+                Nodes { plugin }
+            }
+        };
+        Node subsystemPlugins { "SubsystemPlugins", Body { Attributes {}, Nodes { location } } };
+        Node structure {
+            "StructureDescriptionFileLocation",
+            Body { Attributes { makePathAttribute(mConfiguration._structureFile) }, Nodes {} }
+        };
+        Node configurableDomains {
+            "ConfigurableDomainsFileLocation",
+            Body { Attributes { makePathAttribute(mConfiguration._settingsFile) }, Nodes {} }
+        };
+        Node settingsBinary {
+            "BinarySettingsFileLocation",
+            Body { Attributes { makePathAttribute(mConfiguration._binarySettingsFile) }, Nodes {} }
+        };
+        Node settings {
+            "SettingsConfiguration",
+            Body { Attributes {}, Nodes { configurableDomains, settingsBinary } }
+        };
+        Node configuration {
+            "ParameterFrameworkConfiguration",
+            Body {
+                Attributes {
+                    { "SystemClassName", makeAccessor(mConfiguration._strSystemClassName) },
+                    { "ServerPort", makeAccessor(mConfiguration._uiServerPort) },
+                    { "TuningAllowed", makeAccessor(mConfiguration._bTuningAllowed) }
+                },
+                Nodes { subsystemPlugins, structure, settings }
+            }
+        };
+
+        return configuration;
+    }
+
+private:
+    /** Helper for Path attribute binding generation
+     * Prepare, in the setter, the path by adding the configuration folder to any
+     * relative path.
+     *
+     * @return an Attribute which can hold a path
+     */
+    core::xml::binding::Attribute makePathAttribute(std::string &pathSink)
+    {
+        using namespace core::xml::binding;
+        return { "Path", Type<std::string>{},
+                 [&pathSink] () { return pathSink; },
+                 [&pathSink, this] (std::string path) {
+                    if (path[0] != '/') {
+                        // Path is relative
+                        pathSink = mConfiguration._configurationFolder + "/" + path;
+                    }
+                 }
+        };
+    }
+    /** Reference on the Configuration object to fill */
+    CParameterFrameworkConfiguration &mConfiguration;
+
+    /** Plugin Folder temporary variable */
+    std::string mPluginFolder;
+};
+
+} /** bindings namespace */
+} /** xml namespace */
+} /** core namespace */
