Python HDKModule 예제들

예제 #1

파일: hdkcli_cpp.py 프로젝트: cablelabs/Utopia

    def __init__(self, model, baseName, moduleName, actionLocation, fDOM, fInline):

        self._baseName = baseName
        self._fDOM = fDOM
        self._fInline = fInline

        # Generator state
        self._out = None
        self._namespaceStack = []

        # The underlying module.
        self._module = HDKModule(model, moduleName, actionLocation, fDOM)

        # Type information
        structTypes = {}
        arrayTypes = {}
        enumTypes = {}
        for type in model.all_types(user_types = fDOM, state_types = False):
            if type.isArray:
                arrayTypes[type.uri] = type
            elif type.isStruct:
                structTypes[type.uri] = type
            elif type.isEnum:
                enumTypes[type.uri] = type

        self._structTypes = sorted(structTypes.values(), key = lambda x:x.uri)
        self._arrayTypes = sorted(arrayTypes.values(), key = lambda x:x.uri)
        self._enumTypes = sorted(enumTypes.values(), key = lambda x:x.uri)

예제 #2

파일: hdkcli_cpp.py 프로젝트: WizzerWorks/Utopia

    def __init__(self, model, baseName, moduleName, actionLocation, fDOM, fInline):

        self._baseName = baseName
        self._fDOM = fDOM
        self._fInline = fInline

        # Generator state
        self._out = None
        self._namespaceStack = []

        # The underlying module.
        self._module = HDKModule(model, moduleName, actionLocation, fDOM)

        # Type information
        structTypes = {}
        arrayTypes = {}
        enumTypes = {}
        for type in model.all_types(user_types = fDOM, state_types = False):
            if type.isArray:
                arrayTypes[type.uri] = type
            elif type.isStruct:
                structTypes[type.uri] = type
            elif type.isEnum:
                enumTypes[type.uri] = type

        self._structTypes = sorted(structTypes.values(), key = lambda x:x.uri)
        self._arrayTypes = sorted(arrayTypes.values(), key = lambda x:x.uri)
        self._enumTypes = sorted(enumTypes.values(), key = lambda x:x.uri)

예제 #3

파일: hdkmod.py 프로젝트: vkanupuru/rdkb-Utopia

    def __init__(self, model, baseName, noid, friendlyName, actionLocation,
                 bGenerateDOMSchemas, bGenerateMethods, bClient, bADIReport):

        self._model = model

        # Options
        self._baseName = baseName
        self._noid = noid
        self._friendlyName = friendlyName
        self._bGenerateMethods = bGenerateMethods
        self._bADIReport = bADIReport

        # Generator state
        self._out = None

        # Module
        self._module = HDKModule(model, baseName, actionLocation,
                                 bGenerateDOMSchemas)

        # Generation options
        self._bGenerateActions = not bClient and self._module.actions
        self._bGenerateServices = not bClient and self._module.services
        self._bGenerateModule = self._module.actions or self._module.events
        self._bGenerateModuleDynamic = not bClient and self._bGenerateModule

예제 #4

파일: hdkmod.py 프로젝트: WizzerWorks/Utopia

    def __init__(self, model, baseName, noid, friendlyName,
                 actionLocation, bGenerateDOMSchemas,
                 bGenerateMethods, bClient, bADIReport):

        self._model = model

        # Options
        self._baseName = baseName
        self._noid = noid
        self._friendlyName = friendlyName
        self._bGenerateMethods = bGenerateMethods
        self._bADIReport = bADIReport

        # Generator state
        self._out = None

        # Module
        self._module = HDKModule(model, baseName, actionLocation, bGenerateDOMSchemas)

        # Generation options
        self._bGenerateActions = not bClient and self._module.actions
        self._bGenerateServices = not bClient and self._module.services
        self._bGenerateModule = self._module.actions or self._module.events
        self._bGenerateModuleDynamic = not bClient and self._bGenerateModule

예제 #5

파일: hdkmod.py 프로젝트: vkanupuru/rdkb-Utopia

class ModuleGenerator:

    # Class initializer
    def __init__(self, model, baseName, noid, friendlyName, actionLocation,
                 bGenerateDOMSchemas, bGenerateMethods, bClient, bADIReport):

        self._model = model

        # Options
        self._baseName = baseName
        self._noid = noid
        self._friendlyName = friendlyName
        self._bGenerateMethods = bGenerateMethods
        self._bADIReport = bADIReport

        # Generator state
        self._out = None

        # Module
        self._module = HDKModule(model, baseName, actionLocation,
                                 bGenerateDOMSchemas)

        # Generation options
        self._bGenerateActions = not bClient and self._module.actions
        self._bGenerateServices = not bClient and self._module.services
        self._bGenerateModule = self._module.actions or self._module.events
        self._bGenerateModuleDynamic = not bClient and self._bGenerateModule

    #
    # Generate code
    #

    def generate(self, dir, fhReport):

        for file, fn, bGenerate in \
                [(os.path.join(dir, self._module.filename('.h')), self._generate_h, not self._bGenerateMethods),
                 (os.path.join(dir, self._module.filename('.c')), self._generate_c, not self._bGenerateMethods),
                 (os.path.join(dir, self._module.filename('_methods.c')), self._generate_methods_c, self._bGenerateMethods),
                 (os.path.join(dir, self._module.filename('_adi.txt')), self._generate_adi_txt, self._bADIReport)]:

            if bGenerate:

                if fhReport is not None:
                    print >> fhReport, 'Generating "%s" ...' % file

                self._out = open(file, "w")
                try:
                    fn()
                except:
                    raise
                finally:
                    self._out.close()

    #
    # Output helper methods
    #

    # Output
    def _write(self, s):

        self._out.write(s)

    # Write .c file header
    def _write_header_c(self):

        self._write('''\
/*
 * Copyright (c) 2008-2010 Cisco Systems, Inc. All rights reserved.
 *
 * Cisco Systems, Inc. retains all right, title and interest (including all
 * intellectual property rights) in and to this computer program, which is
 * protected by applicable intellectual property laws.  Unless you have obtained
 * a separate written license from Cisco Systems, Inc., you are not authorized
 * to utilize all or a part of this computer program for any purpose (including
 * reproduction, distribution, modification, and compilation into object code),
 * and you must immediately destroy or return to Cisco Systems, Inc. all copies
 * of this computer program.  If you are licensed by Cisco Systems, Inc., your
 * rights to utilize this computer program are limited by the terms of that
 * license.  To obtain a license, please contact Cisco Systems, Inc.
 *
 * This computer program contains trade secrets owned by Cisco Systems, Inc.
 * and, unless unauthorized by Cisco Systems, Inc. in writing, you agree to
 * maintain the confidentiality of this computer program and related information
 * and to not disclose this computer program and related information to any
 * other person or entity.
 *
 * THIS COMPUTER PROGRAM IS PROVIDED AS IS WITHOUT ANY WARRANTIES, AND CISCO
 * SYSTEMS, INC. EXPRESSLY DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
 * INCLUDING THE WARRANTIES OF MERCHANTIBILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, TITLE, AND NONINFRINGEMENT.
 */
''')

    # Write .h file header
    def _write_header_h(self):

        self._write_header_c()
        self._write('''\

#ifndef %s
#define %s
''' % (self._module.header_sentinel('.h'), self._module.header_sentinel('.h')))

    # Write .h file footer
    def _write_footer_h(self):

        self._write('''\

#endif /* %s */
''' % (self._module.header_sentinel('.h')))

    # Write a section comment
    def _write_section(self, comment):

        self._write('''\


/*
 * %s
 */

''' % (comment))

    # Write enumeration definition
    def _write_enumeration(self,
                           name,
                           values,
                           ix_start=0,
                           ix_delta=1,
                           value_symbols={}):

        # Enum header
        self._write('''\
typedef enum _%s
{
''' % (name))

        # Write enum values
        ix_value = ix_start
        ix_value_last = ix_start + ix_delta * (len(values) - 1)
        sep = ","
        for value in values:

            # Does the value have a symbol?
            if value_symbols.has_key(value):
                str_value = value_symbols[value]
            else:
                str_value = str(ix_value)

            # Don't separate the last value
            if ix_value == ix_value_last:
                sep = ""

            # Write the enum value
            self._write('''\
    %s = %s%s
''' % (value, str_value, sep))

            ix_value += ix_delta

        # Enum footer
        self._write('''\
} %s;
''' % (name))

    # Write schema definition
    def _write_schema(self,
                      schema_nodes_static,
                      schema_static,
                      nodes,
                      element_path_static=None,
                      element_path=None):

        # Schema nodes header
        self._write('''\
static const HDK_XML_SchemaNode %s[] =
{
''' % (schema_nodes_static))

        # Write the schema nodes
        ix = 0
        for node in nodes:

            # Compute the parent index
            if node.parent:
                ix_parent = nodes.index(node.parent)
            else:
                ix_parent = 0

            # Compute the options
            options = []
            if node.is_optional:
                options.append("HDK_XML_SchemaNodeProperty_Optional")
            if node.is_unbounded:
                options.append("HDK_XML_SchemaNodeProperty_Unbounded")
            if node.is_any_element:
                options.append("HDK_XML_SchemaNodeProperty_AnyElement")
            if node.is_error:
                options.append("HDK_XML_SchemaNodeProperty_ErrorOutput")
            if node.is_csv:
                options.append("HDK_XML_SchemaNodeProperty_CSV")
            if options:
                options = " | ".join(options)
            else:
                options = "0"

            # Write the schema node
            self._write('''\
    /* %d */ { %d, %s, %s, %s },
''' % (ix, ix_parent, self._module.element_value(
                node.element()), self._module.type_value(node.type), options))
            ix += 1

        # Schema nodes footer
        self._write('''\
    HDK_XML_Schema_SchemaNodesEnd
};
''')

        # Schema struct element path
        if element_path_static and element_path:

            self._write('''\

static const HDK_XML_Element %s[] =
{
''' % (element_path_static))
            for element in element_path:
                self._write('''\
    %s,
''' % (self._module.element_value(element)))
            self._write('''\
    HDK_MOD_ElementPathEnd
};
''')

        # Schema
        self._write('''\

static const HDK_XML_Schema %s =
{
    s_namespaces,
    s_elements,
    %s,
    %s
};
''' % (schema_static, schema_nodes_static,
        "s_enumTypes" if self._module.schema.enums else "0"))

    # Write action definition
    def _write_action(self, action_loc):

        http_method, http_location, action, noauth = \
            (action_loc.http_method, action_loc.http_location, action_loc.action, action_loc.noauth)

        # Compute the SOAP action
        is_get = (http_method.lower() == "get")
        if is_get:
            soap_action = "0"
        else:
            soap_action = '"' + action.uri + '"'

        # Compute the action function name
        if self._bGenerateActions:
            action_fn = self._module.action_fn(action)
        else:
            action_fn = "0"

        # Compute the schema struct element path symbols
        if not is_get and self._module.schema.struct_nodes_envelope(
                action.inputMember, soap=True):
            input_element_path = self._module.schema_element_path_static(
                action, "_Input")
        else:
            input_element_path = "0"
        if self._module.schema.struct_nodes_envelope(action.outputMember,
                                                     soap=True):
            output_element_path = self._module.schema_element_path_static(
                action, "_Output")
        else:
            output_element_path = "0"

        # Compute the method options
        options = []
        if noauth:
            options.append("HDK_MOD_MethodOption_NoBasicAuth")
        if is_get:
            options.append("HDK_MOD_MethodOption_NoInputStruct")
        if options:
            options = " | ".join(options)
        else:
            options = "0"

        # Compute the OK and REBOOT values
        result_member = action.outputMember.type.members[0]
        if "REBOOT" in action.resultEnum.enumValues:
            result_reboot = "REBOOT"
        else:
            result_reboot = "OK"

        # Write the method struct
        self._write('''\
    {
        "%s",
        "%s",
        %s,
        %s,
        &%s,
        &%s,
        %s,
        %s,
        %s,
        %s,
        %s,
        %s,
        %s
    },
''' % (http_method, http_location, soap_action, action_fn,
        self._module.schema_static(action, suffix="_Input"),
        self._module.schema_static(action, suffix="_Output"),
        input_element_path, output_element_path, options,
        self._module.element_value(
           (result_member.namespace, result_member.name)),
        self._module.type_value(result_member.type),
        self._module.enum_value(result_member.type, "OK"),
        self._module.enum_value(result_member.type, result_reboot)))

    # Write event definition
    def _write_event(self, event):

        # Write the method struct
        self._write('''\
    {
        "%s",
        &%s
    },
''' % (event.uri, self._module.schema_static(event)))

    #
    # *.h code generator
    #

    def _generate_h(self):

        # File header
        self._write_header_h()

        # Includes
        self._write('''\

#include "hdk_mod.h"


/*
 * Macro to control public exports
 */

#ifdef __cplusplus
#  define %s_PREFIX extern "C"
#else
#  define %s_PREFIX extern
#endif
#ifdef HDK_MOD_STATIC
#  define %s %s_PREFIX
#else /* ndef HDK_MOD_STATIC */
#  ifdef _MSC_VER
#    ifdef %s
#      define %s %s_PREFIX __declspec(dllexport)
#    else
#      define %s %s_PREFIX __declspec(dllimport)
#    endif
#  else /* ndef _MSC_VER */
#    ifdef %s
#      define %s %s_PREFIX __attribute__ ((visibility("default")))
#    else
#      define %s %s_PREFIX
#    endif
#  endif /*def _MSC_VER */
#endif /* def HDK_MOD_STATIC */
''' % (self._module.export_macro(), self._module.export_macro(),
        self._module.export_macro(), self._module.export_macro(),
        self._module.build_macro(), self._module.export_macro(),
        self._module.export_macro(), self._module.export_macro(),
        self._module.export_macro(), self._module.build_macro(),
        self._module.export_macro(), self._module.export_macro(),
        self._module.export_macro(), self._module.export_macro()))

        # Element enumeration
        self._write_section("Elements")
        self._write_enumeration(self._module.element_enum(), [
            self._module.element_value(element)
            for element in self._module.schema.elements
        ])

        # Enumeration type definition
        if self._module.schema.enums:

            self._write_section("Enum types enumeration")
            self._write_enumeration(self._module.enum_type_enum(), [
                self._module.enum_type_value(enum)
                for enum in self._module.schema.enums
            ],
                                    ix_start=-1,
                                    ix_delta=-1)

        # Enumeration declarations
        for enum in self._module.schema.enums:

            # Enumeration type definition
            self._write_section("Enumeration %s" % (enum.uri))
            value_unknown = self._module.enum_value(enum,
                                                    None,
                                                    is_unknown=True)
            values = [value_unknown]
            values.extend([
                self._module.enum_value(enum, value)
                for value in enum.enumValues
            ])
            self._write_enumeration(
                self._module.enum_enum(enum),
                values,
                ix_start=-1,
                value_symbols={value_unknown: "HDK_XML_Enum_Unknown"})

            # Enumeration accessor declarations
            self._write('''\

#define %s(pStruct, element, value) HDK_XML_Set_Enum(pStruct, element, %s, 0 ? %s : (value))
#define %s(pStruct, element, value) HDK_XML_Append_Enum(pStruct, element, %s, 0 ? %s : (value))
#define %s(pStruct, element) (%s*)HDK_XML_Get_Enum(pStruct, element, %s)
#define %s(pStruct, element, value) (%s)HDK_XML_GetEx_Enum(pStruct, element, %s, 0 ? %s : (value))
#define %s(pMember) (%s*)HDK_XML_GetMember_Enum(pMember, %s)
''' % (self._module.enum_accessor(enum,
                                  "Set"), self._module.enum_type_value(enum),
            self._module.enum_value(
            enum, enum.enumValues[0]), self._module.enum_accessor(
               enum, "Append"), self._module.enum_type_value(enum),
            self._module.enum_value(
            enum, enum.enumValues[0]), self._module.enum_accessor(enum, "Get"),
            self._module.enum_enum(enum), self._module.enum_type_value(enum),
            self._module.enum_accessor(enum, "GetEx"), self._module.enum_enum(enum),
            self._module.enum_type_value(enum),
            self._module.enum_value(enum, enum.enumValues[0]),
            self._module.enum_accessor(enum, "GetMember"),
            self._module.enum_enum(enum), self._module.enum_type_value(enum)))

        # Action enumeration
        if self._module.actions:
            self._write_section("Method enumeration")
            self._write_enumeration(self._module.action_enum(), [
                self._module.action_value(action_loc)
                for action_loc in self._module.action_locations()
            ])

        # Action sentinels
        if self._bGenerateActions:
            self._write_section("Method sentinels")
            for action in self._module.actions:
                self._write('''\
#define %s
''' % (self._module.action_sentinel(action)))

        # Action declarations
        if self._bGenerateActions:
            self._write_section("Methods")
            for action in self._module.actions:
                self._write('''\
extern void %s(HDK_MOD_MethodContext* pMethodCtx, HDK_XML_Struct* pInput, HDK_XML_Struct* pOutput);
''' % (self._module.action_fn(action)))

        # Event enumeration
        if self._module.events:
            self._write_section("Event enumeration")
            self._write_enumeration(self._module.event_enum(), [
                self._module.event_value(event)
                for event in self._module.events
            ])

        # DOM (struct) schema accessor declarations
        if self._module.schema.structs:
            self._write_section("DOM Schemas")
        for struct in self._module.schema.structs:
            self._write('''\
%s const HDK_XML_Schema* %s();
''' % (self._module.export_macro(), self._module.dom_schema_fn(struct)))

        # State declarations
        if self._module.states:

            self._write_section("ADI")
            self._write_enumeration(self._module.state_enum(), [
                self._module.state_value(state)
                for state in self._module.states
            ],
                                    ix_start=1)

            self._write_section("ADI sentinels")
            for state in self._module.states:

                # Determine get/set
                usages = {}
                for actionState in self._model.actionStates:
                    if state.uri in actionState.stateMembers:
                        stateMember = actionState.stateMembers[state.uri]
                        if stateMember.isGet:
                            usages["get"] = None
                        if stateMember.isSet:
                            usages["set"] = None

                for usage in sorted(usages.iterkeys()):
                    self._write('''\
#define %s
''' % (self._module.state_value_sentinel(state, usage)))

        # Module declaration
        if self._bGenerateModule:

            self._write_section("Module")
            self._write('''\
%s const HDK_MOD_Module* %s(void);
''' % (self._module.export_macro(), self._module.module_fn()))

            if self._bGenerateModuleDynamic:
                self._write('''\

/* Dynamic server module export */
%s const HDK_MOD_Module* HDK_SRV_Module(void);
''' % (self._module.export_macro()))

        # File footer
        self._write_footer_h()

    #
    # *.c code generator
    #

    def _generate_c(self):

        # File header
        self._write_header_c()
        self._write('''\

#include "%s"

#include <string.h>
''' % (self._module.filename('.h')))

        # Namespace table
        self._write_section("Namespaces")
        self._write('''\
static const HDK_XML_Namespace s_namespaces[] =
{
''')
        for namespace in self._module.schema.namespaces:
            self._write('''\
    /* %d */ "%s",
''' % (self._module.schema.namespace_index(namespace), namespace))
        self._write('''\
    HDK_XML_Schema_NamespacesEnd
};
''')

        # Elements table
        self._write_section("Elements")
        self._write('''\
static const HDK_XML_ElementNode s_elements[] =
{
''')
        for element in self._module.schema.elements:
            self._write('''\
    /* %s = %d */ { %d, "%s" },
''' % (self._module.element_value(element),
            self._module.schema.element_index(element),
            self._module.schema.namespace_index(element[0]), element[1]))
        self._write('''\
    HDK_XML_Schema_ElementsEnd
};
''')

        # Enumerations definitions
        for enum in self._module.schema.enums:

            # Enumeration string table
            self._write_section("Enumeration %s" % (enum.uri))
            self._write('''\
static const HDK_XML_EnumValue %s[] =
{
''' % (self._module.enum_type_strings_static(enum)))
            for value in enum.enumValues:
                self._write('''\
    "%s",
''' % (value))
            self._write('''\
    HDK_XML_Schema_EnumTypeValuesEnd
};
''')

        # Enum types array
        if self._module.schema.enums:

            self._write_section("Enumeration types array")
            self._write('''\
static const HDK_XML_EnumType s_enumTypes[] =
{
''')
            sep = ','
            for enum in self._module.schema.enums:
                if enum is self._module.schema.enums[-1]:
                    sep = ""
                self._write('''\
    %s%s
''' % (self._module.enum_type_strings_static(enum), sep))
            self._write('''\
};
''')

        # Action definitions
        for action in self._module.actions:

            self._write_section("Method %s" % (action.uri))

            # Input schema
            self._write_schema(
                self._module.schema_nodes_static(action, suffix="_Input"),
                self._module.schema_static(action, suffix="_Input"),
                self._module.schema.struct_nodes(action.inputMember,
                                                 soap=True),
                element_path_static=self._module.schema_element_path_static(
                    action, suffix="_Input"),
                element_path=self._module.schema.struct_nodes_envelope(
                    action.inputMember, soap=True))

            # Output schema
            self._write('''\

''')
            self._write_schema(
                self._module.schema_nodes_static(action, suffix="_Output"),
                self._module.schema_static(action, suffix="_Output"),
                self._module.schema.struct_nodes(action.outputMember,
                                                 soap=True),
                element_path_static=self._module.schema_element_path_static(
                    action, suffix="_Output"),
                element_path=self._module.schema.struct_nodes_envelope(
                    action.outputMember, soap=True))

        # Actions table
        if self._module.actions:

            self._write_section("Methods")

            # Actions table header
            self._write('''\
static const HDK_MOD_Method s_methods[] =
{
''')

            # Write each action node
            for action_loc in self._module.action_locations():
                self._write_action(action_loc)

            # Actions table footer
            self._write('''\
    HDK_MOD_MethodsEnd
};
''')

        # Event definitions
        for event in self._module.events:

            self._write_section("Event %s" % (event.uri))
            self._write_schema(self._module.schema_nodes_static(event),
                               self._module.schema_static(event),
                               self._module.schema.struct_nodes(event.member))

        # Events table
        if self._module.events:

            self._write_section("Events")

            # Events table header
            self._write('''\
static const HDK_MOD_Event s_events[] =
{
''')

            # Write each event node
            for event in self._module.events:
                self._write_event(event)

            # Events table footer
            self._write('''\
    HDK_MOD_EventsEnd
};
''')

        if self._bGenerateServices:

            # Services action tables
            self._write_section("Service Methods")
            for service in self._module.services:

                # Service actions header
                self._write('''\
static const HDK_MOD_Method* %s[] =
{
''' % (self._module.service_actions_name(service)))

                # Service actions
                for action_uri in service.actions:

                    action_loc = [
                        a for a in self._module.action_locations()
                        if a.action.uri == action_uri
                    ][0]
                    self._write('''\
    &s_methods[%s],
''' % (self._module.action_value(action_loc)))

                # Service actions footer
                self._write('''\
    0
};
''')

            # Services event tables
            self._write_section("Service Events")
            for service in self._module.services:

                # Service events header
                self._write('''\
static const HDK_MOD_Event* %s[] =
{
''' % (self._module.service_events_name(service)))

                # Service events
                for eventURI in service.events:

                    event = [
                        e for e in self._module.events if e.uri == eventURI
                    ][0]
                    self._write('''\
    &s_events[%s],
''' % (self._module.event_value(event)))

                # Service events footer
                self._write('''\
    0
};
''')

            # Services table
            self._write_section("Services")

            # Services table header
            self._write('''\
static const HDK_MOD_Service s_services[] =
{
''')

            # Write each service node
            for service in self._module.services:
                self._write('''\
    {
        "%s",
        %s,
        %s
    },
''' % (service.uri, self._module.service_actions_name(service),
                self._module.service_events_name(service)))

            # Services table footer
            self._write('''\
    HDK_MOD_ServicesEnd
};
''')

        # State definitions
        if self._module.states:

            self._write_section("ADI")
            self._write_schema("s_schemaNodes_ADI", "s_schema_ADI",
                               self._module.schema.state_nodes())

        # Struct schema definitions
        for struct in self._module.schema.structs:
            self._write_section("Struct %s" % (struct.uri))
            self._write_schema(self._module.schema_nodes_static(struct),
                               self._module.schema_static(struct),
                               self._module.schema.struct_nodes(struct))
            self._write('''\

/* extern */ const HDK_XML_Schema* %s()
{
    return &%s;
}
''' % (self._module.dom_schema_fn(struct), self._module.schema_static(struct)))

        # Module definition
        if self._bGenerateModule:

            self._write_section("Module")

            # Network Object ID definition
            if self._noid is not None:
                self._write('''\
/* %s */
static const HDK_XML_UUID s_uuid_NOID =
{
    { %s }
};

''' % (self._noid, ", ".join(
                    ["0x%02x" % ord(byte) for byte in self._noid.bytes])))

            # Module definition and accessors
            self._write('''\
static const HDK_MOD_Module s_module =
{
    %s,
    %s,
    %s,
    %s,
    %s,
    %s
};

const HDK_MOD_Module* %s(void)
{
    return &s_module;
}
''' % ("&s_uuid_NOID" if self._noid else "0", '"' + self._friendlyName + '"'
            if self._friendlyName else "0", "s_services" if self._bGenerateServices
            else "0", "s_methods" if self._module.actions else "0",
            "s_events" if self._module.events else "0", "&s_schema_ADI"
            if self._module.states else "0", self._module.module_fn()))

            if self._bGenerateModuleDynamic:
                self._write('''\

const HDK_MOD_Module* HDK_SRV_Module(void)
{
    return &s_module;
}
''')

    #
    # *_methods.c code generator
    #

    def _generate_methods_c(self):

        # File header
        self._write_header_c()
        self._write('''\

#include "%s"

#include "hdk_srv.h"


/* Helper method for HNAP results */
#define SetHNAPResult(pStruct, prefix, method, result) \\
    prefix##_Set_##method##Result(pStruct, prefix##_Element_##method##Result, prefix##_Enum_##method##Result_##result)
''' % (self._module.filename('.h')))

        # Action declarations
        for action in self._module.actions:

            self._write_section("Method %s" % (action.uri))
            self._write('''\
#ifdef %s

void %s(HDK_MOD_MethodContext* pMethodCtx, HDK_XML_Struct* pInput, HDK_XML_Struct* pOutput)
{
    /* Unused parameters */
    (void)pMethodCtx;
    (void)pInput;
    (void)pOutput;
}

#endif /* %s */
''' % (self._module.action_sentinel(action), self._module.action_fn(action),
            self._module.action_sentinel(action)))

    #
    # *_adi.txt report generator
    #

    def _generate_adi_txt(self):

        # ADI report title
        self._write('''\
======================================================================
ADI Report for the %s Module
======================================================================
''' % (self._baseName.upper()))

        # Output the ADI values used (show get/set)
        self._write('''\


======================================================================
ADI values
======================================================================
''')
        for state in self._model.referenced_states():

            # Determine get/set
            usages = {}
            for actionState in self._model.actionStates:
                if state.uri in actionState.stateMembers:
                    stateMember = actionState.stateMembers[state.uri]
                    if stateMember.isGet:
                        usages["get"] = None
                    if stateMember.isSet:
                        usages["set"] = None
            sUsages = ', '.join(sorted(usages.iterkeys()))

            # Get the base type
            type = state.type
            nArray = 0
            while type.isArray:
                nArray += 1
                type = type.arrayType
            sArray = "[]" * nArray

            # Get the type description
            sDesc = ""
            if type.isEnum:
                sDesc = "enum"
            elif type.isStruct:
                sDesc = "struct"

            # Get the type string
            if sDesc:
                sType = '%s%s (%s, "%s")' % (type.name, sArray, sDesc,
                                             type.namespace)
            else:
                sType = '%s%s' % (type.name, sArray)

            self._write('''\

%s

    Namespace: "%s"
         Name: "%s"
         Type: %s
        Usage: %s
''' % (self._module.state_value(state), state.namespace, state.name, sType,
            sUsages))

        # Output the ADI values used by action
        self._write('''\


======================================================================
ADI values by action
======================================================================
''')
        for actionState in self._model.actionStates:
            self._write('''\

%s

''' % (actionState.uri))
            for stateMember in sorted(actionState.stateMembers.itervalues()):

                # Determine usage
                usages = {}
                if stateMember.isGet:
                    usages["get"] = None
                if stateMember.isSet:
                    usages["set"] = None
                sUsages = ', '.join(sorted(usages.iterkeys()))

                self._write('''\
    [%s] %s
''' % (sUsages, self._module.state_value(stateMember.state)))

예제 #6

파일: hdkcli_cpp.py 프로젝트: WizzerWorks/Utopia

class CppClientGenerator:

    # Class initializer
    def __init__(self, model, baseName, moduleName, actionLocation, fDOM, fInline):

        self._baseName = baseName
        self._fDOM = fDOM
        self._fInline = fInline

        # Generator state
        self._out = None
        self._namespaceStack = []

        # The underlying module.
        self._module = HDKModule(model, moduleName, actionLocation, fDOM)

        # Type information
        structTypes = {}
        arrayTypes = {}
        enumTypes = {}
        for type in model.all_types(user_types = fDOM, state_types = False):
            if type.isArray:
                arrayTypes[type.uri] = type
            elif type.isStruct:
                structTypes[type.uri] = type
            elif type.isEnum:
                enumTypes[type.uri] = type

        self._structTypes = sorted(structTypes.values(), key = lambda x:x.uri)
        self._arrayTypes = sorted(arrayTypes.values(), key = lambda x:x.uri)
        self._enumTypes = sorted(enumTypes.values(), key = lambda x:x.uri)


    #
    # Generate code
    #

    def generate(self, dir, fhReport):

        # Generate c++ client code
        for file, fn in [(os.path.join(dir, self._filename('.h')), self._generate_h),
                         (os.path.join(dir, self._filename('.cpp')), self._generate_cpp)]:

            if fhReport is not None:
                print >>fhReport, 'Generating "%s" ...' % file

            self._out = open(file, "w")
            try:
                fn()
            except:
                raise
            finally:
                self._out.close()

    #
    # Helpers
    #

    # Is the given type a "blob"
    @staticmethod
    def is_blob_type(type):

        return type.name == "blob"

    @staticmethod
    def is_bool_type(type):

        return type.name == "bool"

    @staticmethod
    def is_int_type(type):

        return type.name == "int"

    @staticmethod
    def is_long_type(type):

        return type.name == "long"

    @staticmethod
    def is_datetime_type(type):

        return type.name == "datetime"

    @staticmethod
    def is_ipaddress_type(type):

        return type.name == "IPAddress"

    @staticmethod
    def is_macaddress_type(type):

        return type.name == "MACAddress"

    @staticmethod
    def is_string_type(type):

        return type.name == "string"

    @staticmethod
    def is_uuid_type(type):

        return type.name == "UUID"

    @staticmethod
    def is_hnap_result_type(type):

        return type.name == "Result"

    # Does the given type support the "blank" value
    @staticmethod
    def supports_blank(type):

        return CppClientGenerator.is_ipaddress_type(type) or CppClientGenerator.is_macaddress_type(type)

    # Retrieve the HDK_XML_ function to use for the given type and access
    def _hdk_struct_accessor(self, type, access):

        if CppClientGenerator.is_datetime_type(type):
            method = "HDK_XML_" + access + "_DateTime"
        elif CppClientGenerator.is_macaddress_type(type) or \
                CppClientGenerator.is_ipaddress_type(type):
            method = "HDK_XML_" + access + "_" + type.name
        elif CppClientGenerator.is_uuid_type(type):
            method = "HDK_XML_" + access + "_UUID"
        elif type.isEnum:
            method = self._module.enum_accessor(type, access)
        elif type.isStruct:
            method = "HDK_XML_" + access + "_Struct"
        else:
            method = "HDK_XML_" + access + "_" + type.name.capitalize()

        return method

    # Retrieve the HDK type cast for the given type
    def _hdk_type_cast(self, type):

        if type.isEnum:
            return "(" + self._module.enum_enum(type) + ")"
        elif CppClientGenerator.is_bool_type(type):
            return "(int)"
        else:
            return ""

    #
    # Symbol helper methods
    #

    # Generated code filename
    def _filename(self, suffix):

        return self._baseName + suffix

    # c++ namespace
    def _namespace(self, uri):

        ns = re.sub("^\w+:/+(www\.)?", "", uri)
        ns = re.sub("\.com", "", ns)
        ns = re.sub("/+HNAPExt", "", ns)

        ns = re.sub("/+$", "", ns)
        if ns:
            ns = ns[0].upper() + ns[1:]

        return re.sub("[^\w]", "_", ns)

    # c++ class name
    def _class_class(self, type):

        assert(type.isStruct)

        if type.isArray:
            match = re.match("ArrayOf(.*)", type.name);
            return makeGlobalSymbol("", "", match.group(1) + "Array")
        else:
            return makeGlobalSymbol("", "", type.name + "Struct")

    def _class_class_iter(self, type):

        return self._class_class(type) + "Iter"

    # c++ class constructor
    def _class_constructor(self, type):

        assert(type.isStruct)
        return self._class_class(type)

    # c++ class set property method
    def _class_set_property_method(self, member):

        return "set_" + member.name

    # c++ class get property method
    def _class_get_property_method(self, member):

        return "get_" + member.name

    # c++ class from file method
    def _class_from_file_method(self):

        return "FromFile"

    # c++ class to file method
    def _class_to_file_method(self):

        return "ToFile"

    def _type_type(self, type, withNS = False):

        typeName = None

        if type.isBuiltin:
            if CppClientGenerator.is_bool_type(type):
               typeName = "bool"
            elif CppClientGenerator.is_int_type(type):
                typeName = "HDK_XML_Int"
            elif CppClientGenerator.is_long_type(type):
                typeName = "HDK_XML_Long"
            elif CppClientGenerator.is_string_type(type):
                typeName = "const char*"
            elif CppClientGenerator.is_datetime_type(type):
                typeName = "time_t"
            elif CppClientGenerator.is_ipaddress_type(type):
                typeName = "IPv4Address"
            elif CppClientGenerator.is_macaddress_type(type):
                typeName = "MACAddress"
            elif CppClientGenerator.is_blob_type(type):
                typeName = "Blob"
            elif CppClientGenerator.is_uuid_type(type):
                typeName = "UUID"
            elif CppClientGenerator.is_hnap_result_type(type):
                typeName = type.name
                if fWithNamespace and self._current_open_namespace() != type.namespace:
                    typeName = self._namespace(type.namespace) + "::" + typeName
            else:
                print>>sys.stderr, "Unhandled builtin type %s" % (type.name)
                typeName = type.name

        elif type.isStruct:
            typeName = self._class_class(type)
            namespace = self._namespace(type.namespace)

            if namespace and withNS and self._current_open_namespace() != type.namespace:
                typeName = namespace + "::" + typeName

        elif type.isEnum:
            typeName = self._enum_enum(type)
            if withNS and self._current_open_namespace() != type.namespace:
                typeName = self._namespace(type.namespace) + "::" + typeName
            typeName = "enum " + typeName

        return typeName

    # c++ type cast
    def _type_cast(self, type):

        if type.isEnum:
            return "(" + self._type_type(type, withNS = True)  + ")"
        elif CppClientGenerator.is_bool_type(type):
            return "(bool)"
        else:
            return ""

    # c++ enum type
    def _enum_enum(self, type):

        return makeGlobalSymbol("", "", type.name)

    # c++ enum value
    def _enum_value(self, type, value, bIsUnknown = False):

        if bIsUnknown:
            return makeGlobalSymbol(type.name, "", "Unknown")
        else:
            return makeGlobalSymbol(type.name, "", value)

    # c++ action
    def _action_fn(self, action_loc, withNS = False):

        (http_method, action) = (action_loc.http_method, action_loc.action)

        fn = action.name
        if withNS:
            fn = self._namespace(action.namespace) + "::" + fn

        # Non-post action?
        if http_method != "POST":
            suffix = "_" + http_method
        else:
            suffix = ""

        return fn + suffix

    #
    # Output helper methods
    #

    # Output
    def _write(self, s):

        self._out.write(s)

    def _write_newline(self):

        self._out.write('''
''')

    def _write_with_indent(self, s, cIndent, bIndentCPreprocessor = False):

        indent = cIndent * ' '
        for line in s.splitlines(True):
            if line[0] == '#' and not bIndentCPreprocessor:
                self._write(line)
            elif re.search("^\s*$", line):
                # Don't write unnecessary whitespace
                self._write(line)
            else:
                self._write(indent + line)

    def _write_with_ns_indent(self, s, extraIndent = 0):

        self._write_with_indent(s, self._namespace_indent() + extraIndent)

    def _write_copyright(self):

        self._write('''\
/*
 * Copyright (c) 2008-2010 Cisco Systems, Inc. All rights reserved.
 *
 * Cisco Systems, Inc. retains all right, title and interest (including all
 * intellectual property rights) in and to this computer program, which is
 * protected by applicable intellectual property laws.  Unless you have obtained
 * a separate written license from Cisco Systems, Inc., you are not authorized
 * to utilize all or a part of this computer program for any purpose (including
 * reproduction, distribution, modification, and compilation into object code),
 * and you must immediately destroy or return to Cisco Systems, Inc. all copies
 * of this computer program.  If you are licensed by Cisco Systems, Inc., your
 * rights to utilize this computer program are limited by the terms of that
 * license.  To obtain a license, please contact Cisco Systems, Inc.
 *
 * This computer program contains trade secrets owned by Cisco Systems, Inc.
 * and, unless unauthorized by Cisco Systems, Inc. in writing, you agree to
 * maintain the confidentiality of this computer program and related information
 * and to not disclose this computer program and related information to any
 * other person or entity.
 *
 * THIS COMPUTER PROGRAM IS PROVIDED AS IS WITHOUT ANY WARRANTIES, AND CISCO
 * SYSTEMS, INC. EXPRESSLY DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
 * INCLUDING THE WARRANTIES OF MERCHANTIBILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, TITLE, AND NONINFRINGEMENT.
 */
''')

    # Write .cpp file header
    def _write_header_cpp(self, fileName = ""):

        self._write_copyright()

        self._write('''\

// %s - [Generated by hdkcli_cpp]
''' % (fileName))

    # Write .h file header
    def _write_header_h(self, fileName = ""):

        self._write_copyright()
        self._write('''\

#pragma once

// %s - [Generated by hdkcli_cpp]
''' % (fileName))

    # Write .h file footer
    def _write_footer_h(self):

        # Namespace stack should be empty now.
        assert(not self._namespaceStack)

    # Write the opening of a namespace
    def _write_open_namespace(self, uri, cIndent):

        indent = ' ' * cIndent
        namespace = self._namespace(uri)

        self._write('''\

%snamespace %s
%s{
''' % (indent, namespace,
       indent))

    # Write the closing of a namespace
    def _write_close_namespace(self, uri, cIndent):

        indent = ' ' * cIndent
        namespace = self._namespace(uri)

        self._write('''\
%s} // namespace %s
''' % (indent, namespace))

    # Generate a class forward declaration
    def _write_class_forward_declaration(self, type):

        self._write_with_ns_indent('''\
class %s;
''' % (self._class_class(type)))

    # Generate an enum definition
    def _write_enum(self, type, extraIndent = 0):

        assert(type.isEnum)

        indent = self._namespace_indent() + extraIndent

        self._write_doxygen_section_with_ns_indent_begin(extraIndent)
        self._write_doxygen_string_with_ns_indent('''\
\\enum %s
     <a>%s</a>
''' % (self._enum_enum(type),
       type.uri), extraIndent)
        self._write_doxygen_lines_with_ns_indent(type.doctext, extraIndent)
        self._write_doxygen_section_with_ns_indent_end(extraIndent)

        self._write_with_indent('''\
enum %s
{
    %s = %s /*<! Unknown value */,
''' % (self._enum_enum(type),
       self._enum_value(type, None, True), self._module.enum_value(type, None, True)), indent)

        for value in type.enumValues[0:-1]:
            self._write_with_indent('''\
    %s = %s /*!< %s */,
''' % (self._enum_value(type, value), self._module.enum_value(type, value), value), indent)

        if type.enumValues:
            value = type.enumValues[-1]
            self._write_with_indent('''\
    %s = %s /*!< %s */
''' % (self._enum_value(type, value), self._module.enum_value(type, value), value), indent)
        self._write_with_indent('''\
}; // enum %s

''' % (self._enum_enum(type)), indent)

    #
    # Doxygen-formatted output helpers
    #

    # Doxygen comment prefix.
    _doxygenPrefix = "///"

    def _write_doxygen_line_with_ns_indent(self, line, extraIndent = 0):

        doxygenFormattedLine = CppClientGenerator._doxygenPrefix
        if line and not re.search("^\s$", line):
            doxygenFormattedLine += " " + line

        if not doxygenFormattedLine.endswith("\n"):
            doxygenFormattedLine += "\n"

        self._write_with_indent(doxygenFormattedLine, extraIndent + self._namespace_indent())

    def _write_doxygen_lines_with_ns_indent(self, lines, extraIndent = 0):

        for line in lines:
            self._write_doxygen_line_with_ns_indent(line, extraIndent)

    def _write_doxygen_string_with_ns_indent(self, s, extraIndent = 0):

        for line in s.splitlines(True):
            self._write_doxygen_line_with_ns_indent(line, extraIndent)

    def _write_doxygen_section_with_ns_indent_begin(self, extraIndent = 0):

        self._write_doxygen_line_with_ns_indent(None, extraIndent)

    def _write_doxygen_section_with_ns_indent_end(self, extraIndent = 0):

        self._write_doxygen_line_with_ns_indent(None, extraIndent)

    def _write_doxygen_section_with_ns_indent(self, s, extraIndent = 0):

        self._write_doxygen_section_with_ns_indent_begin(extraIndent)

        self._write_doxygen_string_with_ns_indent(s, extraIndent)

        self._write_doxygen_section_with_ns_indent_end(extraIndent)

    #
    # Namespace scoping
    #

    # Update the current namespace (closing the previous one, if needed)
    def _push_namespace(self, ns):

        if self._namespaceStack:
            if self._namespaceStack[-1].namespace == ns:
                if self._namespaceStack[-1].needs_closing:
                    self._namespaceStack[-1].increment()
                    return
                #else: ns::ns. strange...
            else:
                if self._namespaceStack[-1].needs_closing:
                    self._write_close_namespace(self._namespaceStack[-1].namespace, (len(self._namespaceStack) - 1) * 4)
                    self._namespaceStack.pop()

        self._namespaceStack.append(CppNamespaceScope(ns))
        self._write_open_namespace(ns, (len(self._namespaceStack) - 1) * 4)

    def _pop_namespace(self, bAlwaysClose = False):

        if self._namespaceStack[-1].needs_closing:
            self._write_close_namespace(self._namespaceStack[-1].namespace, (len(self._namespaceStack) - 1) * 4)
            self._namespaceStack.pop()

        if self._namespaceStack:
            self._namespaceStack[-1].decrement()

            if bAlwaysClose and self._namespaceStack[-1].needs_closing:
                self._write_close_namespace(self._namespaceStack[-1].namespace, (len(self._namespaceStack) - 1) * 4)
                self._namespaceStack.pop()

    # Namespace indentation
    def _namespace_indent(self):

        return len(self._namespaceStack) * 4

    # Current open namespace
    def _current_open_namespace(self):

        if self._namespaceStack:
            return self._namespaceStack[-1].namespace
        else:
            return None

    #
    # Helpers for c++ class wrappers of HDK_XML_Structs
    #

    # Generate a default constructor
    def _write_class_default_constructor(self, struct, element = None, fImpl = False, classScope = None, extraIndent = 0):

        if element is None:
            element = "HDK_XML_BuiltinElement_Unknown"

        method = self._class_constructor(struct)
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
%s() throw()''' % (method), extraIndent)

        if fImpl:
            self._write(''' :''')
            self._write_with_ns_indent('''
    Struct(%s)
{
}
''' % (element), extraIndent)
        else: # not fImpl
            self._write(''';
''')

    # Generate a constructor with HDK_XML_Struct
    def _write_class_hdk_constructor(self, struct, fImpl = False, classScope = None, extraIndent = 0):

        method = self._class_constructor(struct)
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
%s(HDK_XML_Struct* phdkstruct) throw()''' % (method), extraIndent)

        if fImpl:
            self._write(''' :''')
            self._write_with_ns_indent('''
    Struct(phdkstruct)
{
}
''', extraIndent)
        else: # not fImpl
            self._write(''';
''')

    # Generate a get_ accessor implementation.
    def _write_class_get_accessor(self, member, fImpl = False, classScope = None, extraIndent = 0):

        element = self._module.element_value((member.namespace, member.name))

        method = self._class_get_property_method(member)
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
%s %s() const throw()''' % (self._type_type(member.type, withNS = True), method), extraIndent)

        if fImpl:
            self._write_with_ns_indent('''\

{
''', extraIndent)
            if member.type.isStruct:
                self._write_with_ns_indent('''\
    return %s(GetStruct(), %s);
''' % (self._hdk_struct_accessor(member.type, "Get"), element), extraIndent)
            else:
                # Blob type is special-cased.
                if CppClientGenerator.is_blob_type(member.type):
                    self._write_with_ns_indent('''\
    unsigned int cbBlob = 0;
    char* pbBlob = %s(GetStruct(), %s, &cbBlob);
    return Blob(pbBlob, cbBlob);
''' % (self._hdk_struct_accessor(member.type, "Get"), element), extraIndent)
                else:
                    # Determine the default value
                    if member.type.isEnum:
                        defaultValue = self._module.enum_value(member.type, None, is_unknown = True)
                    elif CppClientGenerator.is_ipaddress_type(member.type):
                        defaultValue = "HDK::IPv4Address::Blank()"
                    elif CppClientGenerator.is_macaddress_type(member.type):
                        defaultValue = "HDK::MACAddress::Blank()"
                    else:
                        defaultValue = "0"

                    # Determine the cast for the type.
                    cast = self._type_cast(member.type)
                    if CppClientGenerator.is_bool_type(member.type):
                        # Avoid Microsoft compiler warning C4800
                        cast = "0 != "
                    self._write_with_ns_indent('''\
    return %s%s(GetStruct(), %s, %s);
''' % (cast, self._hdk_struct_accessor(member.type, "GetEx"), element, defaultValue), extraIndent)
            self._write_with_ns_indent('''\
}
''', extraIndent)

        else: # not fImpl
            self._write(''';
''')

    # Generate a set_ accessor implementation.  If classScope is present, the method will be scoped in the class.
    def _write_class_set_accessor(self, member, fImpl = False, classScope = None, extraIndent = 0):

        element = self._module.element_value((member.namespace, member.name))

        if member.type.isStruct or \
                CppClientGenerator.is_blob_type(member.type) or \
                CppClientGenerator.is_ipaddress_type(member.type) or \
                CppClientGenerator.is_macaddress_type(member.type):

            argType = "const " + self._type_type(member.type, withNS = True) + "&"
        else:
            argType = self._type_type(member.type, withNS = True)

        method = self._class_set_property_method(member)
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
void %s(%s value) throw()''' % (method, argType), extraIndent)
        if fImpl:
            self._write_with_ns_indent('''\

{
''', extraIndent)

            if CppClientGenerator.supports_blank(member.type):
                self._write_with_ns_indent('''\
    if (value.IsBlank())
    {
        (void)HDK_XML_Set_Blank(GetStruct(), %s);
        return;
    }
''' % (element), extraIndent)

            # Handle non-standard value sets (struct and blob types)
            if member.type.isStruct:
                self._write_with_ns_indent('''\
    (void)%s(GetStruct(), %s, value);
''' % (self._hdk_struct_accessor(member.type, "SetEx"), element), extraIndent)

            elif CppClientGenerator.is_blob_type(member.type):
                self._write_with_ns_indent('''\
    (void)%s(GetStruct(), %s, value.get_Data(), value.get_Size());
''' % (self._hdk_struct_accessor(member.type, "Set"), element), extraIndent)

            else:
                self._write_with_ns_indent('''\
    (void)%s(GetStruct(), %s, %svalue);
''' % (self._hdk_struct_accessor(member.type, "Set"), element, self._hdk_type_cast(member.type)), extraIndent)

            self._write_with_ns_indent('''\
}
''', extraIndent)

        else: # not fImpl
            self._write(''';
''')

    # Generate a FromFile method implementation.
    def _write_class_method_from_file(self, type, fImpl = False, classScope = None, extraIndent = 0):

        method = self._class_from_file_method()
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
bool %s(const char* pszFile) throw()''' % (method), extraIndent)

        if fImpl:
            self._write_with_ns_indent('''\

{
    return HDK::Struct::DeserializeFromFile(%s(), pszFile);
}
''' % (self._module.dom_schema_fn(type)), extraIndent)
        else: # not fImpl
            self._write(''';
''')


    # Generate a ToFile method implementation.
    def _write_class_method_to_file(self, type, fImpl = False, classScope = None, extraIndent = 0):

        method = self._class_to_file_method()
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
bool %s(const char* pszFile) const throw()''' % (method), extraIndent)

        if fImpl:
            self._write_with_ns_indent('''\

{
    return HDK::Struct::SerializeToFile(%s(), pszFile, 0);
}
''' % (self._module.dom_schema_fn(type)), extraIndent)
        else: # not fImpl
            self._write(''';
''')

    # Generate a c++ class declaration from an HDK_XML_Struct
    def _write_class_declaration(self, struct,
                                 fGenerateSets = True, fConstructFromStruct = True,
                                 fInline = False, rootElement = None, fDOM = False):

        self._write_doxygen_section_with_ns_indent_begin()
        self._write_doxygen_string_with_ns_indent('''\
\\brief %s
     <a>%s</a>
''' % (struct.name, struct.uri))
        self._write_doxygen_lines_with_ns_indent(struct.doctext)
        self._write_doxygen_section_with_ns_indent_end()

        self._write_with_ns_indent('''\
class %s : public Struct
{
''' % (self._class_class(struct)))

        # Generate the class constructors and destructor.
        self._write_with_ns_indent('''\
public:
    //
    // Constructors/Destructor.
    //
''')
        self._write_class_default_constructor(struct, element = rootElement, fImpl = fInline, extraIndent = 4)
        self._write_newline()

        if fConstructFromStruct:
            self._write_class_hdk_constructor(struct, fImpl = fInline, extraIndent = 4)
            self._write_newline()

        # Write the accessor methods.
        for member in struct.members:

            self._write_doxygen_section_with_ns_indent_begin(4)
            self._write_doxygen_string_with_ns_indent('''\
\\brief Get the %s value.
''' % (member.name), 4)
            if member.doctext:
                self._write_doxygen_line_with_ns_indent('''\
     \\retval %s
''' % (member.doctext[0]), 4)

                self._write_doxygen_lines_with_ns_indent(member.doctext[1:], 4)
            self._write_doxygen_section_with_ns_indent_end(4)

            self._write_class_get_accessor(member, fImpl = fInline, extraIndent = 4)
            self._write_newline()

            if fGenerateSets:
                self._write_doxygen_section_with_ns_indent_begin(4)
                self._write_doxygen_string_with_ns_indent('''\
\\brief Set the %s value.
''' % (member.name), 4)
                if member.doctext:
                    self._write_doxygen_string_with_ns_indent('''\
     \\arg %s
''' % (member.doctext[0]), 4)
                    self._write_doxygen_lines_with_ns_indent(member.doctext[1:], 4)
                self._write_doxygen_section_with_ns_indent_end(4)

                self._write_class_set_accessor(member, fImpl = fInline, extraIndent = 4)
                self._write_newline()

        if fDOM:
            self._write_doxygen_section_with_ns_indent_begin(4)
            self._write_doxygen_string_with_ns_indent('''\
\\brief Serialize to/from an XML file.
''', 4)
            self._write_doxygen_section_with_ns_indent_end(4)

            self._write_class_method_from_file(struct, fImpl = fInline, extraIndent = 4)
            self._write_class_method_to_file(struct, fImpl = fInline, extraIndent = 4)
            self._write_newline()

        self._write_with_ns_indent('''\
}; // class %s : public Struct

''' % self._class_class(struct))

    # Generate a wrapper for an array class using the array template
    def _write_array_template_typedef(self, type, includeClassDeclaration = True):

        assert(type.isArray)

        self._write_doxygen_section_with_ns_indent('''\
\\class %s
     Wrapper class for accessing arrays of %s values.
''' % (self._class_class(type),
       type.arrayType.name))

        # element represents the XML element of each array item
        element = self._module.element_value((type.members[0].namespace, type.members[0].name))

        if type.arrayType.isStruct:
            if includeClassDeclaration:
                self._write_with_ns_indent('''\
class %s; // forward declaration
''' % (self._class_class(type.arrayType)))
            self._write_with_ns_indent('''\
typedef HDK::StructArray<%s, %s> %s;
typedef HDK::StructArray<%s, %s>::StructArrayIter %sIter;

''' % (self._type_type(type.arrayType, withNS = True), element, self._class_class(type),
       self._type_type(type.arrayType, withNS = True), element, self._class_class(type)))
        elif type.arrayType.isEnum:
            self._write_with_ns_indent('''\
typedef HDK::EnumArray<%s, %s, %s> %s;
typedef HDK::EnumArray<%s, %s, %s>::EnumArrayIter %sIter;

''' % (self._type_type(type.arrayType, withNS = True), self._module.enum_type_value(type.arrayType), element, self._class_class(type),
       self._type_type(type.arrayType, withNS = True), self._module.enum_type_value(type.arrayType), element, self._class_class(type)))
        elif type.arrayType.name == "datetime":
            self._write_with_ns_indent('''\
typedef HDK::DateTimeArray<%s> %s;
typedef HDK::DateTimeArray<%s>::DateTimeArrayIter %sIter;

''' % (element, self._class_class(type),
       element, self._class_class(type)))
        else:
            templateClass = type.arrayType.name.capitalize() + "Array"
            self._write_with_ns_indent('''\
typedef HDK::%s<%s> %s;
typedef HDK::%s<%s>::%sIter %sIter;

''' % (templateClass, element, self._class_class(type),
       templateClass, element, self._class_class(type), templateClass))

    #
    # Generate a c++ class definition from an HDK_XML_Struct
    #
    def _write_class_definition(self, struct,
                                fGenerateSets = True, fConstructFromStruct = True,
                                rootElement = None,
                                fDOM = False):

        assert(struct.isStruct)

        # Constructors.
        self._write_class_default_constructor(struct, element = rootElement, fImpl = True, classScope = struct)

        if fConstructFromStruct:
            self._write_newline()
            self._write_class_hdk_constructor(struct, fImpl = True, classScope = struct)

        for member in struct.members:

            element = self._module.element_value((member.namespace, member.name))

            # Get accessor
            self._write_newline()
            self._write_class_get_accessor(member, fImpl = True, classScope = struct)

            # Set accessor
            if fGenerateSets:
                self._write_newline()
                self._write_class_set_accessor(member, fImpl = True, classScope = struct)

        if fDOM:
            self._write_newline()
            self._write_class_method_from_file(struct, fImpl = True, classScope = struct)

            self._write_newline()
            self._write_class_method_to_file(struct, fImpl = True, classScope = struct)

    # Helper to generate the action method documentation
    def _write_action_method_documentation(self, action_loc, extraIndent = 0):

        (http_method, http_location, action, noauth) = \
            (action_loc.http_method, action_loc.http_location, action_loc.action, action_loc.noauth)

        bInput = (len(action.inputMember.type.members) > 0)
        bOutput = (len(action.outputMember.type.members) > 1)

        self._write_doxygen_section_with_ns_indent_begin(extraIndent)
        self._write_doxygen_string_with_ns_indent('''\
\\brief Call the %s method on a given device.
    <a>%s</a>
    This method uses HTTP method %s and location '%s'
''' % (action.name,
       action.uri,
       http_method, http_location), extraIndent)
        if noauth:
            self._write_doxygen_string_with_ns_indent('''\
    \\note This method does NOT require HTTP Basic Authorization.

''', extraIndent)
        self._write_doxygen_lines_with_ns_indent(action.doctext)
        self._write_doxygen_line_with_ns_indent("\n")

        # Write out the potential result values.
        if action.resultEnum.enumValues:
            self._write_doxygen_line_with_ns_indent('''\
    Possible result values:
''', extraIndent)
            for enumValue in action.resultEnum.enumValues:
                self._write_doxygen_line_with_ns_indent('''\
         - #%s
''' % (self._enum_value(action.resultEnum, enumValue)), extraIndent)
        self._write_doxygen_string_with_ns_indent('''\
    \\arg pTarget The target on which to call this method.
''', extraIndent)
        if bInput:
            self._write_doxygen_string_with_ns_indent('''\
    \\arg input The input argument data to the %s HNAP method.
''' % (action.name), extraIndent)

        if bOutput:
            self._write_doxygen_line_with_ns_indent('''\
    \\arg output The output argument data from the %s HNAP method.
''' % (action.name), extraIndent)

        self._write_doxygen_string_with_ns_indent('''\
    \\arg[optional] result The HNAP result of the %s HNAP method.
    \\arg timeoutSecs An optional timeout, in seconds, to use for the HNAP call.
    \\retval The result of the HNAP method call.
''' % (action.name), extraIndent)
        self._write_doxygen_section_with_ns_indent_end(extraIndent)

    # Helper to generate the action method declarations
    def _write_action_method(self, action_loc, fImpl = False, withNS = False, fNoDefaultArgs = False, extraIndent = 0):

        action = action_loc.action

        bInput = (len(action.inputMember.type.members) > 0)
        bOutput = (len(action.outputMember.type.members) > 1)

        self._write_with_ns_indent('''\
HDK::ClientError %s
(
    HDK::ITarget* pTarget,
''' % (self._action_fn(action_loc, withNS = withNS)), extraIndent)
        if bInput:
            self._write_with_ns_indent('''\
    const %s & input,
''' % (self._type_type(action.inputMember.type, withNS = True)), extraIndent)
        if bOutput:
            self._write_with_ns_indent('''\
    %s & output,
''' % (self._type_type(action.outputMember.type, withNS = True)), extraIndent)

        if fNoDefaultArgs:
            presultDefault = "/* = NULL */"
            timeoutSecsDefault = "/* = 0 */"
        else:
            presultDefault = "= NULL"
            timeoutSecsDefault = "= 0"
        self._write_with_ns_indent('''\
    %s* presult %s,
    unsigned int timeoutSecs %s
) throw()''' % (self._type_type(action.outputMember.type.members[0].type, withNS = True), presultDefault,
                timeoutSecsDefault), extraIndent)

        if fImpl:
            self._write_with_ns_indent('''\

{
    if (!pTarget)
    {
        return ClientError_InvalidArg;
    }
''', extraIndent)
            if not bInput:
                self._write_with_ns_indent('''\
    %s input;
''' % (self._type_type(action.inputMember.type, withNS = True)), extraIndent)
            if not bOutput:
                self._write_with_ns_indent('''\

    %s output;
''' % (self._type_type(action.outputMember.type, withNS = True)), extraIndent)
            self._write_with_ns_indent('''\

    ClientError error = pTarget->Request(timeoutSecs,
                                         %s(),
                                         %s,
                                         input,
                                         &output);
''' % (self._module.module_fn(),
       self._module.action_value(action_loc)), extraIndent)
            self._write_with_ns_indent('''\

    const HDK_MOD_Method* pMethod = HDK_MOD_GetMethod(%s(), %s);
''' % (self._module.module_fn(), self._module.action_value(action_loc)), extraIndent)
            self._write_with_ns_indent('''\

    // Get the result value.
    %s result = output.%s();
    if (NULL != presult)
    {
        *presult = result;
    }

    // Determine if there was an HNAP-result, and whether it was an error or not.
    if ((ClientError_OK == error) && (HDK_XML_BuiltinElement_Unknown != pMethod->hnapResultElement))
    {
        if ((pMethod->hnapResultOK != (int)result) && (pMethod->hnapResultREBOOT != (int)result))
        {
            // An HNAP error response.
            error = HDK::ClientError_HnapMethod;
        }
    }

    return error;
}
''' % (self._type_type(action.outputMember.type.members[0].type, withNS = True), \
           self._class_get_property_method(action.outputMember.type.members[0])), extraIndent)

        else: # not fImpl
            self._write(''';
''')

    # Helper to write HDK Init documentation
    def _write_init_function_documentation(self, extraIndent = 0):

        self._write_doxygen_section_with_ns_indent('''\
\\fn InitializeClient
     Initialize the HDK client library.  This should be called once per application instance.
     Each call to InitializeClient should be matched by a call to UninitializeClient.
     \\retval true if initialization was successful, false if not.
''', extraIndent)

    # Helper to write HDK Init method
    def _write_init_function(self, fImpl = False, withNS = False, extraIndent = 0):

        method = "InitializeClient"
        if withNS:
            method = "HDK::" + method

        self._write_with_ns_indent('''\
bool %s() throw()''' % (method), extraIndent)

        if fImpl:

            self._write_with_ns_indent('''\

{
    return !!HDK_CLI_Init();
}
''', extraIndent)

        else: # not fImpl

            self._write(''';
''')

    # Helper to write HDK uninit documentation
    def _write_uninit_function_documentation(self, extraIndent = 0):

        self._write_doxygen_section_with_ns_indent('''\
\\fn UninitializeClient
     Cleanup the HDK client library.  This should be called if true was returned from InitializeClient
     When the caller is done using the HDK client library.
''', extraIndent)

    # Helper to write HDK uninit method
    def _write_uninit_function(self, fImpl = False, withNS = False, extraIndent = 0):

        method = "UninitializeClient"
        if withNS:
            method = "HDK::" + method

        self._write_with_ns_indent('''\
void %s() throw()''' % (method), extraIndent)

        if fImpl:

            self._write_with_ns_indent('''\

{
    HDK_CLI_Cleanup();
}
''', extraIndent)

        else: # not fImpl

            self._write(''';
''')

    # Helper to write URI accessor macro documentation
    def _write_uri_accessor_macro_documentation(self, action_loc, extraIndent = 0):

        self._write_doxygen_section_with_ns_indent('''\
\\brief SOAP method URI for action %s
''' % (action_loc.action.name), extraIndent)

    # Helper to write URI accessor macro
    def _write_uri_accessor_macro(self, action_loc, extraIndent = 0):

        self._write_with_ns_indent('''\
#define %s (HDK_MOD_GetMethod(%s(), %s)->pszSOAPAction)
''' % (makeGlobalSymbol("", action_loc.action.namespace, action_loc.action.name, nameSuffix = "_URI"),
       self._module.module_fn(), self._module.action_value(action_loc)), extraIndent)

    #
    # .h code generator
    #
    def _generate_h(self):

        self._write_header_h(self._filename('.h'))

        self._write('''\

// Non-generated client code.
#include "hdk_cli_cpp.h"

// Underlying schema module.
#include "%s"

''' % (self._module.filename('.h')))

        self._push_namespace("HDK")

        # Write HDK global functions.
        if self._module.action_locations():
            self._write_init_function_documentation()
            self._write_init_function()
            self._write_newline()
            self._write_uninit_function_documentation()
            self._write_uninit_function()
            self._write_newline()

        # Generate c++-style enums
        for typeEnum in self._enumTypes:

            self._push_namespace(typeEnum.namespace)
            self._write_enum(typeEnum)
            self._pop_namespace()

        # Declare array types.
        for typeArray in self._arrayTypes:

            self._push_namespace(typeArray.namespace)
            self._write_array_template_typedef(typeArray)
            self._pop_namespace()

        # Generate c++ wrapper classes for each struct
        for typeStruct in self._structTypes:

            # Generate any required forward declarations.
            for member in typeStruct.members:
                # The types are sorted alphabetically, so anything greater than this one has yet to be defined.
                forwDeclType = member.type
                if forwDeclType.isArray:
                    forwDeclType = forwDeclType.arrayType
                if forwDeclType.isStruct and not forwDeclType.isArray:
                   if forwDeclType.name > typeStruct.name:
                       self._push_namespace(forwDeclType.namespace)
                       self._write_class_forward_declaration(forwDeclType)
                       self._pop_namespace()

            self._push_namespace(typeStruct.namespace)

            element = None
            if self._fDOM:
                element = self._module.element_value((typeStruct.namespace, typeStruct.name))
            self._write_class_declaration(typeStruct,
                                          fDOM = self._fDOM,
                                          fInline = self._fInline,
                                          rootElement = element)
            self._pop_namespace()

        # Generate class implementations for each action input and output structure.
        for action in self._module.actions:

            for (fGenerateSets, struct) in \
                    [(True, action.inputMember.type),
                     (False, action.outputMember.type)]:
                self._push_namespace(struct.namespace)
                self._write_class_declaration(struct,
                                              fGenerateSets, fConstructFromStruct = False,
                                              fInline = self._fInline,
                                              rootElement = self._module.element_value((action.namespace, action.name)))
                self._pop_namespace()

        # Generate the action method declarations.
        for action_loc in self._module.action_locations():
            self._push_namespace(action_loc.action.namespace)

            # Generate accessors for macros URIs.
            if action_loc.http_method == "POST":
                self._write_uri_accessor_macro_documentation(action_loc)
                self._write_uri_accessor_macro(action_loc)
                self._write_newline()

            self._write_action_method_documentation(action_loc)
            self._write_action_method(action_loc)
            self._write_newline()
            self._pop_namespace()

        # Make sure the previous namespace is closed.
        self._pop_namespace()

        # Should be in the HDK namespace scope
        assert(self._namespaceStack[-1].namespace == "HDK")

        # Close HDK namespace
        self._pop_namespace(True)

    #
    # .cpp code generator
    #
    def _generate_cpp(self):

        self._write_header_cpp(self._filename('.cpp'))

        self._write('''\

// Local header.
#include "%s"

using namespace HDK;
''' % (self._filename('.h')))

        if not self._fInline:
            # Generate class implementations for each structure type.
            for type in self._structTypes:
                element = None
                if self._fDOM:
                    element = self._module.element_value((type.namespace, type.name))

                self._write_newline()
                self._write_class_definition(type, fDOM = self._fDOM, rootElement = element)

            # Generate class implementations for each action input and output structure.
            for action in self._module.actions:
                for (fGenerateSets, member) in \
                        [(True, action.inputMember),
                         (False, action.outputMember)]:
                    self._write_newline()
                    self._write_class_definition(member.type,
                                                 fGenerateSets,
                                                 fConstructFromStruct = False,
                                                 rootElement = self._module.element_value((action.namespace, action.name)))

        # Write the action method definitions.
        if self._module.action_locations():
            # Write HDK global init/cleanup function definitions.
            self._write_newline()
            self._write_init_function(fImpl = True, withNS = True)
            self._write_newline()
            self._write_uninit_function(fImpl = True, withNS = True)

            for action_loc in self._module.action_locations():
                self._write_newline()
                self._write_action_method(action_loc, fImpl = True, withNS = True, fNoDefaultArgs = True)

예제 #7

파일: hdkcli_cpp.py 프로젝트: cablelabs/Utopia

class CppClientGenerator:

    # Class initializer
    def __init__(self, model, baseName, moduleName, actionLocation, fDOM, fInline):

        self._baseName = baseName
        self._fDOM = fDOM
        self._fInline = fInline

        # Generator state
        self._out = None
        self._namespaceStack = []

        # The underlying module.
        self._module = HDKModule(model, moduleName, actionLocation, fDOM)

        # Type information
        structTypes = {}
        arrayTypes = {}
        enumTypes = {}
        for type in model.all_types(user_types = fDOM, state_types = False):
            if type.isArray:
                arrayTypes[type.uri] = type
            elif type.isStruct:
                structTypes[type.uri] = type
            elif type.isEnum:
                enumTypes[type.uri] = type

        self._structTypes = sorted(structTypes.values(), key = lambda x:x.uri)
        self._arrayTypes = sorted(arrayTypes.values(), key = lambda x:x.uri)
        self._enumTypes = sorted(enumTypes.values(), key = lambda x:x.uri)


    #
    # Generate code
    #

    def generate(self, dir, fhReport):

        # Generate c++ client code
        for file, fn in [(os.path.join(dir, self._filename('.h')), self._generate_h),
                         (os.path.join(dir, self._filename('.cpp')), self._generate_cpp)]:

            if fhReport is not None:
                print >>fhReport, 'Generating "%s" ...' % file

            self._out = open(file, "w")
            try:
                fn()
            except:
                raise
            finally:
                self._out.close()

    #
    # Helpers
    #

    # Is the given type a "blob"
    @staticmethod
    def is_blob_type(type):

        return type.name == "blob"

    @staticmethod
    def is_bool_type(type):

        return type.name == "bool"

    @staticmethod
    def is_int_type(type):

        return type.name == "int"

    @staticmethod
    def is_long_type(type):

        return type.name == "long"

    @staticmethod
    def is_datetime_type(type):

        return type.name == "datetime"

    @staticmethod
    def is_ipaddress_type(type):

        return type.name == "IPAddress"

    @staticmethod
    def is_macaddress_type(type):

        return type.name == "MACAddress"

    @staticmethod
    def is_string_type(type):

        return type.name == "string"

    @staticmethod
    def is_uuid_type(type):

        return type.name == "UUID"

    @staticmethod
    def is_hnap_result_type(type):

        return type.name == "Result"

    # Does the given type support the "blank" value
    @staticmethod
    def supports_blank(type):

        return CppClientGenerator.is_ipaddress_type(type) or CppClientGenerator.is_macaddress_type(type)

    # Retrieve the HDK_XML_ function to use for the given type and access
    def _hdk_struct_accessor(self, type, access):

        if CppClientGenerator.is_datetime_type(type):
            method = "HDK_XML_" + access + "_DateTime"
        elif CppClientGenerator.is_macaddress_type(type) or \
                CppClientGenerator.is_ipaddress_type(type):
            method = "HDK_XML_" + access + "_" + type.name
        elif CppClientGenerator.is_uuid_type(type):
            method = "HDK_XML_" + access + "_UUID"
        elif type.isEnum:
            method = self._module.enum_accessor(type, access)
        elif type.isStruct:
            method = "HDK_XML_" + access + "_Struct"
        else:
            method = "HDK_XML_" + access + "_" + type.name.capitalize()

        return method

    # Retrieve the HDK type cast for the given type
    def _hdk_type_cast(self, type):

        if type.isEnum:
            return "(" + self._module.enum_enum(type) + ")"
        elif CppClientGenerator.is_bool_type(type):
            return "(int)"
        else:
            return ""

    #
    # Symbol helper methods
    #

    # Generated code filename
    def _filename(self, suffix):

        return self._baseName + suffix

    # c++ namespace
    def _namespace(self, uri):

        ns = re.sub("^\w+:/+(www\.)?", "", uri)
        ns = re.sub("\.com", "", ns)
        ns = re.sub("/+HNAPExt", "", ns)

        ns = re.sub("/+$", "", ns)
        if ns:
            ns = ns[0].upper() + ns[1:]

        return re.sub("[^\w]", "_", ns)

    # c++ class name
    def _class_class(self, type):

        assert(type.isStruct)

        if type.isArray:
            match = re.match("ArrayOf(.*)", type.name);
            return makeGlobalSymbol("", "", match.group(1) + "Array")
        else:
            return makeGlobalSymbol("", "", type.name + "Struct")

    def _class_class_iter(self, type):

        return self._class_class(type) + "Iter"

    # c++ class constructor
    def _class_constructor(self, type):

        assert(type.isStruct)
        return self._class_class(type)

    # c++ class set property method
    def _class_set_property_method(self, member):

        return "set_" + member.name

    # c++ class get property method
    def _class_get_property_method(self, member):

        return "get_" + member.name

    # c++ class from file method
    def _class_from_file_method(self):

        return "FromFile"

    # c++ class to file method
    def _class_to_file_method(self):

        return "ToFile"

    def _type_type(self, type, withNS = False):

        typeName = None

        if type.isBuiltin:
            if CppClientGenerator.is_bool_type(type):
               typeName = "bool"
            elif CppClientGenerator.is_int_type(type):
                typeName = "HDK_XML_Int"
            elif CppClientGenerator.is_long_type(type):
                typeName = "HDK_XML_Long"
            elif CppClientGenerator.is_string_type(type):
                typeName = "const char*"
            elif CppClientGenerator.is_datetime_type(type):
                typeName = "time_t"
            elif CppClientGenerator.is_ipaddress_type(type):
                typeName = "IPv4Address"
            elif CppClientGenerator.is_macaddress_type(type):
                typeName = "MACAddress"
            elif CppClientGenerator.is_blob_type(type):
                typeName = "Blob"
            elif CppClientGenerator.is_uuid_type(type):
                typeName = "UUID"
            elif CppClientGenerator.is_hnap_result_type(type):
                typeName = type.name
                if fWithNamespace and self._current_open_namespace() != type.namespace:
                    typeName = self._namespace(type.namespace) + "::" + typeName
            else:
                print>>sys.stderr, "Unhandled builtin type %s" % (type.name)
                typeName = type.name

        elif type.isStruct:
            typeName = self._class_class(type)
            namespace = self._namespace(type.namespace)

            if namespace and withNS and self._current_open_namespace() != type.namespace:
                typeName = namespace + "::" + typeName

        elif type.isEnum:
            typeName = self._enum_enum(type)
            if withNS and self._current_open_namespace() != type.namespace:
                typeName = self._namespace(type.namespace) + "::" + typeName
            typeName = "enum " + typeName

        return typeName

    # c++ type cast
    def _type_cast(self, type):

        if type.isEnum:
            return "(" + self._type_type(type, withNS = True)  + ")"
        elif CppClientGenerator.is_bool_type(type):
            return "(bool)"
        else:
            return ""

    # c++ enum type
    def _enum_enum(self, type):

        return makeGlobalSymbol("", "", type.name)

    # c++ enum value
    def _enum_value(self, type, value, bIsUnknown = False):

        if bIsUnknown:
            return makeGlobalSymbol(type.name, "", "Unknown")
        else:
            return makeGlobalSymbol(type.name, "", value)

    # c++ action
    def _action_fn(self, action_loc, withNS = False):

        (http_method, action) = (action_loc.http_method, action_loc.action)

        fn = action.name
        if withNS:
            fn = self._namespace(action.namespace) + "::" + fn

        # Non-post action?
        if http_method != "POST":
            suffix = "_" + http_method
        else:
            suffix = ""

        return fn + suffix

    #
    # Output helper methods
    #

    # Output
    def _write(self, s):

        self._out.write(s)

    def _write_newline(self):

        self._out.write('''
''')

    def _write_with_indent(self, s, cIndent, bIndentCPreprocessor = False):

        indent = cIndent * ' '
        for line in s.splitlines(True):
            if line[0] == '#' and not bIndentCPreprocessor:
                self._write(line)
            elif re.search("^\s*$", line):
                # Don't write unnecessary whitespace
                self._write(line)
            else:
                self._write(indent + line)

    def _write_with_ns_indent(self, s, extraIndent = 0):

        self._write_with_indent(s, self._namespace_indent() + extraIndent)

    def _write_copyright(self):

        self._write('''\
/*
 * Copyright (c) 2008-2010 Cisco Systems, Inc. All rights reserved.
 *
 * Cisco Systems, Inc. retains all right, title and interest (including all
 * intellectual property rights) in and to this computer program, which is
 * protected by applicable intellectual property laws.  Unless you have obtained
 * a separate written license from Cisco Systems, Inc., you are not authorized
 * to utilize all or a part of this computer program for any purpose (including
 * reproduction, distribution, modification, and compilation into object code),
 * and you must immediately destroy or return to Cisco Systems, Inc. all copies
 * of this computer program.  If you are licensed by Cisco Systems, Inc., your
 * rights to utilize this computer program are limited by the terms of that
 * license.  To obtain a license, please contact Cisco Systems, Inc.
 *
 * This computer program contains trade secrets owned by Cisco Systems, Inc.
 * and, unless unauthorized by Cisco Systems, Inc. in writing, you agree to
 * maintain the confidentiality of this computer program and related information
 * and to not disclose this computer program and related information to any
 * other person or entity.
 *
 * THIS COMPUTER PROGRAM IS PROVIDED AS IS WITHOUT ANY WARRANTIES, AND CISCO
 * SYSTEMS, INC. EXPRESSLY DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
 * INCLUDING THE WARRANTIES OF MERCHANTIBILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, TITLE, AND NONINFRINGEMENT.
 */
''')

    # Write .cpp file header
    def _write_header_cpp(self, fileName = ""):

        self._write_copyright()

        self._write('''\

// %s - [Generated by hdkcli_cpp]
''' % (fileName))

    # Write .h file header
    def _write_header_h(self, fileName = ""):

        self._write_copyright()
        self._write('''\

#pragma once

// %s - [Generated by hdkcli_cpp]
''' % (fileName))

    # Write .h file footer
    def _write_footer_h(self):

        # Namespace stack should be empty now.
        assert(not self._namespaceStack)

    # Write the opening of a namespace
    def _write_open_namespace(self, uri, cIndent):

        indent = ' ' * cIndent
        namespace = self._namespace(uri)

        self._write('''\

%snamespace %s
%s{
''' % (indent, namespace,
       indent))

    # Write the closing of a namespace
    def _write_close_namespace(self, uri, cIndent):

        indent = ' ' * cIndent
        namespace = self._namespace(uri)

        self._write('''\
%s} // namespace %s
''' % (indent, namespace))

    # Generate a class forward declaration
    def _write_class_forward_declaration(self, type):

        self._write_with_ns_indent('''\
class %s;
''' % (self._class_class(type)))

    # Generate an enum definition
    def _write_enum(self, type, extraIndent = 0):

        assert(type.isEnum)

        indent = self._namespace_indent() + extraIndent

        self._write_doxygen_section_with_ns_indent_begin(extraIndent)
        self._write_doxygen_string_with_ns_indent('''\
\\enum %s
     <a>%s</a>
''' % (self._enum_enum(type),
       type.uri), extraIndent)
        self._write_doxygen_lines_with_ns_indent(type.doctext, extraIndent)
        self._write_doxygen_section_with_ns_indent_end(extraIndent)

        self._write_with_indent('''\
enum %s
{
    %s = %s /*<! Unknown value */,
''' % (self._enum_enum(type),
       self._enum_value(type, None, True), self._module.enum_value(type, None, True)), indent)

        for value in type.enumValues[0:-1]:
            self._write_with_indent('''\
    %s = %s /*!< %s */,
''' % (self._enum_value(type, value), self._module.enum_value(type, value), value), indent)

        if type.enumValues:
            value = type.enumValues[-1]
            self._write_with_indent('''\
    %s = %s /*!< %s */
''' % (self._enum_value(type, value), self._module.enum_value(type, value), value), indent)
        self._write_with_indent('''\
}; // enum %s

''' % (self._enum_enum(type)), indent)

    #
    # Doxygen-formatted output helpers
    #

    # Doxygen comment prefix.
    _doxygenPrefix = "///"

    def _write_doxygen_line_with_ns_indent(self, line, extraIndent = 0):

        doxygenFormattedLine = CppClientGenerator._doxygenPrefix
        if line and not re.search("^\s$", line):
            doxygenFormattedLine += " " + line

        if not doxygenFormattedLine.endswith("\n"):
            doxygenFormattedLine += "\n"

        self._write_with_indent(doxygenFormattedLine, extraIndent + self._namespace_indent())

    def _write_doxygen_lines_with_ns_indent(self, lines, extraIndent = 0):

        for line in lines:
            self._write_doxygen_line_with_ns_indent(line, extraIndent)

    def _write_doxygen_string_with_ns_indent(self, s, extraIndent = 0):

        for line in s.splitlines(True):
            self._write_doxygen_line_with_ns_indent(line, extraIndent)

    def _write_doxygen_section_with_ns_indent_begin(self, extraIndent = 0):

        self._write_doxygen_line_with_ns_indent(None, extraIndent)

    def _write_doxygen_section_with_ns_indent_end(self, extraIndent = 0):

        self._write_doxygen_line_with_ns_indent(None, extraIndent)

    def _write_doxygen_section_with_ns_indent(self, s, extraIndent = 0):

        self._write_doxygen_section_with_ns_indent_begin(extraIndent)

        self._write_doxygen_string_with_ns_indent(s, extraIndent)

        self._write_doxygen_section_with_ns_indent_end(extraIndent)

    #
    # Namespace scoping
    #

    # Update the current namespace (closing the previous one, if needed)
    def _push_namespace(self, ns):

        if self._namespaceStack:
            if self._namespaceStack[-1].namespace == ns:
                if self._namespaceStack[-1].needs_closing:
                    self._namespaceStack[-1].increment()
                    return
                #else: ns::ns. strange...
            else:
                if self._namespaceStack[-1].needs_closing:
                    self._write_close_namespace(self._namespaceStack[-1].namespace, (len(self._namespaceStack) - 1) * 4)
                    self._namespaceStack.pop()

        self._namespaceStack.append(CppNamespaceScope(ns))
        self._write_open_namespace(ns, (len(self._namespaceStack) - 1) * 4)

    def _pop_namespace(self, bAlwaysClose = False):

        if self._namespaceStack[-1].needs_closing:
            self._write_close_namespace(self._namespaceStack[-1].namespace, (len(self._namespaceStack) - 1) * 4)
            self._namespaceStack.pop()

        if self._namespaceStack:
            self._namespaceStack[-1].decrement()

            if bAlwaysClose and self._namespaceStack[-1].needs_closing:
                self._write_close_namespace(self._namespaceStack[-1].namespace, (len(self._namespaceStack) - 1) * 4)
                self._namespaceStack.pop()

    # Namespace indentation
    def _namespace_indent(self):

        return len(self._namespaceStack) * 4

    # Current open namespace
    def _current_open_namespace(self):

        if self._namespaceStack:
            return self._namespaceStack[-1].namespace
        else:
            return None

    #
    # Helpers for c++ class wrappers of HDK_XML_Structs
    #

    # Generate a default constructor
    def _write_class_default_constructor(self, struct, element = None, fImpl = False, classScope = None, extraIndent = 0):

        if element is None:
            element = "HDK_XML_BuiltinElement_Unknown"

        method = self._class_constructor(struct)
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
%s() throw()''' % (method), extraIndent)

        if fImpl:
            self._write(''' :''')
            self._write_with_ns_indent('''
    Struct(%s)
{
}
''' % (element), extraIndent)
        else: # not fImpl
            self._write(''';
''')

    # Generate a constructor with HDK_XML_Struct
    def _write_class_hdk_constructor(self, struct, fImpl = False, classScope = None, extraIndent = 0):

        method = self._class_constructor(struct)
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
%s(HDK_XML_Struct* phdkstruct) throw()''' % (method), extraIndent)

        if fImpl:
            self._write(''' :''')
            self._write_with_ns_indent('''
    Struct(phdkstruct)
{
}
''', extraIndent)
        else: # not fImpl
            self._write(''';
''')

    # Generate a get_ accessor implementation.
    def _write_class_get_accessor(self, member, fImpl = False, classScope = None, extraIndent = 0):

        element = self._module.element_value((member.namespace, member.name))

        method = self._class_get_property_method(member)
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
%s %s() const throw()''' % (self._type_type(member.type, withNS = True), method), extraIndent)

        if fImpl:
            self._write_with_ns_indent('''\

{
''', extraIndent)
            if member.type.isStruct:
                self._write_with_ns_indent('''\
    return %s(GetStruct(), %s);
''' % (self._hdk_struct_accessor(member.type, "Get"), element), extraIndent)
            else:
                # Blob type is special-cased.
                if CppClientGenerator.is_blob_type(member.type):
                    self._write_with_ns_indent('''\
    unsigned int cbBlob = 0;
    char* pbBlob = %s(GetStruct(), %s, &cbBlob);
    return Blob(pbBlob, cbBlob);
''' % (self._hdk_struct_accessor(member.type, "Get"), element), extraIndent)
                else:
                    # Determine the default value
                    if member.type.isEnum:
                        defaultValue = self._module.enum_value(member.type, None, is_unknown = True)
                    elif CppClientGenerator.is_ipaddress_type(member.type):
                        defaultValue = "HDK::IPv4Address::Blank()"
                    elif CppClientGenerator.is_macaddress_type(member.type):
                        defaultValue = "HDK::MACAddress::Blank()"
                    else:
                        defaultValue = "0"

                    # Determine the cast for the type.
                    cast = self._type_cast(member.type)
                    if CppClientGenerator.is_bool_type(member.type):
                        # Avoid Microsoft compiler warning C4800
                        cast = "0 != "
                    self._write_with_ns_indent('''\
    return %s%s(GetStruct(), %s, %s);
''' % (cast, self._hdk_struct_accessor(member.type, "GetEx"), element, defaultValue), extraIndent)
            self._write_with_ns_indent('''\
}
''', extraIndent)

        else: # not fImpl
            self._write(''';
''')

    # Generate a set_ accessor implementation.  If classScope is present, the method will be scoped in the class.
    def _write_class_set_accessor(self, member, fImpl = False, classScope = None, extraIndent = 0):

        element = self._module.element_value((member.namespace, member.name))

        if member.type.isStruct or \
                CppClientGenerator.is_blob_type(member.type) or \
                CppClientGenerator.is_ipaddress_type(member.type) or \
                CppClientGenerator.is_macaddress_type(member.type):

            argType = "const " + self._type_type(member.type, withNS = True) + "&"
        else:
            argType = self._type_type(member.type, withNS = True)

        method = self._class_set_property_method(member)
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
void %s(%s value) throw()''' % (method, argType), extraIndent)
        if fImpl:
            self._write_with_ns_indent('''\

{
''', extraIndent)

            if CppClientGenerator.supports_blank(member.type):
                self._write_with_ns_indent('''\
    if (value.IsBlank())
    {
        (void)HDK_XML_Set_Blank(GetStruct(), %s);
        return;
    }
''' % (element), extraIndent)

            # Handle non-standard value sets (struct and blob types)
            if member.type.isStruct:
                self._write_with_ns_indent('''\
    (void)%s(GetStruct(), %s, value);
''' % (self._hdk_struct_accessor(member.type, "SetEx"), element), extraIndent)

            elif CppClientGenerator.is_blob_type(member.type):
                self._write_with_ns_indent('''\
    (void)%s(GetStruct(), %s, value.get_Data(), value.get_Size());
''' % (self._hdk_struct_accessor(member.type, "Set"), element), extraIndent)

            else:
                self._write_with_ns_indent('''\
    (void)%s(GetStruct(), %s, %svalue);
''' % (self._hdk_struct_accessor(member.type, "Set"), element, self._hdk_type_cast(member.type)), extraIndent)

            self._write_with_ns_indent('''\
}
''', extraIndent)

        else: # not fImpl
            self._write(''';
''')

    # Generate a FromFile method implementation.
    def _write_class_method_from_file(self, type, fImpl = False, classScope = None, extraIndent = 0):

        method = self._class_from_file_method()
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
bool %s(const char* pszFile) throw()''' % (method), extraIndent)

        if fImpl:
            self._write_with_ns_indent('''\

{
    return HDK::Struct::DeserializeFromFile(%s(), pszFile);
}
''' % (self._module.dom_schema_fn(type)), extraIndent)
        else: # not fImpl
            self._write(''';
''')


    # Generate a ToFile method implementation.
    def _write_class_method_to_file(self, type, fImpl = False, classScope = None, extraIndent = 0):

        method = self._class_to_file_method()
        if classScope is not None:
            method = self._type_type(classScope, withNS = True) + "::" + method

        self._write_with_ns_indent('''\
bool %s(const char* pszFile) const throw()''' % (method), extraIndent)

        if fImpl:
            self._write_with_ns_indent('''\

{
    return HDK::Struct::SerializeToFile(%s(), pszFile, 0);
}
''' % (self._module.dom_schema_fn(type)), extraIndent)
        else: # not fImpl
            self._write(''';
''')

    # Generate a c++ class declaration from an HDK_XML_Struct
    def _write_class_declaration(self, struct,
                                 fGenerateSets = True, fConstructFromStruct = True,
                                 fInline = False, rootElement = None, fDOM = False):

        self._write_doxygen_section_with_ns_indent_begin()
        self._write_doxygen_string_with_ns_indent('''\
\\brief %s
     <a>%s</a>
''' % (struct.name, struct.uri))
        self._write_doxygen_lines_with_ns_indent(struct.doctext)
        self._write_doxygen_section_with_ns_indent_end()

        self._write_with_ns_indent('''\
class %s : public Struct
{
''' % (self._class_class(struct)))

        # Generate the class constructors and destructor.
        self._write_with_ns_indent('''\
public:
    //
    // Constructors/Destructor.
    //
''')
        self._write_class_default_constructor(struct, element = rootElement, fImpl = fInline, extraIndent = 4)
        self._write_newline()

        if fConstructFromStruct:
            self._write_class_hdk_constructor(struct, fImpl = fInline, extraIndent = 4)
            self._write_newline()

        # Write the accessor methods.
        for member in struct.members:

            self._write_doxygen_section_with_ns_indent_begin(4)
            self._write_doxygen_string_with_ns_indent('''\
\\brief Get the %s value.
''' % (member.name), 4)
            if member.doctext:
                self._write_doxygen_line_with_ns_indent('''\
     \\retval %s
''' % (member.doctext[0]), 4)

                self._write_doxygen_lines_with_ns_indent(member.doctext[1:], 4)
            self._write_doxygen_section_with_ns_indent_end(4)

            self._write_class_get_accessor(member, fImpl = fInline, extraIndent = 4)
            self._write_newline()

            if fGenerateSets:
                self._write_doxygen_section_with_ns_indent_begin(4)
                self._write_doxygen_string_with_ns_indent('''\
\\brief Set the %s value.
''' % (member.name), 4)
                if member.doctext:
                    self._write_doxygen_string_with_ns_indent('''\
     \\arg %s
''' % (member.doctext[0]), 4)
                    self._write_doxygen_lines_with_ns_indent(member.doctext[1:], 4)
                self._write_doxygen_section_with_ns_indent_end(4)

                self._write_class_set_accessor(member, fImpl = fInline, extraIndent = 4)
                self._write_newline()

        if fDOM:
            self._write_doxygen_section_with_ns_indent_begin(4)
            self._write_doxygen_string_with_ns_indent('''\
\\brief Serialize to/from an XML file.
''', 4)
            self._write_doxygen_section_with_ns_indent_end(4)

            self._write_class_method_from_file(struct, fImpl = fInline, extraIndent = 4)
            self._write_class_method_to_file(struct, fImpl = fInline, extraIndent = 4)
            self._write_newline()

        self._write_with_ns_indent('''\
}; // class %s : public Struct

''' % self._class_class(struct))

    # Generate a wrapper for an array class using the array template
    def _write_array_template_typedef(self, type, includeClassDeclaration = True):

        assert(type.isArray)

        self._write_doxygen_section_with_ns_indent('''\
\\class %s
     Wrapper class for accessing arrays of %s values.
''' % (self._class_class(type),
       type.arrayType.name))

        # element represents the XML element of each array item
        element = self._module.element_value((type.members[0].namespace, type.members[0].name))

        if type.arrayType.isStruct:
            if includeClassDeclaration:
                self._write_with_ns_indent('''\
class %s; // forward declaration
''' % (self._class_class(type.arrayType)))
            self._write_with_ns_indent('''\
typedef HDK::StructArray<%s, %s> %s;
typedef HDK::StructArray<%s, %s>::StructArrayIter %sIter;

''' % (self._type_type(type.arrayType, withNS = True), element, self._class_class(type),
       self._type_type(type.arrayType, withNS = True), element, self._class_class(type)))
        elif type.arrayType.isEnum:
            self._write_with_ns_indent('''\
typedef HDK::EnumArray<%s, %s, %s> %s;
typedef HDK::EnumArray<%s, %s, %s>::EnumArrayIter %sIter;

''' % (self._type_type(type.arrayType, withNS = True), self._module.enum_type_value(type.arrayType), element, self._class_class(type),
       self._type_type(type.arrayType, withNS = True), self._module.enum_type_value(type.arrayType), element, self._class_class(type)))
        elif type.arrayType.name == "datetime":
            self._write_with_ns_indent('''\
typedef HDK::DateTimeArray<%s> %s;
typedef HDK::DateTimeArray<%s>::DateTimeArrayIter %sIter;

''' % (element, self._class_class(type),
       element, self._class_class(type)))
        else:
            templateClass = type.arrayType.name.capitalize() + "Array"
            self._write_with_ns_indent('''\
typedef HDK::%s<%s> %s;
typedef HDK::%s<%s>::%sIter %sIter;

''' % (templateClass, element, self._class_class(type),
       templateClass, element, self._class_class(type), templateClass))

    #
    # Generate a c++ class definition from an HDK_XML_Struct
    #
    def _write_class_definition(self, struct,
                                fGenerateSets = True, fConstructFromStruct = True,
                                rootElement = None,
                                fDOM = False):

        assert(struct.isStruct)

        # Constructors.
        self._write_class_default_constructor(struct, element = rootElement, fImpl = True, classScope = struct)

        if fConstructFromStruct:
            self._write_newline()
            self._write_class_hdk_constructor(struct, fImpl = True, classScope = struct)

        for member in struct.members:

            element = self._module.element_value((member.namespace, member.name))

            # Get accessor
            self._write_newline()
            self._write_class_get_accessor(member, fImpl = True, classScope = struct)

            # Set accessor
            if fGenerateSets:
                self._write_newline()
                self._write_class_set_accessor(member, fImpl = True, classScope = struct)

        if fDOM:
            self._write_newline()
            self._write_class_method_from_file(struct, fImpl = True, classScope = struct)

            self._write_newline()
            self._write_class_method_to_file(struct, fImpl = True, classScope = struct)

    # Helper to generate the action method documentation
    def _write_action_method_documentation(self, action_loc, extraIndent = 0):

        (http_method, http_location, action, noauth) = \
            (action_loc.http_method, action_loc.http_location, action_loc.action, action_loc.noauth)

        bInput = (len(action.inputMember.type.members) > 0)
        bOutput = (len(action.outputMember.type.members) > 1)

        self._write_doxygen_section_with_ns_indent_begin(extraIndent)
        self._write_doxygen_string_with_ns_indent('''\
\\brief Call the %s method on a given device.
    <a>%s</a>
    This method uses HTTP method %s and location '%s'
''' % (action.name,
       action.uri,
       http_method, http_location), extraIndent)
        if noauth:
            self._write_doxygen_string_with_ns_indent('''\
    \\note This method does NOT require HTTP Basic Authorization.

''', extraIndent)
        self._write_doxygen_lines_with_ns_indent(action.doctext)
        self._write_doxygen_line_with_ns_indent("\n")

        # Write out the potential result values.
        if action.resultEnum.enumValues:
            self._write_doxygen_line_with_ns_indent('''\
    Possible result values:
''', extraIndent)
            for enumValue in action.resultEnum.enumValues:
                self._write_doxygen_line_with_ns_indent('''\
         - #%s
''' % (self._enum_value(action.resultEnum, enumValue)), extraIndent)
        self._write_doxygen_string_with_ns_indent('''\
    \\arg pTarget The target on which to call this method.
''', extraIndent)
        if bInput:
            self._write_doxygen_string_with_ns_indent('''\
    \\arg input The input argument data to the %s HNAP method.
''' % (action.name), extraIndent)

        if bOutput:
            self._write_doxygen_line_with_ns_indent('''\
    \\arg output The output argument data from the %s HNAP method.
''' % (action.name), extraIndent)

        self._write_doxygen_string_with_ns_indent('''\
    \\arg[optional] result The HNAP result of the %s HNAP method.
    \\arg timeoutSecs An optional timeout, in seconds, to use for the HNAP call.
    \\retval The result of the HNAP method call.
''' % (action.name), extraIndent)
        self._write_doxygen_section_with_ns_indent_end(extraIndent)

    # Helper to generate the action method declarations
    def _write_action_method(self, action_loc, fImpl = False, withNS = False, fNoDefaultArgs = False, extraIndent = 0):

        action = action_loc.action

        bInput = (len(action.inputMember.type.members) > 0)
        bOutput = (len(action.outputMember.type.members) > 1)

        self._write_with_ns_indent('''\
HDK::ClientError %s
(
    HDK::ITarget* pTarget,
''' % (self._action_fn(action_loc, withNS = withNS)), extraIndent)
        if bInput:
            self._write_with_ns_indent('''\
    const %s & input,
''' % (self._type_type(action.inputMember.type, withNS = True)), extraIndent)
        if bOutput:
            self._write_with_ns_indent('''\
    %s & output,
''' % (self._type_type(action.outputMember.type, withNS = True)), extraIndent)

        if fNoDefaultArgs:
            presultDefault = "/* = NULL */"
            timeoutSecsDefault = "/* = 0 */"
        else:
            presultDefault = "= NULL"
            timeoutSecsDefault = "= 0"
        self._write_with_ns_indent('''\
    %s* presult %s,
    unsigned int timeoutSecs %s
) throw()''' % (self._type_type(action.outputMember.type.members[0].type, withNS = True), presultDefault,
                timeoutSecsDefault), extraIndent)

        if fImpl:
            self._write_with_ns_indent('''\

{
    if (!pTarget)
    {
        return ClientError_InvalidArg;
    }
''', extraIndent)
            if not bInput:
                self._write_with_ns_indent('''\
    %s input;
''' % (self._type_type(action.inputMember.type, withNS = True)), extraIndent)
            if not bOutput:
                self._write_with_ns_indent('''\

    %s output;
''' % (self._type_type(action.outputMember.type, withNS = True)), extraIndent)
            self._write_with_ns_indent('''\

    ClientError error = pTarget->Request(timeoutSecs,
                                         %s(),
                                         %s,
                                         input,
                                         &output);
''' % (self._module.module_fn(),
       self._module.action_value(action_loc)), extraIndent)
            self._write_with_ns_indent('''\

    const HDK_MOD_Method* pMethod = HDK_MOD_GetMethod(%s(), %s);
''' % (self._module.module_fn(), self._module.action_value(action_loc)), extraIndent)
            self._write_with_ns_indent('''\

    // Get the result value.
    %s result = output.%s();
    if (NULL != presult)
    {
        *presult = result;
    }

    // Determine if there was an HNAP-result, and whether it was an error or not.
    if ((ClientError_OK == error) && (HDK_XML_BuiltinElement_Unknown != pMethod->hnapResultElement))
    {
        if ((pMethod->hnapResultOK != (int)result) && (pMethod->hnapResultREBOOT != (int)result))
        {
            // An HNAP error response.
            error = HDK::ClientError_HnapMethod;
        }
    }

    return error;
}
''' % (self._type_type(action.outputMember.type.members[0].type, withNS = True), \
           self._class_get_property_method(action.outputMember.type.members[0])), extraIndent)

        else: # not fImpl
            self._write(''';
''')

    # Helper to write HDK Init documentation
    def _write_init_function_documentation(self, extraIndent = 0):

        self._write_doxygen_section_with_ns_indent('''\
\\fn InitializeClient
     Initialize the HDK client library.  This should be called once per application instance.
     Each call to InitializeClient should be matched by a call to UninitializeClient.
     \\retval true if initialization was successful, false if not.
''', extraIndent)

    # Helper to write HDK Init method
    def _write_init_function(self, fImpl = False, withNS = False, extraIndent = 0):

        method = "InitializeClient"
        if withNS:
            method = "HDK::" + method

        self._write_with_ns_indent('''\
bool %s() throw()''' % (method), extraIndent)

        if fImpl:

            self._write_with_ns_indent('''\

{
    return !!HDK_CLI_Init();
}
''', extraIndent)

        else: # not fImpl

            self._write(''';
''')

    # Helper to write HDK uninit documentation
    def _write_uninit_function_documentation(self, extraIndent = 0):

        self._write_doxygen_section_with_ns_indent('''\
\\fn UninitializeClient
     Cleanup the HDK client library.  This should be called if true was returned from InitializeClient
     When the caller is done using the HDK client library.
''', extraIndent)

    # Helper to write HDK uninit method
    def _write_uninit_function(self, fImpl = False, withNS = False, extraIndent = 0):

        method = "UninitializeClient"
        if withNS:
            method = "HDK::" + method

        self._write_with_ns_indent('''\
void %s() throw()''' % (method), extraIndent)

        if fImpl:

            self._write_with_ns_indent('''\

{
    HDK_CLI_Cleanup();
}
''', extraIndent)

        else: # not fImpl

            self._write(''';
''')

    # Helper to write URI accessor macro documentation
    def _write_uri_accessor_macro_documentation(self, action_loc, extraIndent = 0):

        self._write_doxygen_section_with_ns_indent('''\
\\brief SOAP method URI for action %s
''' % (action_loc.action.name), extraIndent)

    # Helper to write URI accessor macro
    def _write_uri_accessor_macro(self, action_loc, extraIndent = 0):

        self._write_with_ns_indent('''\
#define %s (HDK_MOD_GetMethod(%s(), %s)->pszSOAPAction)
''' % (makeGlobalSymbol("", action_loc.action.namespace, action_loc.action.name, nameSuffix = "_URI"),
       self._module.module_fn(), self._module.action_value(action_loc)), extraIndent)

    #
    # .h code generator
    #
    def _generate_h(self):

        self._write_header_h(self._filename('.h'))

        self._write('''\

// Non-generated client code.
#include "hdk_cli_cpp.h"

// Underlying schema module.
#include "%s"

''' % (self._module.filename('.h')))

        self._push_namespace("HDK")

        # Write HDK global functions.
        if self._module.action_locations():
            self._write_init_function_documentation()
            self._write_init_function()
            self._write_newline()
            self._write_uninit_function_documentation()
            self._write_uninit_function()
            self._write_newline()

        # Generate c++-style enums
        for typeEnum in self._enumTypes:

            self._push_namespace(typeEnum.namespace)
            self._write_enum(typeEnum)
            self._pop_namespace()

        # Declare array types.
        for typeArray in self._arrayTypes:

            self._push_namespace(typeArray.namespace)
            self._write_array_template_typedef(typeArray)
            self._pop_namespace()

        # Generate c++ wrapper classes for each struct
        for typeStruct in self._structTypes:

            # Generate any required forward declarations.
            for member in typeStruct.members:
                # The types are sorted alphabetically, so anything greater than this one has yet to be defined.
                forwDeclType = member.type
                if forwDeclType.isArray:
                    forwDeclType = forwDeclType.arrayType
                if forwDeclType.isStruct and not forwDeclType.isArray:
                   if forwDeclType.name > typeStruct.name:
                       self._push_namespace(forwDeclType.namespace)
                       self._write_class_forward_declaration(forwDeclType)
                       self._pop_namespace()

            self._push_namespace(typeStruct.namespace)

            element = None
            if self._fDOM:
                element = self._module.element_value((typeStruct.namespace, typeStruct.name))
            self._write_class_declaration(typeStruct,
                                          fDOM = self._fDOM,
                                          fInline = self._fInline,
                                          rootElement = element)
            self._pop_namespace()

        # Generate class implementations for each action input and output structure.
        for action in self._module.actions:

            for (fGenerateSets, struct) in \
                    [(True, action.inputMember.type),
                     (False, action.outputMember.type)]:
                self._push_namespace(struct.namespace)
                self._write_class_declaration(struct,
                                              fGenerateSets, fConstructFromStruct = False,
                                              fInline = self._fInline,
                                              rootElement = self._module.element_value((action.namespace, action.name)))
                self._pop_namespace()

        # Generate the action method declarations.
        for action_loc in self._module.action_locations():
            self._push_namespace(action_loc.action.namespace)

            # Generate accessors for macros URIs.
            if action_loc.http_method == "POST":
                self._write_uri_accessor_macro_documentation(action_loc)
                self._write_uri_accessor_macro(action_loc)
                self._write_newline()

            self._write_action_method_documentation(action_loc)
            self._write_action_method(action_loc)
            self._write_newline()
            self._pop_namespace()

        # Make sure the previous namespace is closed.
        self._pop_namespace()

        # Should be in the HDK namespace scope
        assert(self._namespaceStack[-1].namespace == "HDK")

        # Close HDK namespace
        self._pop_namespace(True)

    #
    # .cpp code generator
    #
    def _generate_cpp(self):

        self._write_header_cpp(self._filename('.cpp'))

        self._write('''\

// Local header.
#include "%s"

using namespace HDK;
''' % (self._filename('.h')))

        if not self._fInline:
            # Generate class implementations for each structure type.
            for type in self._structTypes:
                element = None
                if self._fDOM:
                    element = self._module.element_value((type.namespace, type.name))

                self._write_newline()
                self._write_class_definition(type, fDOM = self._fDOM, rootElement = element)

            # Generate class implementations for each action input and output structure.
            for action in self._module.actions:
                for (fGenerateSets, member) in \
                        [(True, action.inputMember),
                         (False, action.outputMember)]:
                    self._write_newline()
                    self._write_class_definition(member.type,
                                                 fGenerateSets,
                                                 fConstructFromStruct = False,
                                                 rootElement = self._module.element_value((action.namespace, action.name)))

        # Write the action method definitions.
        if self._module.action_locations():
            # Write HDK global init/cleanup function definitions.
            self._write_newline()
            self._write_init_function(fImpl = True, withNS = True)
            self._write_newline()
            self._write_uninit_function(fImpl = True, withNS = True)

            for action_loc in self._module.action_locations():
                self._write_newline()
                self._write_action_method(action_loc, fImpl = True, withNS = True, fNoDefaultArgs = True)

예제 #8

파일: hdkmod.py 프로젝트: WizzerWorks/Utopia

class ModuleGenerator:

    # Class initializer
    def __init__(self, model, baseName, noid, friendlyName,
                 actionLocation, bGenerateDOMSchemas,
                 bGenerateMethods, bClient, bADIReport):

        self._model = model

        # Options
        self._baseName = baseName
        self._noid = noid
        self._friendlyName = friendlyName
        self._bGenerateMethods = bGenerateMethods
        self._bADIReport = bADIReport

        # Generator state
        self._out = None

        # Module
        self._module = HDKModule(model, baseName, actionLocation, bGenerateDOMSchemas)

        # Generation options
        self._bGenerateActions = not bClient and self._module.actions
        self._bGenerateServices = not bClient and self._module.services
        self._bGenerateModule = self._module.actions or self._module.events
        self._bGenerateModuleDynamic = not bClient and self._bGenerateModule

    #
    # Generate code
    #

    def generate(self, dir, fhReport):

        for file, fn, bGenerate in \
                [(os.path.join(dir, self._module.filename('.h')), self._generate_h, not self._bGenerateMethods),
                 (os.path.join(dir, self._module.filename('.c')), self._generate_c, not self._bGenerateMethods),
                 (os.path.join(dir, self._module.filename('_methods.c')), self._generate_methods_c, self._bGenerateMethods),
                 (os.path.join(dir, self._module.filename('_adi.txt')), self._generate_adi_txt, self._bADIReport)]:

            if bGenerate:

                if fhReport is not None:
                    print >>fhReport, 'Generating "%s" ...' % file

                self._out = open(file, "w")
                try:
                    fn()
                except:
                    raise
                finally:
                    self._out.close()


    #
    # Output helper methods
    #

    # Output
    def _write(self, s):

        self._out.write(s)

    # Write .c file header
    def _write_header_c(self):

        self._write('''\
/*
 * Copyright (c) 2008-2010 Cisco Systems, Inc. All rights reserved.
 *
 * Cisco Systems, Inc. retains all right, title and interest (including all
 * intellectual property rights) in and to this computer program, which is
 * protected by applicable intellectual property laws.  Unless you have obtained
 * a separate written license from Cisco Systems, Inc., you are not authorized
 * to utilize all or a part of this computer program for any purpose (including
 * reproduction, distribution, modification, and compilation into object code),
 * and you must immediately destroy or return to Cisco Systems, Inc. all copies
 * of this computer program.  If you are licensed by Cisco Systems, Inc., your
 * rights to utilize this computer program are limited by the terms of that
 * license.  To obtain a license, please contact Cisco Systems, Inc.
 *
 * This computer program contains trade secrets owned by Cisco Systems, Inc.
 * and, unless unauthorized by Cisco Systems, Inc. in writing, you agree to
 * maintain the confidentiality of this computer program and related information
 * and to not disclose this computer program and related information to any
 * other person or entity.
 *
 * THIS COMPUTER PROGRAM IS PROVIDED AS IS WITHOUT ANY WARRANTIES, AND CISCO
 * SYSTEMS, INC. EXPRESSLY DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED,
 * INCLUDING THE WARRANTIES OF MERCHANTIBILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, TITLE, AND NONINFRINGEMENT.
 */
''')

    # Write .h file header
    def _write_header_h(self):

        self._write_header_c();
        self._write('''\

#ifndef %s
#define %s
''' % (self._module.header_sentinel('.h'), self._module.header_sentinel('.h')))

    # Write .h file footer
    def _write_footer_h(self):

        self._write('''\

#endif /* %s */
''' % (self._module.header_sentinel('.h')))

    # Write a section comment
    def _write_section(self, comment):

            self._write('''\


/*
 * %s
 */

''' % (comment))

    # Write enumeration definition
    def _write_enumeration(self, name, values, ix_start = 0, ix_delta = 1, value_symbols = {}):

        # Enum header
        self._write('''\
typedef enum _%s
{
''' % (name))

        # Write enum values
        ix_value = ix_start
        ix_value_last = ix_start + ix_delta * (len(values) - 1)
        sep = ","
        for value in values:

            # Does the value have a symbol?
            if value_symbols.has_key(value):
                str_value = value_symbols[value]
            else:
                str_value = str(ix_value)

            # Don't separate the last value
            if ix_value == ix_value_last:
                sep = ""

            # Write the enum value
            self._write('''\
    %s = %s%s
''' % (value, str_value, sep))

            ix_value += ix_delta

        # Enum footer
        self._write('''\
} %s;
''' % (name))

    # Write schema definition
    def _write_schema(self, schema_nodes_static, schema_static, nodes,
                      element_path_static = None, element_path = None):

        # Schema nodes header
        self._write('''\
static const HDK_XML_SchemaNode %s[] =
{
''' % (schema_nodes_static))

        # Write the schema nodes
        ix = 0
        for node in nodes:

            # Compute the parent index
            if node.parent:
                ix_parent = nodes.index(node.parent)
            else:
                ix_parent = 0

            # Compute the options
            options = []
            if node.is_optional:
                options.append("HDK_XML_SchemaNodeProperty_Optional")
            if node.is_unbounded:
                options.append("HDK_XML_SchemaNodeProperty_Unbounded")
            if node.is_any_element:
                options.append("HDK_XML_SchemaNodeProperty_AnyElement")
            if node.is_error:
                options.append("HDK_XML_SchemaNodeProperty_ErrorOutput")
            if node.is_csv:
                options.append("HDK_XML_SchemaNodeProperty_CSV")
            if options:
                options = " | ".join(options)
            else:
                options = "0"

            # Write the schema node
            self._write('''\
    /* %d */ { %d, %s, %s, %s },
''' % (ix, ix_parent,
       self._module.element_value(node.element()),
       self._module.type_value(node.type),
       options))
            ix += 1

        # Schema nodes footer
        self._write('''\
    HDK_XML_Schema_SchemaNodesEnd
};
''')

        # Schema struct element path
        if element_path_static and element_path:

            self._write('''\

static const HDK_XML_Element %s[] =
{
''' % (element_path_static))
            for element in element_path:
                self._write('''\
    %s,
''' % (self._module.element_value(element)))
            self._write('''\
    HDK_MOD_ElementPathEnd
};
''')

        # Schema
        self._write('''\

static const HDK_XML_Schema %s =
{
    s_namespaces,
    s_elements,
    %s,
    %s
};
''' % (schema_static,
       schema_nodes_static,
       "s_enumTypes" if self._module.schema.enums else "0"))

    # Write action definition
    def _write_action(self, action_loc):

        http_method, http_location, action, noauth = \
            (action_loc.http_method, action_loc.http_location, action_loc.action, action_loc.noauth)

        # Compute the SOAP action
        is_get = (http_method.lower() == "get")
        if is_get:
            soap_action = "0"
        else:
            soap_action = '"' + action.uri + '"'

        # Compute the action function name
        if self._bGenerateActions:
            action_fn = self._module.action_fn(action)
        else:
            action_fn = "0"

        # Compute the schema struct element path symbols
        if not is_get and self._module.schema.struct_nodes_envelope(action.inputMember, soap = True):
            input_element_path = self._module.schema_element_path_static(action, "_Input")
        else:
            input_element_path = "0"
        if self._module.schema.struct_nodes_envelope(action.outputMember, soap = True):
            output_element_path = self._module.schema_element_path_static(action, "_Output")
        else:
            output_element_path = "0"

        # Compute the method options
        options = []
        if noauth:
            options.append("HDK_MOD_MethodOption_NoBasicAuth")
        if is_get:
            options.append("HDK_MOD_MethodOption_NoInputStruct")
        if options:
            options = " | ".join(options)
        else:
            options = "0"

        # Compute the OK and REBOOT values
        result_member = action.outputMember.type.members[0]
        if "REBOOT" in action.resultEnum.enumValues:
            result_reboot = "REBOOT"
        else:
            result_reboot = "OK"

        # Write the method struct
        self._write('''\
    {
        "%s",
        "%s",
        %s,
        %s,
        &%s,
        &%s,
        %s,
        %s,
        %s,
        %s,
        %s,
        %s,
        %s
    },
''' % (http_method,
       http_location,
       soap_action,
       action_fn,
       self._module.schema_static(action, suffix = "_Input"),
       self._module.schema_static(action, suffix = "_Output"),
       input_element_path,
       output_element_path,
       options,
       self._module.element_value((result_member.namespace, result_member.name)),
       self._module.type_value(result_member.type),
       self._module.enum_value(result_member.type, "OK"),
       self._module.enum_value(result_member.type, result_reboot)))

    # Write event definition
    def _write_event(self, event):

        # Write the method struct
        self._write('''\
    {
        "%s",
        &%s
    },
''' % (event.uri,
       self._module.schema_static(event)))


    #
    # *.h code generator
    #

    def _generate_h(self):

        # File header
        self._write_header_h()

        # Includes
        self._write('''\

#include "hdk_mod.h"


/*
 * Macro to control public exports
 */

#ifdef __cplusplus
#  define %s_PREFIX extern "C"
#else
#  define %s_PREFIX extern
#endif
#ifdef HDK_MOD_STATIC
#  define %s %s_PREFIX
#else /* ndef HDK_MOD_STATIC */
#  ifdef _MSC_VER
#    ifdef %s
#      define %s %s_PREFIX __declspec(dllexport)
#    else
#      define %s %s_PREFIX __declspec(dllimport)
#    endif
#  else /* ndef _MSC_VER */
#    ifdef %s
#      define %s %s_PREFIX __attribute__ ((visibility("default")))
#    else
#      define %s %s_PREFIX
#    endif
#  endif /*def _MSC_VER */
#endif /* def HDK_MOD_STATIC */
''' % (self._module.export_macro(),
       self._module.export_macro(),
       self._module.export_macro(), self._module.export_macro(),
       self._module.build_macro(),
       self._module.export_macro(), self._module.export_macro(),
       self._module.export_macro(), self._module.export_macro(),
       self._module.build_macro(),
       self._module.export_macro(), self._module.export_macro(),
       self._module.export_macro(), self._module.export_macro()))

        # Element enumeration
        self._write_section("Elements")
        self._write_enumeration(self._module.element_enum(),
                                [ self._module.element_value(element) for element in self._module.schema.elements ])

        # Enumeration type definition
        if self._module.schema.enums:

            self._write_section("Enum types enumeration")
            self._write_enumeration(self._module.enum_type_enum(),
                                    [ self._module.enum_type_value(enum) for enum in self._module.schema.enums ],
                                    ix_start = -1, ix_delta = -1)

        # Enumeration declarations
        for enum in self._module.schema.enums:

            # Enumeration type definition
            self._write_section("Enumeration %s" % (enum.uri))
            value_unknown = self._module.enum_value(enum, None, is_unknown = True)
            values = [ value_unknown ]
            values.extend([ self._module.enum_value(enum, value) for value in enum.enumValues ])
            self._write_enumeration(self._module.enum_enum(enum), values, ix_start = -1,
                                    value_symbols = { value_unknown: "HDK_XML_Enum_Unknown" })

            # Enumeration accessor declarations
            self._write('''\

#define %s(pStruct, element, value) HDK_XML_Set_Enum(pStruct, element, %s, 0 ? %s : (value))
#define %s(pStruct, element, value) HDK_XML_Append_Enum(pStruct, element, %s, 0 ? %s : (value))
#define %s(pStruct, element) (%s*)HDK_XML_Get_Enum(pStruct, element, %s)
#define %s(pStruct, element, value) (%s)HDK_XML_GetEx_Enum(pStruct, element, %s, 0 ? %s : (value))
#define %s(pMember) (%s*)HDK_XML_GetMember_Enum(pMember, %s)
''' % (self._module.enum_accessor(enum, "Set"), self._module.enum_type_value(enum), self._module.enum_value(enum, enum.enumValues[0]),
       self._module.enum_accessor(enum, "Append"), self._module.enum_type_value(enum), self._module.enum_value(enum, enum.enumValues[0]),
       self._module.enum_accessor(enum, "Get"), self._module.enum_enum(enum), self._module.enum_type_value(enum),
       self._module.enum_accessor(enum, "GetEx"), self._module.enum_enum(enum), self._module.enum_type_value(enum), self._module.enum_value(enum, enum.enumValues[0]),
       self._module.enum_accessor(enum, "GetMember"), self._module.enum_enum(enum), self._module.enum_type_value(enum)))

        # Action enumeration
        if self._module.actions:
            self._write_section("Method enumeration")
            self._write_enumeration(self._module.action_enum(),
                                    [ self._module.action_value(action_loc) for action_loc in self._module.action_locations() ])

        # Action sentinels
        if self._bGenerateActions:
            self._write_section("Method sentinels")
            for action in self._module.actions:
                self._write('''\
#define %s
''' % (self._module.action_sentinel(action)))

        # Action declarations
        if self._bGenerateActions:
            self._write_section("Methods")
            for action in self._module.actions:
                self._write('''\
extern void %s(HDK_MOD_MethodContext* pMethodCtx, HDK_XML_Struct* pInput, HDK_XML_Struct* pOutput);
''' % (self._module.action_fn(action)))

        # Event enumeration
        if self._module.events:
            self._write_section("Event enumeration")
            self._write_enumeration(self._module.event_enum(),
                                    [ self._module.event_value(event) for event in self._module.events ])

        # DOM (struct) schema accessor declarations
        if self._module.schema.structs:
            self._write_section("DOM Schemas")
        for struct in self._module.schema.structs:
            self._write('''\
%s const HDK_XML_Schema* %s();
''' % (self._module.export_macro(), self._module.dom_schema_fn(struct)))

        # State declarations
        if self._module.states:

            self._write_section("ADI")
            self._write_enumeration(self._module.state_enum(),
                                    [ self._module.state_value(state) for state in self._module.states ],
                                    ix_start = 1)

            self._write_section("ADI sentinels")
            for state in self._module.states:

                # Determine get/set
                usages = {}
                for actionState in self._model.actionStates:
                    if state.uri in actionState.stateMembers:
                        stateMember = actionState.stateMembers[state.uri]
                        if stateMember.isGet:
                            usages["get"] = None
                        if stateMember.isSet:
                            usages["set"] = None

                for usage in sorted(usages.iterkeys()):
                    self._write('''\
#define %s
''' % (self._module.state_value_sentinel(state, usage)))

        # Module declaration
        if self._bGenerateModule:

            self._write_section("Module")
            self._write('''\
%s const HDK_MOD_Module* %s(void);
''' % (self._module.export_macro(), self._module.module_fn()))

            if self._bGenerateModuleDynamic:
                self._write('''\

/* Dynamic server module export */
%s const HDK_MOD_Module* HDK_SRV_Module(void);
''' % (self._module.export_macro()))

        # File footer
        self._write_footer_h()


    #
    # *.c code generator
    #

    def _generate_c(self):

        # File header
        self._write_header_c()
        self._write('''\

#include "%s"

#include <string.h>
''' % (self._module.filename('.h')))

        # Namespace table
        self._write_section("Namespaces")
        self._write('''\
static const HDK_XML_Namespace s_namespaces[] =
{
''')
        for namespace in self._module.schema.namespaces:
            self._write('''\
    /* %d */ "%s",
''' % (self._module.schema.namespace_index(namespace),
       namespace))
        self._write('''\
    HDK_XML_Schema_NamespacesEnd
};
''')

        # Elements table
        self._write_section("Elements")
        self._write('''\
static const HDK_XML_ElementNode s_elements[] =
{
''')
        for element in self._module.schema.elements:
            self._write('''\
    /* %s = %d */ { %d, "%s" },
''' % (self._module.element_value(element),
       self._module.schema.element_index(element),
       self._module.schema.namespace_index(element[0]),
       element[1]))
        self._write('''\
    HDK_XML_Schema_ElementsEnd
};
''')

        # Enumerations definitions
        for enum in self._module.schema.enums:

            # Enumeration string table
            self._write_section("Enumeration %s" % (enum.uri))
            self._write('''\
static const HDK_XML_EnumValue %s[] =
{
''' % (self._module.enum_type_strings_static(enum)))
            for value in enum.enumValues:
                self._write('''\
    "%s",
''' % (value))
            self._write('''\
    HDK_XML_Schema_EnumTypeValuesEnd
};
''')

        # Enum types array
        if self._module.schema.enums:

            self._write_section("Enumeration types array")
            self._write('''\
static const HDK_XML_EnumType s_enumTypes[] =
{
''')
            sep = ','
            for enum in self._module.schema.enums:
                if enum is self._module.schema.enums[-1]:
                    sep = ""
                self._write('''\
    %s%s
''' % (self._module.enum_type_strings_static(enum), sep))
            self._write('''\
};
''')

        # Action definitions
        for action in self._module.actions:

            self._write_section("Method %s" % (action.uri))

            # Input schema
            self._write_schema(self._module.schema_nodes_static(action, suffix = "_Input"),
                               self._module.schema_static(action, suffix = "_Input"),
                               self._module.schema.struct_nodes(action.inputMember, soap = True),
                               element_path_static = self._module.schema_element_path_static(action, suffix = "_Input"),
                               element_path = self._module.schema.struct_nodes_envelope(action.inputMember, soap = True))

            # Output schema
            self._write('''\

''')
            self._write_schema(self._module.schema_nodes_static(action, suffix = "_Output"),
                               self._module.schema_static(action, suffix = "_Output"),
                               self._module.schema.struct_nodes(action.outputMember, soap = True),
                               element_path_static = self._module.schema_element_path_static(action, suffix = "_Output"),
                               element_path = self._module.schema.struct_nodes_envelope(action.outputMember, soap = True))

        # Actions table
        if self._module.actions:

            self._write_section("Methods")

            # Actions table header
            self._write('''\
static const HDK_MOD_Method s_methods[] =
{
''')

            # Write each action node
            for action_loc in self._module.action_locations():
                self._write_action(action_loc)

            # Actions table footer
            self._write('''\
    HDK_MOD_MethodsEnd
};
''')

        # Event definitions
        for event in self._module.events:

            self._write_section("Event %s" % (event.uri))
            self._write_schema(self._module.schema_nodes_static(event),
                               self._module.schema_static(event),
                               self._module.schema.struct_nodes(event.member))

        # Events table
        if self._module.events:

            self._write_section("Events")

            # Events table header
            self._write('''\
static const HDK_MOD_Event s_events[] =
{
''')

            # Write each event node
            for event in self._module.events:
                self._write_event(event)

            # Events table footer
            self._write('''\
    HDK_MOD_EventsEnd
};
''')

        if self._bGenerateServices:

            # Services action tables
            self._write_section("Service Methods")
            for service in self._module.services:

                # Service actions header
                self._write('''\
static const HDK_MOD_Method* %s[] =
{
''' % (self._module.service_actions_name(service)))

                # Service actions
                for action_uri in service.actions:

                    action_loc = [a for a in self._module.action_locations() if a.action.uri == action_uri][0]
                    self._write('''\
    &s_methods[%s],
''' % (self._module.action_value(action_loc)))

                # Service actions footer
                self._write('''\
    0
};
''')

            # Services event tables
            self._write_section("Service Events")
            for service in self._module.services:

                # Service events header
                self._write('''\
static const HDK_MOD_Event* %s[] =
{
''' % (self._module.service_events_name(service)))

                # Service events
                for eventURI in service.events:

                    event = [e for e in self._module.events if e.uri == eventURI][0]
                    self._write('''\
    &s_events[%s],
''' % (self._module.event_value(event)))

                # Service events footer
                self._write('''\
    0
};
''')

            # Services table
            self._write_section("Services")

            # Services table header
            self._write('''\
static const HDK_MOD_Service s_services[] =
{
''')

            # Write each service node
            for service in self._module.services:
                self._write('''\
    {
        "%s",
        %s,
        %s
    },
''' % (service.uri,
       self._module.service_actions_name(service),
       self._module.service_events_name(service)))

            # Services table footer
            self._write('''\
    HDK_MOD_ServicesEnd
};
''')

        # State definitions
        if self._module.states:

            self._write_section("ADI")
            self._write_schema("s_schemaNodes_ADI", "s_schema_ADI",
                               self._module.schema.state_nodes())

        # Struct schema definitions
        for struct in self._module.schema.structs:
            self._write_section("Struct %s" % (struct.uri))
            self._write_schema(self._module.schema_nodes_static(struct),
                               self._module.schema_static(struct),
                               self._module.schema.struct_nodes(struct))
            self._write('''\

/* extern */ const HDK_XML_Schema* %s()
{
    return &%s;
}
''' % (self._module.dom_schema_fn(struct),
       self._module.schema_static(struct)))

        # Module definition
        if self._bGenerateModule:

            self._write_section("Module");

            # Network Object ID definition
            if self._noid is not None:
                self._write('''\
/* %s */
static const HDK_XML_UUID s_uuid_NOID =
{
    { %s }
};

''' % (self._noid, ", ".join(["0x%02x" % ord(byte) for byte in self._noid.bytes])))

            # Module definition and accessors
            self._write('''\
static const HDK_MOD_Module s_module =
{
    %s,
    %s,
    %s,
    %s,
    %s,
    %s
};

const HDK_MOD_Module* %s(void)
{
    return &s_module;
}
''' % (
    "&s_uuid_NOID" if self._noid else "0",
    '"' + self._friendlyName + '"' if self._friendlyName else "0",
    "s_services" if self._bGenerateServices else "0",
    "s_methods" if self._module.actions else "0",
    "s_events" if self._module.events else "0",
    "&s_schema_ADI" if self._module.states else "0",
    self._module.module_fn()
    ))

            if self._bGenerateModuleDynamic:
                self._write('''\

const HDK_MOD_Module* HDK_SRV_Module(void)
{
    return &s_module;
}
''')


    #
    # *_methods.c code generator
    #

    def _generate_methods_c(self):

        # File header
        self._write_header_c()
        self._write('''\

#include "%s"

#include "hdk_srv.h"


/* Helper method for HNAP results */
#define SetHNAPResult(pStruct, prefix, method, result) \\
    prefix##_Set_##method##Result(pStruct, prefix##_Element_##method##Result, prefix##_Enum_##method##Result_##result)
''' % (self._module.filename('.h')))

        # Action declarations
        for action in self._module.actions:

            self._write_section("Method %s" % (action.uri))
            self._write('''\
#ifdef %s

void %s(HDK_MOD_MethodContext* pMethodCtx, HDK_XML_Struct* pInput, HDK_XML_Struct* pOutput)
{
    /* Unused parameters */
    (void)pMethodCtx;
    (void)pInput;
    (void)pOutput;
}

#endif /* %s */
''' % (self._module.action_sentinel(action),
       self._module.action_fn(action),
       self._module.action_sentinel(action)))


    #
    # *_adi.txt report generator
    #

    def _generate_adi_txt(self):

        # ADI report title
        self._write('''\
======================================================================
ADI Report for the %s Module
======================================================================
''' % (self._baseName.upper()))

        # Output the ADI values used (show get/set)
        self._write('''\


======================================================================
ADI values
======================================================================
''')
        for state in self._model.referenced_states():

            # Determine get/set
            usages = {}
            for actionState in self._model.actionStates:
                if state.uri in actionState.stateMembers:
                    stateMember = actionState.stateMembers[state.uri]
                    if stateMember.isGet:
                        usages["get"] = None
                    if stateMember.isSet:
                        usages["set"] = None
            sUsages = ', '.join(sorted(usages.iterkeys()))

            # Get the base type
            type = state.type
            nArray = 0
            while type.isArray:
                nArray += 1
                type = type.arrayType
            sArray = "[]" * nArray

            # Get the type description
            sDesc = ""
            if type.isEnum:
                sDesc = "enum"
            elif type.isStruct:
                sDesc = "struct"

            # Get the type string
            if sDesc:
                sType = '%s%s (%s, "%s")' % (type.name, sArray, sDesc, type.namespace)
            else:
                sType = '%s%s' % (type.name, sArray)

            self._write('''\

%s

    Namespace: "%s"
         Name: "%s"
         Type: %s
        Usage: %s
''' % (self._module.state_value(state), state.namespace, state.name, sType, sUsages))

        # Output the ADI values used by action
        self._write('''\


======================================================================
ADI values by action
======================================================================
''')
        for actionState in self._model.actionStates:
            self._write('''\

%s

''' % (actionState.uri))
            for stateMember in sorted(actionState.stateMembers.itervalues()):

                # Determine usage
                usages = {}
                if stateMember.isGet:
                    usages["get"] = None
                if stateMember.isSet:
                    usages["set"] = None
                sUsages = ', '.join(sorted(usages.iterkeys()))

                self._write('''\
    [%s] %s
''' % (sUsages, self._module.state_value(stateMember.state)))