Add default element fallback

BZ: 122982

The element library class is a factory that receives an xml node and
instanciates the corresponding element. In some case, it would be usefull
not to fail if no matching builder is found but use a default one.

Add a setDefaultElementBuilder method to set the default builder to
fallback to, in case no  matching builder is found.

Change-Id: I58f0ada3450195a3ca7d878e4b666b0a9359b499
Signed-off-by: Kevin Rocard <kevinx.rocard@intel.com>
Reviewed-on: http://android.intel.com:8080/118042
Reviewed-by: Centelles, Sylvain <sylvain.centelles@intel.com>
Tested-by: Barthes, FabienX <fabienx.barthes@intel.com>
Reviewed-by: cactus <cactus@intel.com>
Tested-by: cactus <cactus@intel.com>

5 files changed, 106 insertions, 23 deletions

diff --git a/parameter/DefaultElementLibrary.h b/parameter/DefaultElementLibrary.h
new file mode 100644
index 0000000..53a9059
--- /dev/null
+++ b/parameter/DefaultElementLibrary.h
@@ -0,0 +1,94 @@
+/*
+ * INTEL CONFIDENTIAL
+ * Copyright 2013 Intel
+ * Corporation All Rights Reserved.
+ *
+ * The source code contained or described herein and all documents related to
+ * the source code ("Material") are owned by Intel Corporation or its suppliers
+ * or licensors. Title to the Material remains with Intel Corporation or its
+ * suppliers and licensors. The Material contains trade secrets and proprietary
+ * and confidential information of Intel or its suppliers and licensors. The
+ * Material is protected by worldwide copyright and trade secret laws and
+ * treaty provisions. No part of the Material may be used, copied, reproduced,
+ * modified, published, uploaded, posted, transmitted, distributed, or
+ * disclosed in any way without Intel’s prior express written permission.
+ *
+ * No license under any patent, copyright, trade secret or other intellectual
+ * property right is granted to or conferred upon you by disclosure or delivery
+ * of the Materials, either expressly, by implication, inducement, estoppel or
+ * otherwise. Any license under such intellectual property rights must be
+ * express and approved by Intel in writing.
+ */
+#pragma once
+
+#include "ElementLibrary.h"
+#include "ElementBuilder.h"
+
+#include <map>
+#include <string>
+
+/** Factory that creates an element given an xml element. If no matching builder is found, it uses
+  * the default builder.
+  *
+  * @tparam CDefaultElementBuilder is the class of the element builder to use if no corresponding
+  *                                builder is found for a given xml element.
+  */
+template<class CDefaultElementBuilder>
+class CDefaultElementLibrary: public CElementLibrary
+{
+public:
+
+    explicit CDefaultElementLibrary(bool bEnableDefaultMechanism = true);
+    virtual ~CDefaultElementLibrary() {}
+
+    /** Enable the default builder fallback mechanism.
+      * @see createElement() for more detail on this mechanism.
+      *
+      * @param[in] bEnable if true/false, activate/deactivate the default builder mechanism.
+      */
+    void enableDefaultMechanism(bool bEnable) {
+        _bEnableDefaultMechanism = bEnable;
+    }
+
+
+    /** Create and return an element instanciated depending on an xmlElement.
+      *
+      * @param[in] xmlElement: The xml element used to find a matching builder
+      *
+      * @return If a matching builder is found, return an element created from the builder,
+      *         otherwise:
+      *             If the default mechanism is enable (@see enableDefaultMechanism),
+      *                 create the elemen with the default element builder.
+      *             otherwise, return NULL.
+      */
+    CElement* createElement(const CXmlElement& xmlElement) const;
+
+private:
+    bool _bEnableDefaultMechanism;
+    CDefaultElementBuilder _DefaultElementBuilder;
+};
+
+template<class CDefaultElementBuilder>
+CDefaultElementLibrary<CDefaultElementBuilder>::CDefaultElementLibrary(bool bEnableDefaultMechanism) :
+        _bEnableDefaultMechanism(bEnableDefaultMechanism),
+        _DefaultElementBuilder() {}
+
+template<class CDefaultElementBuilder>
+CElement* CDefaultElementLibrary<CDefaultElementBuilder>::createElement(const CXmlElement& xmlElement) const
+{
+    CElement* builtElement = CElementLibrary::createElement(xmlElement);
+
+    if (builtElement != NULL) {
+        // The element was created, return it
+        return builtElement;
+    }
+
+    if (!_bEnableDefaultMechanism) {
+        // The default builder mechanism is not enabled
+        return NULL;
+    }
+
+    // Use the default builder
+    return _DefaultElementBuilder.createElement(xmlElement);
+}
+
diff --git a/parameter/ElementLibrary.cpp b/parameter/ElementLibrary.cpp
index 695942a..2945064 100644
--- a/parameter/ElementLibrary.cpp
+++ b/parameter/ElementLibrary.cpp
@@ -57,12 +57,12 @@ CElement* CElementLibrary::createElement(const CXmlElement& xmlElement) const
     return NULL;
 }
 
-void CElementLibrary::addElementBuilder(string type, const CElementBuilder *pElementBuilder)
+void CElementLibrary::addElementBuilder(const std::string& type, const CElementBuilder *pElementBuilder)
 {
     _elementBuilderMap[type] = pElementBuilder;
 }
 
-string CElementLibrary::getBuilderType(const CXmlElement& xmlElement) const
+std::string CElementLibrary::getBuilderType(const CXmlElement& xmlElement) const
 {
     // Defaulting to xml element name
     return xmlElement.getType();
diff --git a/parameter/ElementLibrary.h b/parameter/ElementLibrary.h
index 0de6056..8f9337e 100644
--- a/parameter/ElementLibrary.h
+++ b/parameter/ElementLibrary.h
@@ -29,13 +29,11 @@
 
 #include "Element.h"
 
-using namespace std;
-
 class CElementBuilder;
 
 class CElementLibrary
 {
-    typedef map<string, const CElementBuilder*> ElementBuilderMap;
+    typedef std::map<string, const CElementBuilder*> ElementBuilderMap;
     typedef ElementBuilderMap::iterator ElementBuilderMapIterator;
     typedef ElementBuilderMap::const_iterator ElementBuilderMapConstIterator;
 
@@ -49,7 +47,7 @@ public:
        *               create a new element.
        * @param[in] pElementBuilder is the tag associated element builder.
        */
-    void addElementBuilder(string type, const CElementBuilder *pElementBuilder);
+    void addElementBuilder(const std::string& type, const CElementBuilder *pElementBuilder);
     void clean();
 
     // Instantiation
@@ -57,7 +55,7 @@ public:
 
 private:
     // Builder type
-    virtual string getBuilderType(const CXmlElement& xmlElement) const;
+    virtual std::string getBuilderType(const CXmlElement& xmlElement) const;
 
     // Builders
     ElementBuilderMap _elementBuilderMap;
diff --git a/parameter/SubsystemLibrary.cpp b/parameter/SubsystemLibrary.cpp
index 1f4c3e6..d6a82f4 100644
--- a/parameter/SubsystemLibrary.cpp
+++ b/parameter/SubsystemLibrary.cpp
@@ -25,15 +25,6 @@
 #include "SubsystemLibrary.h"
 #include "XmlElement.h"
 
-
-CSubsystemLibrary::CSubsystemLibrary()
-{
-}
-
-CSubsystemLibrary::~CSubsystemLibrary()
-{
-}
-
 string CSubsystemLibrary::getBuilderType(const CXmlElement& xmlElement) const
 {
     // Xml element's name attribute
diff --git a/parameter/SubsystemLibrary.h b/parameter/SubsystemLibrary.h
index 42ade57..00898ce 100644
--- a/parameter/SubsystemLibrary.h
+++ b/parameter/SubsystemLibrary.h
@@ -24,15 +24,15 @@
  */
 #pragma once
 
-#include "ElementLibrary.h"
+#include "DefaultElementLibrary.h"
+#include "VirtualSubsystem.h"
+#include "NamedElementBuilderTemplate.h"
+#include <string>
 
-class CSubsystemLibrary : public CElementLibrary
+class CSubsystemLibrary :
+        public CDefaultElementLibrary<TNamedElementBuilderTemplate<CVirtualSubsystem> >
 {
-public:
-    CSubsystemLibrary();
-    virtual ~CSubsystemLibrary();
-
 private:
     // Builder type (based on element's name attribute)
-    virtual string getBuilderType(const CXmlElement& xmlElement) const;
+    virtual std::string getBuilderType(const CXmlElement& xmlElement) const;
 };