[SDL 0173] - Read Generic Network Signal Data Implementation (#2977)

* Generate policy enums from MOBILE_API

Policy manager HMI level enum reorder

* Add  RPC vehicle data and endpoint_properties to sdl_preloaded_pt

Set default version of custom vehicle data mapping

*  Add VehicleDataItem to policy table

SQL storage implementation for VehicleDataItems

Fix validation of double values in policy table

Change isDouble to isNumeric during validation double values

"0" should be validated as correct double value

Add validation vehicle data during PTU

Send in PT snapshot only version of custom VDI

 - During snapshot generation remove vehicle data items section
 - Add validation for Policy table depended on PT type

Fix wrong check for vehicle data snapshot

Allow empty vehicle data in PTU

Change max value of string for URL from 255 to INT_MAX

* Make Policy Handler forward declared to avoid high coupling

* Add vehicle_info_command_params for vehicle info plugin

Vehicle info params added to hmi commands

* Process CustomVehicleData in GetVehicleData request

* CustomVehicleDataManager implementation

* Process Custom vehicle data subscriptions

Refactored code.
Extracted CheckFrequency to separate method in class

* Check update of content of functional groups

Fixes https://github.com/smartdevicelink/sdl_core/issues/2962

Add additional check for functional group content
before OnPermissionChangeNotification.

* rename comparing functions to make more clear
their return value sense
* change variable names
* extra check for null values in HasNewGroups()

New unit test to cover changes within functional group

* Add GetPolicyConfigurationData

GetPolicyCOnfigurationData Implementation

* Add CustomVehicleData functionality for POLICY_EXTERNAL flow

Change max value url for external policy

fixes for external flow
* since unti validation for the database
* empty vehicle data validation

* Convert data_type to VehicleDataType enum value

* Validation of VehicleDataItem name and key

Introduces validation of vehicle_data_item
name and key validation:
* they should not contain spaces;
* they should not be empty or consist only spaces;
* they should not contain invalid chars like '!@#$%^&*'.

* Add engineOilLife to HMI_API

* Remove deprecated RPC GetUrls due to major version update

* Add ability to extend Smart schema with parameters

Extract SMember from CObjectSchemaItem

Add methods to ISchemaItem (Using composite pattern)
 - GetMemberSchemaItem
 - AddMemberSchemaItem

Add implementation of VehicleDataItemSchema class
Add appropriate unit tests

Add creation of vehicle_data items schemes on policy event

12 files changed, 1013 insertions, 191 deletions

diff --git a/tools/InterfaceGenerator/Generator.py b/tools/InterfaceGenerator/Generator.py
index 932620c153..905b0754b3 100755
--- a/tools/InterfaceGenerator/Generator.py
+++ b/tools/InterfaceGenerator/Generator.py
@@ -26,6 +26,7 @@ import generator.parsers.SDLRPCV2
 import generator.parsers.JSONRPC
 import generator.generators.SmartFactorySDLRPC
 import generator.generators.SmartFactoryJSONRPC
+import generator.generators.PolicyTypes
 import MsgVersionGenerate
 
 from generator.parsers.RPCBase import ParseError
@@ -37,7 +38,11 @@ SUPPORTED_FORMATS = {
     "sdlrpcv2": (generator.parsers.SDLRPCV2.Parser,
                  generator.generators.SmartFactorySDLRPC.CodeGenerator),
     "jsonrpc": (generator.parsers.JSONRPC.Parser,
-                generator.generators.SmartFactoryJSONRPC.CodeGenerator)
+                generator.generators.SmartFactoryJSONRPC.CodeGenerator),
+    "mobile-policy-types": (generator.parsers.SDLRPCV2.Parser,
+                generator.generators.PolicyTypes.CodeGenerator),
+    "hmi-policy-types": (generator.parsers.JSONRPC.Parser,
+                generator.generators.PolicyTypes.CodeGenerator)
 }
 
 
diff --git a/tools/InterfaceGenerator/generator/generators/PolicyTypes.py b/tools/InterfaceGenerator/generator/generators/PolicyTypes.py
new file mode 100644
index 0000000000..2621950e7a
--- /dev/null
+++ b/tools/InterfaceGenerator/generator/generators/PolicyTypes.py
@@ -0,0 +1,691 @@
+"""SmartFactory code generator base.
+
+Base of code generator for SmartFactory that provides SmartSchema object in
+accordance with given internal model.
+
+"""
+# pylint: disable=W0402
+# pylint: disable=C0302
+import codecs
+import collections
+import os
+import string
+import uuid
+import re
+
+from generator import Model
+
+
+class GenerateError(Exception):
+
+    """Generate error.
+
+    This exception is raised when generator is unable to create
+    output from given model.
+
+    """
+
+    pass
+
+def to_camel_case(snake_str):
+    components = snake_str.split('_')
+    return components[0].lower() + "".join(x.title() for x in components[1:])
+
+def to_snake_case(camel_str):
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', camel_str)
+    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1)
+
+class CodeGenerator(object):
+
+    """Base PolicyTypes generator.
+
+    This class provides service which allows to generate *.h files with types required for Policy
+
+    """
+
+    def __init__(self):
+        """Construct new object."""
+
+        self._generated_structs = []
+        self._structs_add_code = u""
+
+    def generate_vehicledatatype_names(self, enum):
+        template = string.Template('''static std::set<std::string> ${enum_name}_enum_names = { \n${values}\n};\n''')
+        enum_element_name = lambda enum_element: enum_element.internal_name if enum_element.internal_name else enum_element.name
+        values = ", \n".join(["  \"{}\"".format(enum_element_name(enum_element)) for enum_element in enum.elements.values()])
+        return template.substitute(enum_name=enum.name, values = values)
+
+    def generate_all_enum_values(self, enum):
+        template = string.Template('''static std::set<mobile_apis::${enum_name}::eType> ${enum_name}_all_enum_values = { \n${values}\n};\n''')
+        enum_element_name = lambda enum_element: enum_element.internal_name if enum_element.internal_name else enum_element.name
+        values = ", \n".join(["  mobile_apis::{}::{}".format(enum.name, enum_element_name(enum_element)) for enum_element in enum.elements.values()])
+        return template.substitute(enum_name=enum.name, values = values)
+
+    def generate_enums_schema_factory_content(self, enums):
+        return "\n".join([self._enum_factory_element_template.substitute(enum_name = enum.name) for enum in enums])
+
+    def generate_enums_schema_factory_impl(self, enums):
+        enums_values = ""
+        for enum in enums:
+            enums_values += "\n".join([self.generate_all_enum_values(enum)])
+            if enum.name == "VehicleDataType":
+                enums_values += "\n".join([self.generate_vehicledatatype_names(enum)])
+        return self._enum_factory_template.substitute(enums_values = enums_values,
+                                                      enum_factory_content = self.generate_enums_schema_factory_content(enums))
+
+    def generate_POD_types_schema_factory_impl(self, enums):
+        pod_types = {
+        "Integer" : "int32_t",
+        "Float" : "double",
+        }
+        '''if (enum_name == "DriverDistractionState") {
+                            return Get<mobile_apis::DriverDistractionState::eType>(DriverDistractionState_all_enum_values);
+                          }'''
+        enums_values = "\n".join([self.generate_all_enum_values(enum) for enum in enums])
+        return self._enum_factory_template.substitute(enums_values = enums_values,
+                                                      enum_factory_content = self.generate_enums_schema_factory_content(enums))
+
+    def generate(self, interface, filename, namespace, destination_dir):
+        """ Generate SmartFactory source files.
+
+        Generates source code files at destination directory in
+        accordance with given model in specified namespace.
+
+        Keyword arguments:
+        interface -- model of the interface to generate source code for.
+        filename -- name of initial XML file.
+        namespace -- name of destination namespace.
+        destination_dir -- directory to create source files.
+
+        """
+
+        if interface is None:
+            raise GenerateError("Given interface is None.")
+
+        params_set = set()
+        for func in interface.functions.values():
+            for param in func.params:
+                params_set.add(param)
+        parameter_enum = Model.Enum('Parameter')
+        
+        for item in params_set:
+            parameter_enum.elements[item.upper()] = Model.EnumElement(item)
+                
+
+        required_enums_for_policy = [
+            "HMILevel",
+            "FunctionID",
+            "HybridAppPreference",
+            "AppHMIType",
+            "RequestType",
+            "ModuleType",
+            "Common_AppPriority",
+            "Parameter"
+        ]
+
+        self.required_empty_value = [
+            "RequestType",
+            "ModuleType",
+            "Parameter"
+        ]
+
+        self.enum_items_naming_conversion_ = {
+            "HMILevel" :  lambda item_name : "HL_" + item_name.replace("HMI_", ""),
+            "AppHMIType" : lambda item_name : "AHT_" + item_name,
+            "FunctionID" : lambda item_name : item_name,
+            "HybridAppPreference" : lambda item_name : item_name,
+            "RequestType" : lambda item_name : "RT_" + item_name,
+            "ModuleType" : lambda item_name : "MT_" + item_name,
+            "Common_AppPriority" :  lambda item_name : "P_" + item_name if not item_name == "VOICE_COMMUNICATION" else "P_VOICECOM",
+            "Parameter" :  lambda item_name : "P_" + to_snake_case(item_name).upper()
+        }
+
+        self.enum_items_string_naming_conversion_ = {
+            "HMILevel" :  lambda item_name : item_name,
+            "AppHMIType" : lambda item_name : item_name,
+            "FunctionID" : lambda item_name : item_name[:item_name.rfind("ID")],
+            "HybridAppPreference" : lambda item_name : item_name,
+            "RequestType" : lambda item_name : item_name,
+            "ModuleType" : lambda item_name : item_name,
+            "Common_AppPriority" :  lambda item_name : item_name if not item_name == "VOICE_COMMUNICATION" else "VOICECOM",
+            "Parameter" :  lambda item_name : item_name
+        }
+
+        self.enum_naming_conversion_ = {
+            "HMILevel" : "HmiLevel",
+            "AppHMIType" : "AppHMIType",
+            "FunctionID" : "FunctionID",
+            "HybridAppPreference" : "HybridAppPreference",
+            "RequestType" : "RequestType",
+            "ModuleType" : "ModuleType",
+            "Common_AppPriority" : "Priority",
+            "Parameter" : "Parameter"
+        }
+
+        get_first_enum_value_name = lambda enum : enum.elements.values()[0].name
+        enum_required_for_policy = lambda enum : enum.name in required_enums_for_policy and "." not in get_first_enum_value_name(enum)
+
+        # In case if "." is in FunctionID name this is HMI_API function ID and should not be included in Policy  enums
+
+        required_enum_values = [val for val in interface.enums.values()
+                               if enum_required_for_policy(val)]
+
+        if filename == "MOBILE_API":
+            self._write_cc_with_enum_schema_factory(filename, namespace, destination_dir, interface.enums.values())
+
+            # Params should be generated as enum for MOBILE_API to validate RPCSpec parameters
+            required_enum_values.append(parameter_enum)
+
+        self._write_header_with_enums(filename, namespace, destination_dir, required_enum_values)
+        self._write_cc_with_enums(filename, namespace, destination_dir, required_enum_values)
+
+    def _write_cc_with_enum_schema_factory(self,filename, namespace, destination_dir, required_enum_values):
+        class_name = u"generated_{0}_enum_schema_factory".format(filename)
+        header_file_name = '''policy/policy_table/policy_enum_schema_factory.h'''
+        cc_file_name = u"".join("{0}.cc".format(class_name))
+        if not os.path.exists(destination_dir):
+            os.makedirs(destination_dir)
+        print(os.path.join(destination_dir, cc_file_name))
+        with codecs.open(os.path.join(destination_dir, cc_file_name),
+                         encoding="utf-8",
+                         mode="w") as f_cc:
+            guard = u"_{0}_{1}_CC__".format( class_name.upper(),
+                    unicode(uuid.uuid1().hex.capitalize()))
+            namespace_open, namespace_close = self._namespaces_strings(namespace)
+            includes = '''#include <set>\n'''\
+            '''#include "interfaces/MOBILE_API.h"\n'''\
+            '''#include "smart_objects/enum_schema_item.h"\n'''
+            f_cc.write(self._cc_file_template.substitute(
+                class_name=class_name,
+                header_file=header_file_name,
+                includes = includes,
+                namespace_open=namespace_open,
+                enums_content=self.generate_enums_schema_factory_impl(required_enum_values),
+                namespace_close=namespace_close))
+
+    def _write_header_with_enums(self,filename, namespace, destination_dir, required_enum_values):
+        class_name = u"generated_{0}_policy_types".format(filename)
+        header_file_name = u"".join("{0}.h".format(class_name))
+        if not os.path.exists(destination_dir):
+            os.makedirs(destination_dir)
+        with codecs.open(os.path.join(destination_dir, header_file_name),
+                         encoding="utf-8",
+                         mode="w") as f_h:
+            guard = u"_{0}_{1}_H__".format( class_name.upper(),
+                    unicode(uuid.uuid1().hex.capitalize()))
+            namespace_open, namespace_close = self._namespaces_strings(namespace)
+            f_h.write(self._h_file_template.substitute(
+                class_name=class_name,
+                guard=guard,
+                includes="",
+                namespace_open=namespace_open,
+                enums_content=self._gen_enums(required_enum_values
+                    ),
+                namespace_close=namespace_close))
+
+    def _write_cc_with_enums(self,filename, namespace, destination_dir, required_enum_values):
+        class_name = u"generated_{0}_policy_types".format(filename)
+        header_file_name = u"".join("{0}.h".format(class_name))
+        cc_file_name = u"".join("{0}.cc".format(class_name))
+        if not os.path.exists(destination_dir):
+            os.makedirs(destination_dir)
+        with codecs.open(os.path.join(destination_dir, cc_file_name),
+                         encoding="utf-8",
+                         mode="w") as f_cc:
+            guard = u"_{0}_{1}_CC__".format( class_name.upper(),
+                    unicode(uuid.uuid1().hex.capitalize()))
+            namespace_open, namespace_close = self._namespaces_strings(namespace)
+            f_cc.write(self._cc_file_template.substitute(
+                class_name=class_name,
+                header_file=header_file_name,
+                includes="",
+                namespace_open=namespace_open,
+                enums_content=self.gen_enums_processing(required_enum_values
+                    ),
+                namespace_close=namespace_close))
+
+    def _namespaces_strings(self, namespace):
+
+        """ Generate open and close namespaces strings
+
+        Generates source code for opening and close namespaces
+
+        Keyword arguments:
+        namespace -- name of destination namespace.
+
+        Returns:
+        Tuple with namespace open string and namespace close string
+        """
+
+        namespace = unicode(namespace)
+        namespace_open = u""
+        namespace_close = u""
+        if namespace:
+            parts = namespace.split(u"::")
+            for part in parts:
+                namespace_open = u"".join(
+                    [namespace_open,
+                     self._namespace_open_template.substitute(name=part)])
+                namespace_close = u"".join(
+                    [namespace_close,
+                     "}} // {0}\n".format(part)])
+
+        return namespace_open, namespace_close
+
+
+    def _gen_enums(self, enums):
+        """Generate enums for header file.
+
+        Generates declaration of enumerations for the header file.
+
+        Keyword arguments:
+        enums -- list of enums to generate.
+
+        Returns:
+        String with enums declaration source code.
+
+        """
+
+        if enums is None:
+            raise GenerateError("Enums is None")
+
+        return u"\n".join([self._gen_enum(x) for x in enums])
+
+    def _gen_enum(self, enum):
+        """Generate enum for header file.
+
+        Generates declaration of enumeration for the header file.
+
+        Keyword arguments:
+        enum -- enum to generate.
+
+        Returns:
+        String with enum declaration source code.
+
+        """
+
+        enum_elements = enum.elements.values()
+        return self._enum_template.substitute(
+            comment=self._gen_comment(enum),
+            name=self.enum_naming_conversion_[enum.name],
+            enum_items=self._indent_code(self._gen_enum_elements(
+                enum_elements, enum.name), 1))
+
+    def _gen_enum_elements(self, enum_elements, enum_name):
+        """Generate enum elements for header file.
+
+        Generates declaration of enumeration elements for the header file.
+
+        Keyword arguments:
+        enum_elements -- list of enum elements to generate.
+
+        Returns:
+        String with enum elements declaration source code.
+
+        """
+        enum_elements = [self._gen_enum_element(x, enum_name)
+                              for x in enum_elements]
+        if (enum_name in self.required_empty_value):
+            enum_elements.append(self._gen_empty_enum_element(enum_name))
+        return u",\n\n".join(enum_elements)
+
+    def _gen_empty_enum_element(self, enum_name) :
+        return self._enum_element_with_value_template.substitute(
+                comment="",
+                name=self.enum_items_naming_conversion_[enum_name]("EMPTY"),
+                value=-1)
+
+    def _gen_enum_element(self, enum_element, enum_name):
+        """Generate enum element for header file.
+
+        Generates declaration of enumeration element for the header file.
+
+        Keyword arguments:
+        enum_element -- enum element to generate.
+
+        Returns:
+        String with enum element declaration source code.
+
+        """
+
+        if enum_element.value is not None:
+            return self._enum_element_with_value_template.substitute(
+                comment=self._gen_comment(enum_element),
+                name=self.enum_items_naming_conversion_[enum_name](enum_element.primary_name),
+                value=enum_element.value)
+        else:
+            return self._enum_element_with_no_value_template.substitute(
+                comment=self._gen_comment(enum_element),
+                name=self.enum_items_naming_conversion_[enum_name](enum_element.primary_name))
+
+    def gen_enums_processing(self, enums):
+        validation = "\n".join([self._gen_enum_validation(enum) for enum in enums])
+        to_json = "\n".join([self._gen_enum_to_json(enum) for enum in enums])
+        from_json = "\n".join([self._gen_enum_from_json(enum) for enum in enums])
+        return "\n".join([validation, to_json, from_json])
+
+    def _gen_enum_validation(self, enum):
+        return self._valiation_enum_template.substitute(
+            name = self.enum_naming_conversion_[enum.name],
+            enum_items = "\n".join([self._gen_enum_item_validation(enum_item.name, enum.name) for enum_item in enum.elements.values()])
+        )
+
+    def _gen_enum_item_validation(self, item_name, enum_name):
+        return self._valiation_enum_item_template.substitute(
+            name = self.enum_items_naming_conversion_[enum_name](item_name))
+
+    def _gen_enum_to_json(self, enum):
+        name = self.enum_naming_conversion_[enum.name]
+        enum_items = "\n".join([self._gen_enum_item_to_json(enum_item.name, enum.name) for enum_item in enum.elements.values()])
+        if (enum.name in self.required_empty_value):
+            enum_items+= "\n" + self._gen_enum_item_to_json("EMPTY", enum.name)
+        return self._enum_to_json_template.substitute(
+            name = name,
+            enum_items = enum_items
+        )
+
+    def _gen_enum_item_to_json(self, item_name, enum_name):
+        return self._enum_to_json_item_template.substitute(
+            name =  self.enum_items_naming_conversion_[enum_name](item_name),
+            string_name = self.enum_items_string_naming_conversion_[enum_name](item_name)
+            )
+
+
+    def _gen_enum_from_json(self, enum):
+        name = self.enum_naming_conversion_[enum.name]
+        enum_items = "\n".join([self._gen_enum_item_from_json(enum_item.name, enum.name) for enum_item in enum.elements.values()])
+        if (enum.name in self.required_empty_value):
+            enum_items += "\n" + self._gen_enum_item_from_json("EMPTY", enum.name)
+        return self._enum_from_json_template.substitute(
+            name = name,
+            enum_items = enum_items
+        )
+
+    def _gen_enum_item_from_json(self, item_name, enum_name):
+        return self._enum_from_json_item_template.substitute(
+            name = self.enum_items_naming_conversion_[enum_name](item_name),
+            string_name = self.enum_items_string_naming_conversion_[enum_name](item_name)
+            )
+
+    def _gen_comment(self, interface_item_base, use_doxygen=True):
+        """Generate doxygen comment for iterface_item_base for header file.
+
+        Generates doxygen comment for any iterface_item_base for the header
+        file.
+
+        Keyword arguments:
+        interface_item_base -- object to generate doxygen comment for.
+        use_doxygen -- Flag that indicates does function uses doxygen or not.
+
+        Returns:
+        String with generated doxygen comment.
+
+        """
+
+        brief_type_title = None
+        interface_item_base_classname = interface_item_base.__class__.__name__
+        if interface_item_base_classname in self._model_types_briefs:
+            brief_type_title = \
+                self._model_types_briefs[interface_item_base_classname]
+        else:
+            raise GenerateError("Unable to create comment for unknown type " +
+                                interface_item_base_classname)
+
+        name = interface_item_base.primary_name if \
+            type(interface_item_base) is Model.EnumElement else \
+            interface_item_base.name
+        brief_description = (u" * @brief {0}{1}.\n" if use_doxygen is
+                             True else u"// {0}{1}.\n").format(
+                                 brief_type_title,
+                                 name)
+
+        description = u"".join([(u" * {0}\n" if use_doxygen
+                                is True else u"// {0}\n").format(x)
+                                for x in self._normalize_multiline_comments(
+                                    interface_item_base.description)])
+        if description is not u"":
+            description = u"".join([u" *\n" if use_doxygen
+                                    is True else u"//\n", description])
+
+        design_description = u"".join([(u" * {0}\n" if use_doxygen is
+                                       True else u"// {0}\n").format(x)
+                                       for x in
+                                       self._normalize_multiline_comments(
+                                           interface_item_base.
+                                           design_description)])
+        if design_description is not u"":
+            design_description = u"".join([u" *\n" if use_doxygen is
+                                           True else "//\n",
+                                           design_description])
+
+        issues = u"".join([(u" * @note {0}\n" if use_doxygen is
+                           True else u"// Note: {0}\n").format(x)
+                           for x in self._normalize_multiline_comments(
+                               [x.value for x in interface_item_base.issues])])
+        if issues is not u"":
+            issues = u"".join([u" *\n" if use_doxygen is
+                              True else u"//\n", issues])
+
+        todos = u"".join([(u" * @todo {0}\n" if use_doxygen is
+                          True else u"// ToDo: {0}\n").format(x)
+                          for x in self._normalize_multiline_comments(
+                              interface_item_base.todos)])
+        if todos is not u"":
+            todos = u"".join([u" *\n" if use_doxygen is
+                              True else u"//\n", todos])
+
+        returns = u""
+        if type(interface_item_base) is Model.Function:
+            returns = u"".join([u" *\n", self._function_return_comment])
+
+        template = self._comment_doxygen_template if use_doxygen is \
+            True else self._comment_cc_template
+
+        return template.substitute(
+            brief_description=brief_description,
+            description=description,
+            design_description=design_description,
+            issues=issues,
+            todos=todos,
+            returns=returns)
+
+    def _indent_code(self, code, indent_level):
+        """Indent given source code.
+
+        Indents given source code right by given indentation level.
+
+        Keyword arguments:
+        code -- given source code.
+        indent_level -- desired indentation level.
+
+        Returns:
+        String with processed code.
+
+        """
+
+        code_lines = code.split("\n")
+        return u"".join(
+            [u"{0}{1}\n".format(
+                self._indent_template * indent_level,
+                x) if x is not u"" else u"\n" for x in code_lines])
+
+    @staticmethod
+    def _normalize_multiline_comments(initial_strings):
+        """Normalize multiline comments.
+
+        Makes multiline comment clean of any line breaks creating additional
+        strings for the comment.
+
+        Keyword arguments:
+        initial_strings -- initial list of strings to process.
+
+        Returns:
+        New list of the strings (with contains no strings with line breaks).
+
+        """
+
+        result = []
+        for initial_string in initial_strings:
+            result = result + initial_string.splitlines()
+        return result
+
+    _model_types_briefs = dict(
+        {u"EnumElement": u"",
+         u"Enum": u"Enumeration ",
+         u"Function": u"Method that generates schema for function ",
+         u"Struct": u"Method that generates schema item for structure ",
+         u"Param": u"Struct member ",
+         u"FunctionParam": u"Function parameter "})
+
+    _cc_file_template = string.Template(
+        u'''/**\n'''
+        u''' * @file ${class_name}.h\n'''
+        u''' * @brief Generated class ${class_name} source file.\n'''
+        u''' *\n'''
+        u'''*/\n'''
+        u'''#include "${header_file}"\n'''
+        u'''${includes}'''
+        u'''\n\n'''
+        u'''$namespace_open'''
+        u'''\n'''
+        u'''$enums_content'''
+        u'''\n'''
+        u'''$namespace_close'''
+        u'''\n\n''')
+
+
+    _h_file_template = string.Template(
+        u'''/**\n'''
+        u''' * @file ${class_name}.h\n'''
+        u''' * @brief Generated class ${class_name} header file.\n'''
+        u''' *\n'''
+        u'''* Copyright (c) 2017, Ford Motor Company\n'''
+        u'''* All rights reserved.\n'''
+        u'''*\n'''
+        u'''* Redistribution and use in source and binary forms, with or without\n'''
+        u'''* modification, are permitted provided that the following conditions are met:\n'''
+        u'''*\n'''
+        u'''* Redistributions of source code must retain the above copyright notice, this\n'''
+        u'''* list of conditions and the following disclaimer.\n'''
+        u'''*\n'''
+        u'''* Redistributions in binary form must reproduce the above copyright notice,\n'''
+        u'''* this list of conditions and the following\n'''
+        u'''* disclaimer in the documentation and/or other materials provided with the\n'''
+        u'''* distribution.\n'''
+        u'''*\n'''
+        u'''* Neither the name of the Ford Motor Company nor the names of its contributors\n'''
+        u'''* may be used to endorse or promote products derived from this software\n'''
+        u'''* without specific prior written permission.\n'''
+        u'''*\n'''
+        u'''* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\n'''
+        u'''* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n'''
+        u'''* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n'''
+        u'''* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n'''
+        u'''* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n'''
+        u'''* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n'''
+        u'''* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n'''
+        u'''* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n'''
+        u'''* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n'''
+        u'''* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n'''
+        u'''* POSSIBILITY OF SUCH DAMAGE.\n'''
+        u'''*/\n'''
+        u'''\n'''
+        u'''#ifndef $guard\n'''
+        u'''#define $guard\n'''
+        u'''#include <string>\n'''
+        u'''${includes}'''
+        u'''\n'''
+        u'''$namespace_open'''
+        u'''$enums_content'''
+        u'''$namespace_close'''
+        u'''#endif //$guard\n'''
+        u'''\n\n''')
+
+
+    _namespace_open_template = string.Template(
+        u'''namespace $name {\n''')
+
+    _comment_doxygen_template = string.Template(
+        u'''/**\n'''
+        u'''$brief_description'''
+        u'''$description'''
+        u'''$design_description'''
+        u'''$issues'''
+        u'''$todos'''
+        u'''$returns */''')
+
+    _enum_template = string.Template(
+        u'''$comment\n'''
+        u'''enum $name {\n'''
+        u'''$enum_items};\n'''
+        u'''bool IsValidEnum($name val);\n'''
+        u'''const char* EnumToJsonString($name val);\n'''
+        u'''bool EnumFromJsonString(const std::string& literal, $name* result);\n'''
+        )
+    _valiation_enum_template = string.Template(
+        u'''bool IsValidEnum($name val) {\n'''
+        u'''  return !(std::string(EnumToJsonString(val)).empty());\n'''
+        u'''};\n''')
+
+    _valiation_enum_item_template = string.Template(
+        u'''    case $name: return true;''')
+
+    _enum_to_json_template = string.Template(
+        u'''const char* EnumToJsonString($name val) {\n'''
+        u'''  switch (val) {\n'''
+        u'''$enum_items\n'''
+        u'''    default: return "";\n'''
+        u'''  }\n'''
+        u'''};\n''')
+
+    _enum_to_json_item_template = string.Template(
+        u'''    case $name: return "$string_name";''')
+
+    _enum_from_json_template = string.Template(
+        u'''bool EnumFromJsonString(const std::string& literal, $name* result) {\n'''
+        u'''$enum_items'''
+        u'''  return false;\n'''
+        u'''};\n''')
+
+    _enum_from_json_item_template = string.Template(
+        u'''  if ("$string_name" == literal) {\n'''
+        u'''    *result = $name;\n'''
+        u'''    return true;\n'''
+        u'''  }\n''')
+
+    _enum_element_with_value_template = string.Template(
+        u'''$comment\n'''
+        u'''$name = $value''')
+
+    _enum_element_with_no_value_template = string.Template(
+        u'''$comment\n'''
+        u'''$name''')
+    _enum_factory_template = string.Template(
+        '''${enums_values}\n'''
+        '''template<typename EnumType>\n'''
+        '''std::shared_ptr<smart_objects::ISchemaItem> Create(const std::set<EnumType>& all_enum_values) {\n'''
+        '''using namespace smart_objects;\n'''
+        '''  static auto schemaItem = TEnumSchemaItem<EnumType>::create(all_enum_values, TSchemaItemParameter<EnumType>());\n'''
+        '''  return schemaItem;\n'''
+        '''}\n\n'''
+        '''std::shared_ptr<smart_objects::ISchemaItem> EnumSchemaItemFactory::Get(const std::string & enum_name) {\n'''
+        '''${enum_factory_content}\n'''
+        '''  return std::shared_ptr<smart_objects::ISchemaItem>();\n'''
+        '''}\n\n'''
+        '''bool EnumSchemaItemFactory::IsRPCSpecVehicleDataType(const std::string& vd_name) {\n'''
+        '''  for(auto& item_name : VehicleDataType_enum_names) {\n'''
+        '''    if (vd_name == item_name) {\n'''
+        '''      return true;\n'''
+        '''   }\n'''
+        '''  }\n'''
+        '''  return false;\n'''
+        '''}\n''')
+    _enum_factory_element_template = string.Template(
+        '''  if (enum_name == "${enum_name}") {\n'''
+        '''    return Create<mobile_apis::${enum_name}::eType>(${enum_name}_all_enum_values);\n'''
+        '''  }''')
+    _POD_type_factory_element_template = string.Template(
+        '''  if (typename == "${type_name}") {\n'''
+        '''    return TNumberSchemaItem<${cpp_type}>::create(TSchemaItemParameter<double>(${min_val}), TSchemaItemParameter<double>(${${max_val}}), TSchemaItemParameter<${cpp_type}>());'''
+        '''  }''')
+    _indent_template = u"  "
diff --git a/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py b/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py
index c6a0145ac6..86d238ef69 100755
--- a/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py
+++ b/tools/InterfaceGenerator/generator/generators/SmartFactoryBase.py
@@ -93,7 +93,7 @@ class CodeGenerator(object):
         with codecs.open(os.path.join(destination_dir, header_file_name),
                          encoding="utf-8",
                          mode="w") as f_h:
-            f_h.write(self._h_file_tempalte.substitute(
+            f_h.write(self._h_file_template.substitute(
                 class_name=class_name,
                 guard=guard,
                 namespace_open=namespace_open,
@@ -131,7 +131,7 @@ class CodeGenerator(object):
         with codecs.open(os.path.join(destination_dir, header_file_name),
                          encoding="utf-8",
                          mode="w") as f_h:
-            f_h.write(self._hpp_schema_file_tempalte.substitute(
+            f_h.write(self._hpp_schema_file_template.substitute(
                 class_name=class_name,
                 guard=guard,
                 header_file_name=unicode("".join("{0}.h".format(class_name))),
@@ -157,6 +157,8 @@ class CodeGenerator(object):
                     interface.functions.values()),
                 function_schemas=self._gen_function_schemas(
                     interface.functions.values()),
+                function_schemas_switch=self._gen_function_schema_switch(
+                    interface.functions.values()),
                 init_function_impls=self._gen_function_impls(
                     interface.functions.values(),
                     namespace,
@@ -450,6 +452,48 @@ class CodeGenerator(object):
             self._gen_function_schema(x), 1)
             for x in functions])
 
+    def _gen_function_schema_switch(self, functions):
+        """Generate initialization code of each function for source file.
+
+        Generates function schema initialization code that should be used
+        in the source file.
+
+        Keyword arguments:
+        function -- function to generate method for.
+
+        Returns:
+        String with switch for functions initialization source code.
+
+        """
+
+        if functions is None:
+            raise GenerateError("Functions is None")
+
+        def function_id_switch(self, message_type, functions):
+            case_list = [self._function_id_case_template.substitute(
+                function_id=x.function_id.primary_name,
+                message_type=x.message_type.primary_name)
+            for x in functions if x.message_type.primary_name == message_type ]
+            case_list.append("default:\n  break;\n")
+            switch_function_id_cases =  self._indent_code(u"".join(case_list), 1)[:-1]
+
+            return self._indent_code(self._function_switch_template.substitute(
+                switchable="function_id",
+                cases=switch_function_id_cases
+            ), 1)[:-1]
+
+        message_type_case_list = [self._message_type_case_template.substitute(
+                message_type = message_type,
+                case_body = function_id_switch(self, message_type, functions)
+            ) for message_type in set([x.message_type.primary_name for x in functions])]
+        message_type_case_list.append("default:\n  break;\n")
+        message_type_cases = self._indent_code(u"".join(message_type_case_list), 1)[:-1]
+
+        return self._indent_code(self._function_switch_template.substitute(
+            switchable="message_type",
+            cases=message_type_cases
+        ), 1)[:-1]
+
     def _gen_function_schema(self, function):
         """Generate function initialization code for source file.
 
@@ -1361,7 +1405,7 @@ class CodeGenerator(object):
          u"Param": u"Struct member ",
          u"FunctionParam": u"Function parameter "})
 
-    _h_file_tempalte = string.Template(
+    _h_file_template = string.Template(
         u'''/**\n'''
         u''' * @file ${class_name}.h\n'''
         u''' * @brief Generated class ${class_name} header file.\n'''
@@ -1426,7 +1470,7 @@ class CodeGenerator(object):
         u'''#endif //$guard\n'''
         u'''\n\n''')
 
-    _hpp_schema_file_tempalte = string.Template(
+    _hpp_schema_file_template = string.Template(
         u'''/**\n'''
         u''' * @file ${class_name}.h\n'''
         u''' * @brief Generated class ${class_name} header file.\n'''
@@ -1488,6 +1532,7 @@ class CodeGenerator(object):
         u'''#include "formatters/CSmartFactory.h"\n'''
         u'''#include "smart_objects/smart_schema.h"\n'''
         u'''#include "smart_objects/schema_item.h"\n'''
+        u'''#include "smart_objects/object_schema_item.h"\n'''
         u'''#include "$header_file_name"\n'''
         u'''\n'''
         u'''$namespace_open'''
@@ -1604,6 +1649,32 @@ class CodeGenerator(object):
         u'''CAlwaysFalseSchemaItem::create();\n'''
         u'''}\n'''
         u'''\n'''
+        u'''bool $namespace::$class_name::AddCustomMember(FunctionID::eType function_id,\n'''
+        u'''                                              messageType::eType message_type,\n'''
+        u'''                                              std::string member_key, ns_smart_device_link::ns_smart_objects::SMember member) {\n'''
+        u'''  using namespace ns_smart_device_link::ns_json_handler;\n'''
+        u'''  using namespace ns_smart_device_link::ns_smart_objects;\n'''
+        u'''  SmartSchemaKey<FunctionID::eType, messageType::eType> shema_key(function_id, message_type);\n'''
+        u'''  auto function_schema = functions_schemes_.find(shema_key);\n'''
+        u'''  if (functions_schemes_.end() == function_schema){\n'''
+        u'''    return false;\n'''
+        u'''  }\n'''
+        u'''\n'''
+        u'''  auto schema = function_schema->second.getSchemaItem();\n'''
+        u'''  auto msg_params_schema_item = schema->GetMemberSchemaItem(ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS);\n'''
+        u'''  if (!msg_params_schema_item.is_initialized()){\n'''
+        u'''    return false;\n'''
+        u'''  }\n'''
+        u'''\n'''
+        u'''  msg_params_schema_item->mSchemaItem->AddMemberSchemaItem(member_key, member);\n'''
+        u'''  return true;\n'''
+        u'''}\n'''
+        u'''\n'''
+        u'''void $namespace::$class_name::ResetFunctionSchema(FunctionID::eType function_id,\n'''
+        u'''                         messageType::eType message_type) {\n'''
+        u'''  InitFunctionSchema(function_id, message_type);\n'''
+        u'''}\n'''
+        u'''\n'''
         u'''void $namespace::$class_name::InitStructSchemes(\n'''
         u'''    TStructsSchemaItems &struct_schema_items) {'''
         u'''$struct_schema_items'''
@@ -1617,6 +1688,19 @@ class CodeGenerator(object):
         u'''$function_schemas'''
         u'''}\n'''
         u'''\n'''
+        u'''void $namespace::$class_name::InitFunctionSchema(\n'''
+        u'''    const FunctionID::eType &function_id,\n'''
+        u'''    const messageType::eType &message_type) {\n'''
+        u'''\n'''
+        u'''  TStructsSchemaItems struct_schema_items;\n'''
+        u'''  InitStructSchemes(struct_schema_items);\n'''
+        u'''\n'''
+        u'''  std::set<FunctionID::eType> function_id_items { function_id };\n'''
+        u'''  std::set<messageType::eType> message_type_items { message_type };\n'''
+        u'''\n'''
+        u'''$function_schemas_switch'''
+        u'''}\n'''
+        u'''\n'''
         u'''//------------- Functions schemes initialization -------------\n'''
         u'''\n'''
         u'''$init_function_impls'''
@@ -1668,6 +1752,26 @@ class CodeGenerator(object):
         u'''};\n'''
         u'''\n''')
 
+    _function_switch_template = string.Template(
+        u'''switch(${switchable}) {\n'''
+        u'''${cases}'''
+        u'''}\n''')
+
+    _message_type_case_template = string.Template(
+        u'''case messageType::${message_type}: {\n'''
+        u'''${case_body}'''
+        u'''  break;\n'''
+        u'''}\n''')
+
+    _function_id_case_template = string.Template(
+        u'''case FunctionID::${function_id}: {\n'''
+        u'''  ns_smart_device_link::ns_json_handler::SmartSchemaKey<FunctionID::eType, messageType::eType> shema_key(function_id, message_type);\n'''
+        u'''  functions_schemes_[shema_key] = '''
+        u'''InitFunction_${function_id}_${message_type}('''
+        u'''struct_schema_items, function_id_items, message_type_items);\n'''
+        u'''  break;\n'''
+        u'''}\n''')
+
     _struct_schema_item_template = string.Template(
         u'''std::shared_ptr<ISchemaItem> struct_schema_item_${name} = '''
         u'''InitStructSchemaItem_${name}(struct_schema_items);\n'''
@@ -1695,7 +1799,7 @@ class CodeGenerator(object):
     _struct_impl_code_tempate = string.Template(
         u'''${schema_loc_decl}'''
         u'''${schema_items_decl}'''
-        u'''CObjectSchemaItem::Members '''
+        u'''Members '''
         u'''schema_members;\n\n'''
         u'''${schema_item_fill}'''
         u'''return CObjectSchemaItem::create(schema_members);''')
@@ -1724,10 +1828,10 @@ class CodeGenerator(object):
         u'''std::shared_ptr<ISchemaItem> ${var_name} = ${item_decl};''')
 
     _impl_code_shared_ptr_vector_template = string.Template(
-        u'''std::vector<CObjectSchemaItem::SMember> ${var_name}_history_vector;''')
+        u'''std::vector<SMember> ${var_name}_history_vector;''')
 
     _impl_code_append_history_vector_template = string.Template(
-        u'''${vector_name}_history_vector.push_back(CObjectSchemaItem::SMember(${name}_SchemaItem, ${mandatory}, "${since}", "${until}", ${deprecated}, ${removed}));''')
+        u'''${vector_name}_history_vector.push_back(SMember(${name}_SchemaItem, ${mandatory}, "${since}", "${until}", ${deprecated}, ${removed}));''')
 
     _impl_code_integer_item_template = string.Template(
         u'''TNumberSchemaItem<${type}>::create(${params})''')
@@ -1755,16 +1859,13 @@ class CodeGenerator(object):
         u'''TSchemaItemParameter<$type>($value)''')
 
     _impl_code_item_fill_template = string.Template(
-        u'''schema_members["${name}"] = CObjectSchemaItem::'''
-        u'''SMember(${var_name}, ${is_mandatory});''')
+        u'''schema_members["${name}"] = SMember(${var_name}, ${is_mandatory});''')
 
     _impl_code_item_fill_template_with_version = string.Template(
-        u'''schema_members["${name}"] = CObjectSchemaItem::'''
-        u'''SMember(${var_name}, ${is_mandatory}, "${since}", "${until}", ${deprecated}, ${removed});''')
+        u'''schema_members["${name}"] = SMember(${var_name}, ${is_mandatory}, "${since}", "${until}", ${deprecated}, ${removed});''')
 
     _impl_code_item_fill_template_with_version_and_history_vector = string.Template(
-        u'''schema_members["${name}"] = CObjectSchemaItem::'''
-        u'''SMember(${var_name}, ${is_mandatory}, "${since}", "${until}", ${deprecated}, ${removed}, ${vector_name}_history_vector);''')
+        u'''schema_members["${name}"] = SMember(${var_name}, ${is_mandatory}, "${since}", "${until}", ${deprecated}, ${removed}, ${vector_name}_history_vector);''')
 
     _function_impl_template = string.Template(
         u'''CSmartSchema $namespace::$class_name::'''
@@ -1778,22 +1879,22 @@ class CodeGenerator(object):
     _function_impl_code_tempate = string.Template(
         u'''${schema_loc_decl}'''
         u'''${schema_items_decl}'''
-        u'''CObjectSchemaItem::Members '''
+        u'''Members '''
         u'''schema_members;\n\n'''
         u'''${schema_item_fill}'''
-        u'''CObjectSchemaItem::Members '''
+        u'''Members '''
         u'''params_members;\n'''
         u'''${schema_params_fill}'''
         u'''\n'''
-        u'''CObjectSchemaItem::Members '''
+        u'''Members '''
         u'''root_members_map;\n'''
         u'''root_members_map[ns_smart_device_link::ns_json_handler::'''
         u'''strings::S_MSG_PARAMS] = '''
-        u'''CObjectSchemaItem::SMember(CObjectSchemaItem::'''
+        u'''SMember(CObjectSchemaItem::'''
         u'''create(schema_members), true);\n'''
         u'''root_members_map[ns_smart_device_link::ns_json_handler::'''
         u'''strings::S_PARAMS] = '''
-        u'''CObjectSchemaItem::SMember(CObjectSchemaItem::'''
+        u'''SMember(CObjectSchemaItem::'''
         u'''create(params_members), true);\n\n'''
         u'''return CSmartSchema(CObjectSchemaItem::'''
         u'''create(root_members_map));''')
@@ -1809,7 +1910,19 @@ class CodeGenerator(object):
         u'''   */\n'''
         u'''  $class_name();\n'''
         u'''\n'''
-        u''' protected:\n'''
+        u'''  /**\n'''
+        u'''   * @brief Adds custom members to existing list of params.\n'''
+        u'''   */\n'''
+        u'''  bool AddCustomMember(FunctionID::eType function_id,\n'''
+        u'''                       messageType::eType message_type,\n'''
+        u'''                       std::string member_key, ns_smart_device_link::ns_smart_objects::SMember member);\n'''
+        u'''\n'''
+        u'''  /**\n'''
+        u'''   * @brief Reset function schema to state defined in API.\n'''
+        u'''   */\n'''
+        u'''  void ResetFunctionSchema(FunctionID::eType function_id,\n'''
+        u'''                           messageType::eType message_type);\n'''
+        u'''\n'''
         u'''  /**\n'''
         u'''   * @brief Type that maps of struct IDs to schema items.\n'''
         u'''   */\n'''
@@ -1817,6 +1930,7 @@ class CodeGenerator(object):
         u'''std::shared_ptr<ns_smart_device_link::ns_smart_objects::'''
         u'''ISchemaItem> > TStructsSchemaItems;\n'''
         u'''\n'''
+        u''' protected:\n'''
         u'''  /**\n'''
         u'''   * @brief Helper that allows to make reference to struct\n'''
         u'''   *\n'''
@@ -1852,8 +1966,19 @@ class CodeGenerator(object):
         u'''      const std::set<messageType::eType> '''
         u'''&message_type_items);\n'''
         u'''\n'''
+        u'''  /**\n'''
+        u'''   * @brief Initializes single function schema.\n'''
+        u'''   *\n'''
+        u'''   * @param function_id Function ID of schema to be initialized.\n'''
+        u'''   * @param message_type Message type of schema to be initialized.\n'''
+        u'''   */\n'''
+        u'''  void InitFunctionSchema(\n'''
+        u'''      const FunctionID::eType &function_id,\n'''
+        u'''      const messageType::eType &message_type);\n'''
+        u'''\n'''
         u'''$init_function_decls'''
         u'''\n'''
+        u''' public:\n'''
         u'''$init_struct_decls'''
         u'''};''')
 
diff --git a/tools/InterfaceGenerator/generator/generators/SmartFactoryJSONRPC.py b/tools/InterfaceGenerator/generator/generators/SmartFactoryJSONRPC.py
index 6924ec67aa..07b55382a6 100755
--- a/tools/InterfaceGenerator/generator/generators/SmartFactoryJSONRPC.py
+++ b/tools/InterfaceGenerator/generator/generators/SmartFactoryJSONRPC.py
@@ -100,35 +100,35 @@ class CodeGenerator(SmartFactoryBase.CodeGenerator):
         u'''error_response_schema));\n''')
 
     _error_response_schema_template = (
-        u'''CObjectSchemaItem::Members '''
+        u'''Members '''
         u'''params_members;\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember('''
+        u'''strings::S_FUNCTION_ID] = SMember('''
         u'''TEnumSchemaItem<FunctionID::eType>::create('''
         u'''function_id_items), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember('''
+        u'''strings::S_MESSAGE_TYPE] = SMember('''
         u'''TEnumSchemaItem<messageType::eType>::create('''
         u'''message_type_items), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember('''
+        u'''strings::S_PROTOCOL_VERSION] = SMember('''
         u'''TNumberSchemaItem<int>::create(), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember('''
+        u'''strings::S_PROTOCOL_TYPE] = SMember('''
         u'''TNumberSchemaItem<int>::create(), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember('''
+        u'''strings::S_CORRELATION_ID] = SMember('''
         u'''TNumberSchemaItem<int>::create(), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::kCode] = CObjectSchemaItem::SMember('''
+        u'''strings::kCode] = SMember('''
         u'''TNumberSchemaItem<int>::create(), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::kMessage] = CObjectSchemaItem::SMember('''
+        u'''strings::kMessage] = SMember('''
         u'''CStringSchemaItem::create(), true);\n'''
         u'''\n'''
-        u'''CObjectSchemaItem::Members root_members_map;\n'''
+        u'''Members root_members_map;\n'''
         u'''root_members_map[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_PARAMS] = CObjectSchemaItem::SMember('''
+        u'''strings::S_PARAMS] = SMember('''
         u'''CObjectSchemaItem::create(params_members), true);\n'''
         u'''\n'''
         u'''CSmartSchema error_response_schema('''
@@ -137,29 +137,23 @@ class CodeGenerator(SmartFactoryBase.CodeGenerator):
 
     _base_params = (
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_FUNCTION_ID] = CObjectSchemaItem::'''
-        u'''SMember(TEnumSchemaItem<FunctionID::eType>::'''
+        u'''strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::'''
         u'''create(function_id_items), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_MESSAGE_TYPE] = CObjectSchemaItem::'''
-        u'''SMember(TEnumSchemaItem<messageType::eType>::'''
+        u'''strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::'''
         u'''create(message_type_items), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::'''
-        u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+        u'''strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);\n'''
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::'''
-        u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+        u'''strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);\n'''
     )
 
     _correlation_id_param = (
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::S_CORRELATION_ID] = CObjectSchemaItem::'''
-        u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+        u'''strings::S_CORRELATION_ID] = SMember(TNumberSchemaItem<int>::create(), true);\n'''
     )
 
     _additional_response_params = (
         u'''params_members[ns_smart_device_link::ns_json_handler::'''
-        u'''strings::kCode] = CObjectSchemaItem::'''
-        u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+        u'''strings::kCode] = SMember(TNumberSchemaItem<int>::create(), true);\n'''
     )
diff --git a/tools/InterfaceGenerator/generator/generators/SmartFactorySDLRPC.py b/tools/InterfaceGenerator/generator/generators/SmartFactorySDLRPC.py
index c3244f7e95..f82c7bb808 100755
--- a/tools/InterfaceGenerator/generator/generators/SmartFactorySDLRPC.py
+++ b/tools/InterfaceGenerator/generator/generators/SmartFactorySDLRPC.py
@@ -68,24 +68,19 @@ class CodeGenerator(SmartFactoryBase.CodeGenerator):
 
         base_params = \
             u'''params_members[ns_smart_device_link::ns_json_handler::''' \
-            u'''strings::S_FUNCTION_ID] = CObjectSchemaItem::''' \
-            u'''SMember(TEnumSchemaItem<FunctionID::eType>::''' \
+            u'''strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::''' \
             u'''create(function_id_items), true);\n''' \
             u'''params_members[ns_smart_device_link::ns_json_handler::''' \
-            u'''strings::S_MESSAGE_TYPE] = CObjectSchemaItem::''' \
-            u'''SMember(TEnumSchemaItem<messageType::eType>::''' \
+            u'''strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::''' \
             u'''create(message_type_items), true);\n''' \
             u'''params_members[ns_smart_device_link::ns_json_handler::''' \
-            u'''strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::''' \
-            u'''SMember(TNumberSchemaItem<int>::create(), true);\n''' \
+            u'''strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);\n''' \
             u'''params_members[ns_smart_device_link::ns_json_handler::''' \
-            u'''strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::''' \
-            u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+            u'''strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);\n'''
 
         correlation_id_param = \
             u'''params_members[ns_smart_device_link::ns_json_handler::''' \
-            u'''strings::S_CORRELATION_ID] = CObjectSchemaItem::''' \
-            u'''SMember(TNumberSchemaItem<int>::create(), true);\n'''
+            u'''strings::S_CORRELATION_ID] = SMember(TNumberSchemaItem<int>::create(), true);\n'''
 
         return u"".join([base_params, correlation_id_param
                         if unicode(message_type_name) !=
diff --git a/tools/InterfaceGenerator/generator/parsers/JSONRPC.py b/tools/InterfaceGenerator/generator/parsers/JSONRPC.py
index 092f41ec17..52aa5a1048 100755
--- a/tools/InterfaceGenerator/generator/parsers/JSONRPC.py
+++ b/tools/InterfaceGenerator/generator/parsers/JSONRPC.py
@@ -4,8 +4,9 @@ Contains parser for JSON RPC XML format.
 
 """
 
+from generator import Model
 from generator.parsers import RPCBase
-
+import xml.etree.ElementTree as ET
 
 class Parser(RPCBase.Parser):
 
@@ -42,6 +43,17 @@ class Parser(RPCBase.Parser):
             self._interface_name = element.attrib["name"]
             self._parse_interface(element, self._interface_name + "_")
 
+    def _check_enum_name(self, enum):
+        """Check enum name.
+
+        This method is called to check whether the newly parsed enum's name
+        conflicts with some predefined enum.
+        As SDLRPCV2 has no predefined enums this implementation does nothing.
+
+        """
+
+        pass
+
     def _provide_enum_element_for_function(self, enum_name, element_name):
         """Provide enum element for functions.
 
diff --git a/tools/InterfaceGenerator/generator/parsers/RPCBase.py b/tools/InterfaceGenerator/generator/parsers/RPCBase.py
index 955de31dc7..d11b9e8d0d 100755
--- a/tools/InterfaceGenerator/generator/parsers/RPCBase.py
+++ b/tools/InterfaceGenerator/generator/parsers/RPCBase.py
@@ -865,8 +865,6 @@ class Parser(object):
         """
         if name in attrib:
             del attrib[name]
-            print ("Ignoring attribute '" +
-                   name + "'")
         return True
 
     def _parse_version(self, version):
diff --git a/tools/InterfaceGenerator/generator/parsers/SDLRPCV2.py b/tools/InterfaceGenerator/generator/parsers/SDLRPCV2.py
index 3d67c6e4c6..24974a5527 100755
--- a/tools/InterfaceGenerator/generator/parsers/SDLRPCV2.py
+++ b/tools/InterfaceGenerator/generator/parsers/SDLRPCV2.py
@@ -8,6 +8,7 @@ import collections
 
 from generator import Model
 from generator.parsers import RPCBase
+import xml.etree.ElementTree as ET
 
 
 class Parser(RPCBase.Parser):
@@ -31,6 +32,7 @@ class Parser(RPCBase.Parser):
         As SDLRPCV2 has no predefined enums this implementation does nothing.
 
         """
+
         pass
 
     def _parse_function_id_type(self, function_name, attrib):
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py
index c4813d00a8..533fe92eb5 100755
--- a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py
+++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactoryJSONRPC.py
@@ -18,95 +18,95 @@ from generator import Model
 
 EXPECTED_RESULT_REQUEST = (
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_FUNCTION_ID] = SMember("""
     u"""TEnumSchemaItem<FunctionID::eType>::create("""
     u"""function_id_items), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_MESSAGE_TYPE] = SMember("""
     u"""TEnumSchemaItem<messageType::eType>::create("""
     u"""message_type_items), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_VERSION] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_TYPE] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_CORRELATION_ID] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
 )
 
 EXPECTED_RESULT_RESPONSE = (
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_FUNCTION_ID] = SMember("""
     u"""TEnumSchemaItem<FunctionID::eType>::create("""
     u"""function_id_items), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_MESSAGE_TYPE] = SMember("""
     u"""TEnumSchemaItem<messageType::eType>::create("""
     u"""message_type_items), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_VERSION] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_TYPE] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_CORRELATION_ID] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::kCode] = CObjectSchemaItem::SMember("""
+    u"""strings::kCode] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
 )
 
 EXPECTED_RESULT_NOTIFICATION = (
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_FUNCTION_ID] = SMember("""
     u"""TEnumSchemaItem<FunctionID::eType>::create("""
     u"""function_id_items), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_MESSAGE_TYPE] = SMember("""
     u"""TEnumSchemaItem<messageType::eType>::create("""
     u"""message_type_items), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_VERSION] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_TYPE] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
 )
 
 EXPECTED_PRE_FUNCTION_CODE = (
-    u"""  std::map<std::string, CObjectSchemaItem::SMember> """
+    u"""  std::map<std::string, SMember> """
     u"""params_members;\n"""
     u"""  params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_FUNCTION_ID] = SMember("""
     u"""TEnumSchemaItem<FunctionID::eType>::create("""
     u"""function_id_items), true);\n"""
     u"""  params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_MESSAGE_TYPE] = SMember("""
     u"""TEnumSchemaItem<messageType::eType>::create("""
     u"""message_type_items), true);\n"""
     u"""  params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_VERSION] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""  params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_TYPE] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""  params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_CORRELATION_ID] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""  params_members[ns_smart_device_link::ns_json_handler"""
-    u"""::strings::kCode] = CObjectSchemaItem::SMember("""
+    u"""::strings::kCode] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""  params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::kMessage] = CObjectSchemaItem::SMember("""
+    u"""strings::kMessage] = SMember("""
     u"""CStringSchemaItem::create(), true);\n"""
     u"""\n"""
-    u"""  std::map<std::string, CObjectSchemaItem::SMember> """
+    u"""  std::map<std::string, SMember> """
     u"""root_members_map;\n"""
     u"""  root_members_map[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PARAMS] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PARAMS] = SMember("""
     u"""CObjectSchemaItem::create(params_members), true);\n"""
     u"""\n"""
     u"""  CSmartSchema error_response_schema(CObjectSchemaItem::create("""
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py
index 35e4aeb6ce..3c354cd34b 100755
--- a/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py
+++ b/tools/InterfaceGenerator/test/generator/generators/test_SmartFactorySDLRPC.py
@@ -18,23 +18,23 @@ from generator import Model
 
 EXPECTED_NOTIFICATION_RESULT = (
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_FUNCTION_ID] = SMember("""
     u"""TEnumSchemaItem<FunctionID::eType>::create("""
     u"""function_id_items), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_MESSAGE_TYPE] = SMember("""
     u"""TEnumSchemaItem<messageType::eType>::create("""
     u"""message_type_items), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_VERSION] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n"""
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember("""
+    u"""strings::S_PROTOCOL_TYPE] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n""")
 
 EXPECTED_REQ_RESP_RESULT = "".join([EXPECTED_NOTIFICATION_RESULT, (
     u"""params_members[ns_smart_device_link::ns_json_handler::"""
-    u"""strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember("""
+    u"""strings::S_CORRELATION_ID] = SMember("""
     u"""TNumberSchemaItem<int>::create(), true);\n""")])
 
 DESCRIPTION = [u"Description Line1", u"Description Line2"]
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc
index 49369d2559..05795ecf3b 100644
--- a/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_jsonrpc.cc
@@ -95,17 +95,17 @@ void XXX::YYY::ZZZ::Test::InitFunctionSchemes(
     const TStructsSchemaItems &struct_schema_items,
     const std::set<FunctionID::eType> &function_id_items,
     const std::set<messageType::eType> &message_type_items) {
-  std::map<std::string, CObjectSchemaItem::SMember> params_members;
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::kCode] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::kMessage] = CObjectSchemaItem::SMember(CStringSchemaItem::create(), true);
-
-  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+  std::map<std::string, SMember> params_members;
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::kCode] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::kMessage] = SMember(CStringSchemaItem::create(), true);
+
+  std::map<std::string, SMember> root_members_map;
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = SMember(CObjectSchemaItem::create(params_members), true);
 
   CSmartSchema error_response_schema(CObjectSchemaItem::create(root_members_map));
 
@@ -147,21 +147,21 @@ CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_name1_request(
   // Function parameter param2.
   TSharedPtr<ISchemaItem> param2_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(param2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>(name1));
 
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+  std::map<std::string, SMember> schema_members;
 
-  schema_members["param1"] = CObjectSchemaItem::SMember(param1_SchemaItem, true);
-  schema_members["param2"] = CObjectSchemaItem::SMember(param2_SchemaItem, true);
+  schema_members["param1"] = SMember(param1_SchemaItem, true);
+  schema_members["param2"] = SMember(param2_SchemaItem, true);
 
-  std::map<std::string, CObjectSchemaItem::SMember> params_members;
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  std::map<std::string, SMember> params_members;
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = SMember(TNumberSchemaItem<int>::create(), true);
 
-  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+  std::map<std::string, SMember> root_members_map;
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = SMember(CObjectSchemaItem::create(params_members), true);
 
   return CSmartSchema(CObjectSchemaItem::create(root_members_map));
 }
@@ -170,19 +170,19 @@ CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_1_response(
     const TStructsSchemaItems &struct_schema_items,
     const std::set<FunctionID::eType> &function_id_items,
     const std::set<messageType::eType> &message_type_items) {
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+  std::map<std::string, SMember> schema_members;
 
-  std::map<std::string, CObjectSchemaItem::SMember> params_members;
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::kCode] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  std::map<std::string, SMember> params_members;
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::kCode] = SMember(TNumberSchemaItem<int>::create(), true);
 
-  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+  std::map<std::string, SMember> root_members_map;
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = SMember(CObjectSchemaItem::create(params_members), true);
 
   return CSmartSchema(CObjectSchemaItem::create(root_members_map));
 }
@@ -191,17 +191,17 @@ CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_2_notification(
     const TStructsSchemaItems &struct_schema_items,
     const std::set<FunctionID::eType> &function_id_items,
     const std::set<messageType::eType> &message_type_items) {
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+  std::map<std::string, SMember> schema_members;
 
-  std::map<std::string, CObjectSchemaItem::SMember> params_members;
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  std::map<std::string, SMember> params_members;
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);
 
-  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+  std::map<std::string, SMember> root_members_map;
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = SMember(CObjectSchemaItem::create(params_members), true);
 
   return CSmartSchema(CObjectSchemaItem::create(root_members_map));
 }
@@ -270,28 +270,28 @@ TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct1(
   // Struct member arrayOfEnum6.
   TSharedPtr<ISchemaItem> arrayOfEnum6_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new4::eType>::create(sub3_allowed_enum_subset_values, TSchemaItemParameter<Enum_new4::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(43));
 
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
-
-  schema_members["intParam"] = CObjectSchemaItem::SMember(intParam_SchemaItem, true);
-  schema_members["doubleParam"] = CObjectSchemaItem::SMember(doubleParam_SchemaItem, false);
-  schema_members["boolParam"] = CObjectSchemaItem::SMember(boolParam_SchemaItem, true);
-  schema_members["structParam"] = CObjectSchemaItem::SMember(structParam_SchemaItem, true);
-  schema_members["enumParam"] = CObjectSchemaItem::SMember(enumParam_SchemaItem, true);
-  schema_members["enumParam1"] = CObjectSchemaItem::SMember(enumParam1_SchemaItem, true);
-  schema_members["enumSubset1"] = CObjectSchemaItem::SMember(enumSubset1_SchemaItem, false);
-  schema_members["arrayOfInt"] = CObjectSchemaItem::SMember(arrayOfInt_SchemaItem, false);
-  schema_members["arrayOfEnum1"] = CObjectSchemaItem::SMember(arrayOfEnum1_SchemaItem, false);
-  schema_members["arrayOfEnum3"] = CObjectSchemaItem::SMember(arrayOfEnum3_SchemaItem, true);
-  schema_members["arrayOfEnum4"] = CObjectSchemaItem::SMember(arrayOfEnum4_SchemaItem, true);
-  schema_members["arrayOfEnum5"] = CObjectSchemaItem::SMember(arrayOfEnum5_SchemaItem, true);
-  schema_members["arrayOfEnum6"] = CObjectSchemaItem::SMember(arrayOfEnum6_SchemaItem, true);
+  std::map<std::string, SMember> schema_members;
+
+  schema_members["intParam"] = SMember(intParam_SchemaItem, true);
+  schema_members["doubleParam"] = SMember(doubleParam_SchemaItem, false);
+  schema_members["boolParam"] = SMember(boolParam_SchemaItem, true);
+  schema_members["structParam"] = SMember(structParam_SchemaItem, true);
+  schema_members["enumParam"] = SMember(enumParam_SchemaItem, true);
+  schema_members["enumParam1"] = SMember(enumParam1_SchemaItem, true);
+  schema_members["enumSubset1"] = SMember(enumSubset1_SchemaItem, false);
+  schema_members["arrayOfInt"] = SMember(arrayOfInt_SchemaItem, false);
+  schema_members["arrayOfEnum1"] = SMember(arrayOfEnum1_SchemaItem, false);
+  schema_members["arrayOfEnum3"] = SMember(arrayOfEnum3_SchemaItem, true);
+  schema_members["arrayOfEnum4"] = SMember(arrayOfEnum4_SchemaItem, true);
+  schema_members["arrayOfEnum5"] = SMember(arrayOfEnum5_SchemaItem, true);
+  schema_members["arrayOfEnum6"] = SMember(arrayOfEnum6_SchemaItem, true);
 
   return CObjectSchemaItem::create(schema_members);
 }
 
 TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct2(
     const TStructsSchemaItems &struct_schema_items) {
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+  std::map<std::string, SMember> schema_members;
 
   return CObjectSchemaItem::create(schema_members);
 }
diff --git a/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc
index a62f485eb9..30b9b645ab 100644
--- a/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc
+++ b/tools/InterfaceGenerator/test/generator/generators/test_expected_sdlrpc.cc
@@ -130,21 +130,21 @@ CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_name1_request(
   // Function parameter param2.
   TSharedPtr<ISchemaItem> param2_SchemaItem = TEnumSchemaItem<Enum1::eType>::create(param2_allowed_enum_subset_values, TSchemaItemParameter<Enum1::eType>(name1));
 
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+  std::map<std::string, SMember> schema_members;
 
-  schema_members["param1"] = CObjectSchemaItem::SMember(param1_SchemaItem, true);
-  schema_members["param2"] = CObjectSchemaItem::SMember(param2_SchemaItem, true);
+  schema_members["param1"] = SMember(param1_SchemaItem, true);
+  schema_members["param2"] = SMember(param2_SchemaItem, true);
 
-  std::map<std::string, CObjectSchemaItem::SMember> params_members;
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  std::map<std::string, SMember> params_members;
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = SMember(TNumberSchemaItem<int>::create(), true);
 
-  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+  std::map<std::string, SMember> root_members_map;
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = SMember(CObjectSchemaItem::create(params_members), true);
 
   return CSmartSchema(CObjectSchemaItem::create(root_members_map));
 }
@@ -153,18 +153,18 @@ CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_1_response(
     const TStructsSchemaItems &struct_schema_items,
     const std::set<FunctionID::eType> &function_id_items,
     const std::set<messageType::eType> &message_type_items) {
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+  std::map<std::string, SMember> schema_members;
 
-  std::map<std::string, CObjectSchemaItem::SMember> params_members;
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  std::map<std::string, SMember> params_members;
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_CORRELATION_ID] = SMember(TNumberSchemaItem<int>::create(), true);
 
-  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+  std::map<std::string, SMember> root_members_map;
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = SMember(CObjectSchemaItem::create(params_members), true);
 
   return CSmartSchema(CObjectSchemaItem::create(root_members_map));
 }
@@ -173,17 +173,17 @@ CSmartSchema XXX::YYY::ZZZ::Test::InitFunction_val_2_notification(
     const TStructsSchemaItems &struct_schema_items,
     const std::set<FunctionID::eType> &function_id_items,
     const std::set<messageType::eType> &message_type_items) {
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+  std::map<std::string, SMember> schema_members;
 
-  std::map<std::string, CObjectSchemaItem::SMember> params_members;
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = CObjectSchemaItem::SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = CObjectSchemaItem::SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
-  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = CObjectSchemaItem::SMember(TNumberSchemaItem<int>::create(), true);
+  std::map<std::string, SMember> params_members;
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_FUNCTION_ID] = SMember(TEnumSchemaItem<FunctionID::eType>::create(function_id_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_MESSAGE_TYPE] = SMember(TEnumSchemaItem<messageType::eType>::create(message_type_items), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_VERSION] = SMember(TNumberSchemaItem<int>::create(), true);
+  params_members[ns_smart_device_link::ns_json_handler::strings::S_PROTOCOL_TYPE] = SMember(TNumberSchemaItem<int>::create(), true);
 
-  std::map<std::string, CObjectSchemaItem::SMember> root_members_map;
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(schema_members), true);
-  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = CObjectSchemaItem::SMember(CObjectSchemaItem::create(params_members), true);
+  std::map<std::string, SMember> root_members_map;
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_MSG_PARAMS] = SMember(CObjectSchemaItem::create(schema_members), true);
+  root_members_map[ns_smart_device_link::ns_json_handler::strings::S_PARAMS] = SMember(CObjectSchemaItem::create(params_members), true);
 
   return CSmartSchema(CObjectSchemaItem::create(root_members_map));
 }
@@ -252,28 +252,28 @@ TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct1(
   // Struct member arrayOfEnum6.
   TSharedPtr<ISchemaItem> arrayOfEnum6_SchemaItem = CArraySchemaItem::create(TEnumSchemaItem<Enum_new4::eType>::create(sub3_allowed_enum_subset_values, TSchemaItemParameter<Enum_new4::eType>()), TSchemaItemParameter<size_t>(10), TSchemaItemParameter<size_t>(43));
 
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
-
-  schema_members["intParam"] = CObjectSchemaItem::SMember(intParam_SchemaItem, true);
-  schema_members["doubleParam"] = CObjectSchemaItem::SMember(doubleParam_SchemaItem, false);
-  schema_members["boolParam"] = CObjectSchemaItem::SMember(boolParam_SchemaItem, true);
-  schema_members["structParam"] = CObjectSchemaItem::SMember(structParam_SchemaItem, true);
-  schema_members["enumParam"] = CObjectSchemaItem::SMember(enumParam_SchemaItem, true);
-  schema_members["enumParam1"] = CObjectSchemaItem::SMember(enumParam1_SchemaItem, true);
-  schema_members["enumSubset1"] = CObjectSchemaItem::SMember(enumSubset1_SchemaItem, false);
-  schema_members["arrayOfInt"] = CObjectSchemaItem::SMember(arrayOfInt_SchemaItem, false);
-  schema_members["arrayOfEnum1"] = CObjectSchemaItem::SMember(arrayOfEnum1_SchemaItem, false);
-  schema_members["arrayOfEnum3"] = CObjectSchemaItem::SMember(arrayOfEnum3_SchemaItem, true);
-  schema_members["arrayOfEnum4"] = CObjectSchemaItem::SMember(arrayOfEnum4_SchemaItem, true);
-  schema_members["arrayOfEnum5"] = CObjectSchemaItem::SMember(arrayOfEnum5_SchemaItem, true);
-  schema_members["arrayOfEnum6"] = CObjectSchemaItem::SMember(arrayOfEnum6_SchemaItem, true);
+  std::map<std::string, SMember> schema_members;
+
+  schema_members["intParam"] = SMember(intParam_SchemaItem, true);
+  schema_members["doubleParam"] = SMember(doubleParam_SchemaItem, false);
+  schema_members["boolParam"] = SMember(boolParam_SchemaItem, true);
+  schema_members["structParam"] = SMember(structParam_SchemaItem, true);
+  schema_members["enumParam"] = SMember(enumParam_SchemaItem, true);
+  schema_members["enumParam1"] = SMember(enumParam1_SchemaItem, true);
+  schema_members["enumSubset1"] = SMember(enumSubset1_SchemaItem, false);
+  schema_members["arrayOfInt"] = SMember(arrayOfInt_SchemaItem, false);
+  schema_members["arrayOfEnum1"] = SMember(arrayOfEnum1_SchemaItem, false);
+  schema_members["arrayOfEnum3"] = SMember(arrayOfEnum3_SchemaItem, true);
+  schema_members["arrayOfEnum4"] = SMember(arrayOfEnum4_SchemaItem, true);
+  schema_members["arrayOfEnum5"] = SMember(arrayOfEnum5_SchemaItem, true);
+  schema_members["arrayOfEnum6"] = SMember(arrayOfEnum6_SchemaItem, true);
 
   return CObjectSchemaItem::create(schema_members);
 }
 
 TSharedPtr<ISchemaItem> XXX::YYY::ZZZ::Test::InitStructSchemaItem_Struct2(
     const TStructsSchemaItems &struct_schema_items) {
-  std::map<std::string, CObjectSchemaItem::SMember> schema_members;
+  std::map<std::string, SMember> schema_members;
 
   return CObjectSchemaItem::create(schema_members);
 }