Merge pull request #305 from dawagner/component-arrays

dawagner · dawagner · commit 0ba8ce6f3972 · 2015-11-20T14:12:42.000+01:00
Add "array" capability to Components Numerical parameters as well as ParameterBlocks can have an "ArrayLength" attribute that instantiate as many identical parameters or parameter blocks. This is now also possible for Component instances (not types). The Semantic of this feature is very unclear, even now... use with caution and see 416f784.
diff --git a/parameter/Component.h b/parameter/Component.h
@@ -45,12 +45,5 @@ class CComponent : public CInstanceConfigurableElement
     {
         return EComponent;
     }
-
-    std::string getXmlElementName() const override
-    {
-        // Once instantiated components are reflected as parameter blocks
-        // in XML documents
-        return "ParameterBlock";
-    }
 };
 
diff --git a/parameter/ComponentInstance.cpp b/parameter/ComponentInstance.cpp
@@ -31,6 +31,7 @@
 #include "ComponentLibrary.h"
 #include "ComponentType.h"
 #include "Component.h"
+#include "ParameterBlock.h" // for "array" instantiation
 #include "XmlParameterSerializingContext.h"
 
 #define base CTypeElement
@@ -41,7 +42,14 @@ CComponentInstance::CComponentInstance(const std::string& strName) : base(strNam
 
 std::string CComponentInstance::getKind() const
 {
-    return "Component";
+    return "ComponentInstance";
+}
+
+std::string CComponentInstance::getXmlElementName() const
+{
+    // Once instantiated components are reflected as parameter blocks
+    // in XML documents
+    return "ParameterBlock";
 }
 
 bool CComponentInstance::childrenAreDynamic() const
@@ -103,12 +111,33 @@ bool CComponentInstance::fromXml(const CXmlElement& xmlElement, CXmlSerializingC
 
 CInstanceConfigurableElement* CComponentInstance::doInstantiate() const
 {
-    return new CComponent(getName(), this);
+    if (isScalar()) {
+        return new CComponent(getName(), this);
+    } else {
+        return new CParameterBlock(getName(), this);
+    }
 }
 
 void CComponentInstance::populate(CElement* pElement) const
 {
-    base::populate(pElement);
+    size_t arrayLength = getArrayLength();
+
+    if (arrayLength != 0) {
+
+        // Create child elements
+        for (size_t child = 0; child < arrayLength; child++) {
 
-    _pComponentType->populate(static_cast<CComponent*>(pElement));
+            CComponent* pChildComponent = new CComponent(std::to_string(child), this);
+
+            pElement->addChild(pChildComponent);
+
+            base::populate(pChildComponent);
+
+            _pComponentType->populate(pChildComponent);
+        }
+    } else {
+        base::populate(pElement);
+
+        _pComponentType->populate(static_cast<CComponent*>(pElement));
+    }
 }
diff --git a/parameter/ComponentInstance.h b/parameter/ComponentInstance.h
@@ -55,6 +55,7 @@ class CComponentInstance : public CTypeElement
 
     // CElement
     virtual std::string getKind() const;
+    std::string getXmlElementName() const override;
 private:
     virtual bool childrenAreDynamic() const;
     virtual CInstanceConfigurableElement* doInstantiate() const;
diff --git a/parameter/InstanceConfigurableElement.cpp b/parameter/InstanceConfigurableElement.cpp
@@ -47,6 +47,12 @@ std::string CInstanceConfigurableElement::getKind() const
     return _pTypeElement->getKind();
 }
 
+std::string CInstanceConfigurableElement::getXmlElementName() const
+{
+    // Delegate
+    return _pTypeElement->getXmlElementName();
+}
+
 // Type element
 const CTypeElement* CInstanceConfigurableElement::getTypeElement() const
 {
diff --git a/parameter/InstanceConfigurableElement.h b/parameter/InstanceConfigurableElement.h
@@ -70,6 +70,7 @@ class PARAMETER_EXPORT CInstanceConfigurableElement : public CConfigurableElemen
 
     // From CElement
     virtual std::string getKind() const;
+    std::string getXmlElementName() const override;
 
     // Syncer to/from HW
     void setSyncer(ISyncer* pSyncer);
diff --git a/parameter/MappingContext.cpp b/parameter/MappingContext.cpp
@@ -37,12 +37,7 @@ using std::string;
 // Item access
 bool CMappingContext::setItem(size_t itemType, const string* pStrKey, const string* pStrItem)
 {
-    // Assert that the key hasn't been set before
-    assert(find_if(begin(mItems), end(mItems), [pStrKey](SItem &item)
-                       { return item.strKey == pStrKey; }
-                  ) == end(mItems));
-
-    if (mItems[itemType].bSet) {
+    if (iSet(itemType)) {
         // Already set!
         return false;
     }
@@ -53,8 +48,6 @@ bool CMappingContext::setItem(size_t itemType, const string* pStrKey, const stri
     // Set item value
     mItems[itemType].strItem = pStrItem;
 
-    // Now is set
-    mItems[itemType].bSet = true;
     return true;
 }
 
@@ -83,5 +76,5 @@ const string* CMappingContext::getItem(const string& strKey) const
 
 bool CMappingContext::iSet(size_t itemType) const
 {
-    return mItems[itemType].bSet;
+    return mItems[itemType].strItem != nullptr;
 }
diff --git a/parameter/MappingContext.h b/parameter/MappingContext.h
@@ -41,9 +41,8 @@ class PARAMETER_EXPORT CMappingContext
 private:
     // Item structure
     struct SItem {
-        const std::string* strKey;
-        const std::string* strItem;
-        bool bSet;
+        const std::string* strKey{nullptr};
+        const std::string* strItem{nullptr};
     };
 
 public:
diff --git a/schemas/Parameter.xsd b/schemas/Parameter.xsd
@@ -10,6 +10,7 @@
 	</xs:attributeGroup>
 	<xs:complexType name="ComponentInstance">
 		<xs:attributeGroup ref="TypedNameable"/>
+		<xs:attributeGroup ref="ArrayLengthAttribute"/>
 		<xs:attribute name="Mapping" use="optional"/>
 	</xs:complexType>
 	<xs:simpleType name="SizeType">
diff --git a/test/functional-tests/Handle.cpp b/test/functional-tests/Handle.cpp
@@ -102,7 +102,6 @@ struct AllParamsPF : public ParameterFramework
                            nodeDesc("ParameterBlock", "parameter_block_array",
                                     getBasicParams(), "ArrayLength='2'") +
                            nodeDesc("Component", "component_scalar", "", "Type='component_type'") +
-                           // Test that ArrayLength have no effect on components
                            nodeDesc("Component", "component_array", "",
                                     "Type='component_type' ArrayLength='2'");
         return config;
@@ -220,10 +219,12 @@ SCENARIO_METHOD(AllParamsPF, "Export component", "[handler][structure][xml]")
 
 SCENARIO_METHOD(AllParamsPF, "Export component array", "[handler][structure][xml]")
 {
-    string expected = rootNode("ParameterBlock", "Name='component_array' "
-                                                 "Description='description_component_array'",
-                               // component array are the same as non array for now
-                               getBasicParams());
+    string expected = rootNode("ParameterBlock",
+                               "Name='component_array' Description='description_component_array'",
+                               nodeDesc("ParameterBlock", "0", getBasicParams(), "",
+                                        "description_component_array") +
+                               nodeDesc("ParameterBlock", "1", getBasicParams(), "",
+                                        "description_component_array"));
     checkStructure("/test/test/component_array", expected);
 }
 
@@ -239,7 +240,12 @@ SCENARIO_METHOD(AllParamsPF, "Export all parameters", "[handler][structure][xml]
                                         "description_parameter_block_array")) +
                            // Components should be exported as parameterBlock
                            nodeDesc("ParameterBlock", "component_scalar", getBasicParams()) +
-                           nodeDesc("ParameterBlock", "component_array", getBasicParams());
+                           nodeDesc("ParameterBlock", "component_array",
+                                   nodeDesc("ParameterBlock", "0", getBasicParams(), "",
+                                        // description is inherited from array
+                                        "description_component_array") +
+                                   nodeDesc("ParameterBlock", "1", getBasicParams(), "",
+                                        "description_component_array"));
 
     WHEN("Exporting subsystem") {
         string expected = rootNode("Subsystem", "Name='test'", paramExpected);
@@ -274,7 +280,9 @@ struct SettingsTestPF : public AllParamsPF
                         parameterBlockNode("0", settings) +
                         parameterBlockNode("1", settings)) +
                     parameterBlockNode("component_scalar", settings) +
-                    parameterBlockNode("component_array", settings);
+                    parameterBlockNode("component_array",
+                        parameterBlockNode("0", settings) +
+                        parameterBlockNode("1", settings));
 
         return rootNode("SystemClass", "Name='test'" ,
                         node("Subsystem", "test", settings, ""));
@@ -283,7 +291,9 @@ struct SettingsTestPF : public AllParamsPF
     static string fullBytesSettings(const string &basicSettings)
     {
         string fullSettings;
-        for (size_t i = 0; i < 6; ++i) {
+        // We have the "basic params" repeated 7 times across the test
+        // structure
+        for (size_t i = 0; i < 7; ++i) {
             fullSettings += basicSettings;
         }
         return fullSettings;

Original file line number	Diff line number	Diff line change
`@@ -45,12 +45,5 @@ class CComponent : public CInstanceConfigurableElement`
`45`	`45`	`{`
`46`	`46`	`return EComponent;`
`47`	`47`	`}`
`48`		`-`
`49`		`- std::string getXmlElementName() const override`
`50`		`- {`
`51`		`- // Once instantiated components are reflected as parameter blocks`
`52`		`- // in XML documents`
`53`		`- return "ParameterBlock";`
`54`		`- }`
`55`	`48`	`};`
`56`	`49`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,12 @@ std::string CInstanceConfigurableElement::getKind() const`
`47`	`47`	`return _pTypeElement->getKind();`
`48`	`48`	`}`
`49`	`49`
	`50`	`+std::string CInstanceConfigurableElement::getXmlElementName() const`
	`51`	`+{`
	`52`	`+ // Delegate`
	`53`	`+ return _pTypeElement->getXmlElementName();`
	`54`	`+}`
	`55`	`+`
`50`	`56`	`// Type element`
`51`	`57`	`const CTypeElement* CInstanceConfigurableElement::getTypeElement() const`
`52`	`58`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,12 +37,7 @@ using std::string;`
`37`	`37`	`// Item access`
`38`	`38`	`bool CMappingContext::setItem(size_t itemType, const string* pStrKey, const string* pStrItem)`
`39`	`39`	`{`
`40`		`- // Assert that the key hasn't been set before`
`41`		`- assert(find_if(begin(mItems), end(mItems), [pStrKey](SItem &item)`
`42`		`- { return item.strKey == pStrKey; }`
`43`		`- ) == end(mItems));`
`44`		`-`
`45`		`- if (mItems[itemType].bSet) {`
	`40`	`+ if (iSet(itemType)) {`
`46`	`41`	`// Already set!`
`47`	`42`	`return false;`
`48`	`43`	`}`
`@@ -53,8 +48,6 @@ bool CMappingContext::setItem(size_t itemType, const string* pStrKey, const stri`
`53`	`48`	`// Set item value`
`54`	`49`	`mItems[itemType].strItem = pStrItem;`
`55`	`50`
`56`		`- // Now is set`
`57`		`- mItems[itemType].bSet = true;`
`58`	`51`	`return true;`
`59`	`52`	`}`
`60`	`53`
`@@ -83,5 +76,5 @@ const string* CMappingContext::getItem(const string& strKey) const`
`83`	`76`
`84`	`77`	`bool CMappingContext::iSet(size_t itemType) const`
`85`	`78`	`{`
`86`		`- return mItems[itemType].bSet;`
	`79`	`+ return mItems[itemType].strItem != nullptr;`
`87`	`80`	`}`