APPLINK-6274: CodeGenerator supports param default value

diff --git a/tools/InterfaceGenerator/generator/Model.py b/tools/InterfaceGenerator/generator/Model.py
index 1e158c0..ee458d9 100755 (executable)
--- a/tools/InterfaceGenerator/generator/Model.py
+++ b/tools/InterfaceGenerator/generator/Model.py
@@ -15,9 +15,14 @@ import collections
 
 class Boolean(object):
 
-    """Boolean type."""
+    """Boolean type.
 
-    pass
+    default_value -- default value
+
+    """
+
+    def __init__(self, default_value=None):
+        self.default_value = default_value
 
 
 class Integer(object):
@@ -27,12 +32,14 @@ class Integer(object):
     Instance variables:
     min_value -- minimum allowed value
     max_value -- maximum allowed value
+    default_value -- default value
 
     """
 
-    def __init__(self, min_value=None, max_value=None):
+    def __init__(self, min_value=None, max_value=None, default_value=None):
         self.min_value = min_value
         self.max_value = max_value
+        self.default_value = default_value
 
 
 class Double(object):
@@ -42,13 +49,14 @@ class Double(object):
     Instance variables:
     min_value -- minimum allowed value
     max_value -- maximum allowed value
+    default_value -- default value
 
     """
 
-    def __init__(self, min_value=None, max_value=None):
+    def __init__(self, min_value=None, max_value=None, default_value=None):
         self.min_value = min_value
         self.max_value = max_value
-
+        self.default_value = default_value
 
 class String(object):
 
@@ -57,12 +65,14 @@ class String(object):
     Instance variables:
     min_length -- minimum string length
     max_length -- maximum string length
+    default_value -- default value
 
     """
 
-    def __init__(self, min_length=None, max_length=None):
+    def __init__(self, min_length=None, max_length=None, default_value=None):
         self.min_length = min_length
         self.max_length = max_length
+        self.default_value = default_value
 
 
 class Array(object):
@@ -108,12 +118,13 @@ class InterfaceItemBase(object):
     issues -- list of issues
     todos -- list of string todo elements
     platform -- optional platform (string or None)
+    default_value -- default value
     scope -- optional scope: internal, partner or none (none by defaul, means public)
 
     """
 
     def __init__(self, name, description=None, design_description=None,
-                 issues=None, todos=None, platform=None, scope=None):
+                 issues=None, todos=None, platform=None, default_value=None, scope=None):
         self.name = name
         self.description = description if description is not None else []
         self.design_description = \
@@ -121,6 +132,7 @@ class InterfaceItemBase(object):
         self.issues = issues if issues is not None else []
         self.todos = todos if todos is not None else []
         self.platform = platform
+        self.default_value = default_value
         self.scope = scope
 
 
@@ -211,19 +223,21 @@ class Param(InterfaceItemBase):
     is_mandatory -- boolean value indicating whether
                     this parameter is mandatory
     param_type -- parameter type
+    default_value -- default value
 
     """
 
     def __init__(self, name, param_type, description=None,
                  design_description=None, issues=None, todos=None,
-                 platform=None, is_mandatory=True, scope=None):
+                 platform=None, is_mandatory=True, default_value=None, scope=None):
         super(Param, self).__init__(
             name, description=description,
             design_description=design_description, issues=issues, todos=todos,
-            platform=platform, scope=scope)
+            platform=platform, default_value=default_value, scope=scope)
 
         self.is_mandatory = is_mandatory
         self.param_type = param_type
+        self.default_value = default_value
 
 
 class FunctionParam(Param):
@@ -241,7 +255,7 @@ class FunctionParam(Param):
         super(FunctionParam, self).__init__(
             name, param_type=param_type, description=description,
             design_description=design_description, issues=issues, todos=todos,
-            platform=platform, is_mandatory=is_mandatory, scope=scope)
+            platform=platform, is_mandatory=is_mandatory, default_value=default_value, scope=scope)
 
         self.default_value = default_value
 

diff --git a/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py b/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py
index eff5b1d..1fc5824 100755 (executable)
--- a/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py
+++ b/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py
@@ -625,8 +625,7 @@ class CodeGenerator(object):
             item_decl=self._gen_schema_item_decl_code(
                 member.param_type,
                 member.name,
-                member.default_value if type(member)
-                is Model.FunctionParam else None))
+                member.default_value))
 
     def _gen_schema_item_decl_code(self, param, member_name, default_value):
 
@@ -643,34 +642,33 @@ class CodeGenerator(object):
         String with schema item initialization source code.
 
         """
-
         code = u""
         if type(param) is Model.Boolean:
             code = self._impl_code_bool_item_template.substitute(
                 params=self._gen_schema_item_param_values(
-                    [[u"bool", None if default_value is None
-                      else u"true" if default_value is True else u"false"]]))
+                    [[u"bool", None if param.default_value is None
+                      else u"true" if param.default_value is True else u"false"]]))
         elif type(param) is Model.Integer:
             code = self._impl_code_integer_item_template.substitute(
                 type=u"int",
                 params=self._gen_schema_item_param_values(
                     [[u"int", param.min_value],
                      [u"int", param.max_value],
-                     [u"int", default_value]]))
+                     [u"int", param.default_value]]))
         elif type(param) is Model.Double:
             code = self._impl_code_integer_item_template.substitute(
                 type=u"double",
                 params=self._gen_schema_item_param_values(
                     [[u"double", param.min_value],
                      [u"double", param.max_value],
-                     [u"double", default_value]]))
+                     [u"double", param.default_value]]))
         elif type(param) is Model.String:
             code = self._impl_code_string_item_template.substitute(
                 params=self._gen_schema_item_param_values(
                     [[u"size_t", param.min_length],
                      [u"size_t", param.max_length],
                      [u"std::string", u"".join(
-                     [u'"', default_value, u'"']) if default_value
+                     [u'"', param.default_value, u'"']) if param.default_value
                          is not None else u""]]))
         elif type(param) is Model.Array:
             code = self._impl_code_array_item_template.substitute(

diff --git a/tools/InterfaceGenerator/generator/parsers/RPCBase.py b/tools/InterfaceGenerator/generator/parsers/RPCBase.py
index 7713895..34171ea 100755 (executable)
--- a/tools/InterfaceGenerator/generator/parsers/RPCBase.py
+++ b/tools/InterfaceGenerator/generator/parsers/RPCBase.py
@@ -560,26 +560,33 @@ class Parser(object):
         scope = self._extract_attrib(attrib, "scope")
         if scope is not None:
             params["scope"] = scope
-        self._ignore_attribute(attrib, "defvalue")
 
+        default_value = None;
         param_type = None
         type_name = self._extract_attrib(attrib, "type")
         if type_name is None:
             raise ParseError("Type is not specified for parameter '" +
                              params["name"] + "'")
         if type_name == "Boolean":
-            param_type = Model.Boolean()
+            default_value = self._extract_attrib(
+                attrib, "defvalue")
+            if default_value != None:
+                default_value = self._get_bool_from_string(default_value);
+            param_type = Model.Boolean(default_value=default_value)
         elif type_name == "Integer" or \
                 type_name == "Float":
             min_value = self._extract_optional_number_attrib(
                 attrib, "minvalue", int if type_name == "Integer" else float)
             max_value = self._extract_optional_number_attrib(
                 attrib, "maxvalue", int if type_name == "Integer" else float)
+            default_value = self._extract_optional_number_attrib(
+                attrib, "defvalue", int if type_name == "Integer" else float)
 
             param_type = \
                 (Model.Integer if type_name == "Integer" else Model.Double)(
                     min_value=min_value,
-                    max_value=max_value)
+                    max_value=max_value,
+                    default_value=default_value)
         elif type_name == "String":
             min_length = self._extract_optional_number_attrib(
                 attrib, "minlength")
@@ -588,7 +595,8 @@ class Parser(object):
                 min_length = 1
             max_length = self._extract_optional_number_attrib(
                 attrib, "maxlength")
-            param_type = Model.String(min_length=min_length, max_length=max_length)
+            default_value = self._extract_attrib(attrib, "defvalue")
+            param_type = Model.String(min_length=min_length, max_length=max_length, default_value=default_value)
         else:
             if 1 == type_name.count("."):
                 custom_type_name = type_name.replace(".", "_")
@@ -597,6 +605,15 @@ class Parser(object):
 
             if custom_type_name in self._types:
                 param_type = self._types[custom_type_name]
+                default_value = self._extract_attrib(attrib, "defvalue")
+                if default_value != None:
+                    if default_value not in param_type.elements:
+                        raise ParseError("Default value '" + default_value +
+                                     "' for parameter '" + params["name"] +
+                                     "' is not a member of " +
+                                     type(param_type).__name__ +
+                                     "'" + params["name"] + "'")
+                    default_value = param_type.elements[default_value]
             else:
                 raise ParseError("Unknown type '" + type_name + "'")
 
@@ -608,7 +625,7 @@ class Parser(object):
             param_type = Model.Array(element_type=param_type,
                                      min_size=min_size,
                                      max_size=max_size)
-
+            
         base_type = \
             param_type.element_type if isinstance(param_type, Model.Array) \
             else param_type
@@ -662,6 +679,8 @@ class Parser(object):
             param_type = base_type
 
         params["param_type"] = param_type
+        if default_value is not None:
+            params["default_value"] = default_value
 
         return params, other_subelements, attrib