From bd354363f83e4f43cea16cd17dd2f2bb209872ee Mon Sep 17 00:00:00 2001 From: Dirk Thomas Date: Thu, 18 Apr 2019 14:29:47 -0700 Subject: [PATCH] update code to match refactoring of rosidl definitions Signed-off-by: Dirk Thomas --- rosidl_generator_py/resource/_action.py.em | 38 +-- .../_action_pkg_typesupport_entry_point.c.em | 20 +- .../_idl_pkg_typesupport_entry_point.c.em | 6 +- rosidl_generator_py/resource/_msg.py.em | 166 ++++++------- .../_msg_pkg_typesupport_entry_point.c.em | 22 +- .../resource/_msg_support.c.em | 220 +++++++++--------- rosidl_generator_py/resource/_srv.py.em | 26 +-- .../_srv_pkg_typesupport_entry_point.c.em | 10 +- .../rosidl_generator_py/generate_py_impl.py | 67 +++--- 9 files changed, 289 insertions(+), 286 deletions(-) diff --git a/rosidl_generator_py/resource/_action.py.em b/rosidl_generator_py/resource/_action.py.em index f266d314..9f1877ba 100644 --- a/rosidl_generator_py/resource/_action.py.em +++ b/rosidl_generator_py/resource/_action.py.em @@ -2,7 +2,7 @@ @{ from rosidl_cmake import convert_camel_case_to_lower_case_underscore -action_name = '_' + convert_camel_case_to_lower_case_underscore(action.structure_type.name) +action_name = '_' + convert_camel_case_to_lower_case_underscore(action.namespaced_type.name) module_name = '_' + convert_camel_case_to_lower_case_underscore(interface_path.stem) TEMPLATE( @@ -32,8 +32,8 @@ TEMPLATE( }@ -class Metaclass_@(action.structure_type.name)(type): - """Metaclass of action '@(action.structure_type.name)'.""" +class Metaclass_@(action.namespaced_type.name)(type): + """Metaclass of action '@(action.namespaced_type.name)'.""" _TYPE_SUPPORT = None @@ -46,12 +46,12 @@ class Metaclass_@(action.structure_type.name)(type): import logging import traceback logger = logging.getLogger( - '@('.'.join(action.structure_type.namespaces + [action.structure_type.name]))') + '@('.'.join(action.namespaced_type.namespaces + [action.namespaced_type.name]))') logger.debug( 'Failed to import needed modules for type support:\n' + traceback.format_exc()) else: - cls._TYPE_SUPPORT = module.type_support_action__@('__'.join(action.structure_type.namespaces[1:]))_@(action_name) + cls._TYPE_SUPPORT = module.type_support_action__@('__'.join(action.namespaced_type.namespaces[1:]))_@(action_name) from action_msgs.msg import _goal_status_array if _goal_status_array.Metaclass_GoalStatusArray._TYPE_SUPPORT is None: @@ -60,32 +60,32 @@ class Metaclass_@(action.structure_type.name)(type): if _cancel_goal.Metaclass_CancelGoal._TYPE_SUPPORT is None: _cancel_goal.Metaclass_CancelGoal.__import_type_support__() - from @('.'.join(action.structure_type.namespaces)) import @(module_name) - if @(module_name).Metaclass_@(action.send_goal_service.structure_type.name)._TYPE_SUPPORT is None: - @(module_name).Metaclass_@(action.send_goal_service.structure_type.name).__import_type_support__() - if @(module_name).Metaclass_@(action.get_result_service.structure_type.name)._TYPE_SUPPORT is None: - @(module_name).Metaclass_@(action.get_result_service.structure_type.name).__import_type_support__() - if @(module_name).Metaclass_@(action.feedback_message.structure.type.name)._TYPE_SUPPORT is None: - @(module_name).Metaclass_@(action.feedback_message.structure.type.name).__import_type_support__() + from @('.'.join(action.namespaced_type.namespaces)) import @(module_name) + if @(module_name).Metaclass_@(action.send_goal_service.namespaced_type.name)._TYPE_SUPPORT is None: + @(module_name).Metaclass_@(action.send_goal_service.namespaced_type.name).__import_type_support__() + if @(module_name).Metaclass_@(action.get_result_service.namespaced_type.name)._TYPE_SUPPORT is None: + @(module_name).Metaclass_@(action.get_result_service.namespaced_type.name).__import_type_support__() + if @(module_name).Metaclass_@(action.feedback_message.structure.namespaced_type.name)._TYPE_SUPPORT is None: + @(module_name).Metaclass_@(action.feedback_message.structure.namespaced_type.name).__import_type_support__() -class @(action.structure_type.name)(metaclass=Metaclass_@(action.structure_type.name)): +class @(action.namespaced_type.name)(metaclass=Metaclass_@(action.namespaced_type.name)): # The goal message defined in the action definition. - from @('.'.join(action.structure_type.namespaces)).@(module_name) import @(action.goal.structure.type.name) as Goal + from @('.'.join(action.namespaced_type.namespaces)).@(module_name) import @(action.goal.structure.namespaced_type.name) as Goal # The result message defined in the action definition. - from @('.'.join(action.structure_type.namespaces)).@(module_name) import @(action.result.structure.type.name) as Result + from @('.'.join(action.namespaced_type.namespaces)).@(module_name) import @(action.result.structure.namespaced_type.name) as Result # The feedback message defined in the action definition. - from @('.'.join(action.structure_type.namespaces)).@(module_name) import @(action.feedback.structure.type.name) as Feedback + from @('.'.join(action.namespaced_type.namespaces)).@(module_name) import @(action.feedback.structure.namespaced_type.name) as Feedback class Impl: # The send_goal service using a wrapped version of the goal message as a request. - from @('.'.join(action.structure_type.namespaces)).@(module_name) import @(action.send_goal_service.structure_type.name) as SendGoalService + from @('.'.join(action.namespaced_type.namespaces)).@(module_name) import @(action.send_goal_service.namespaced_type.name) as SendGoalService # The get_result service using a wrapped version of the result message as a response. - from @('.'.join(action.structure_type.namespaces)).@(module_name) import @(action.get_result_service.structure_type.name) as GetResultService + from @('.'.join(action.namespaced_type.namespaces)).@(module_name) import @(action.get_result_service.namespaced_type.name) as GetResultService # The feedback message with generic fields which wraps the feedback message. - from @('.'.join(action.structure_type.namespaces)).@(module_name) import @(action.feedback_message.structure.type.name) as FeedbackMessage + from @('.'.join(action.namespaced_type.namespaces)).@(module_name) import @(action.feedback_message.structure.namespaced_type.name) as FeedbackMessage # The generic service to cancel a goal. from action_msgs.srv._cancel_goal import CancelGoal as CancelGoalService diff --git a/rosidl_generator_py/resource/_action_pkg_typesupport_entry_point.c.em b/rosidl_generator_py/resource/_action_pkg_typesupport_entry_point.c.em index 44d7e301..f3de723b 100644 --- a/rosidl_generator_py/resource/_action_pkg_typesupport_entry_point.c.em +++ b/rosidl_generator_py/resource/_action_pkg_typesupport_entry_point.c.em @@ -3,7 +3,7 @@ @{ TEMPLATE( '_msg_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=action.structure_type, + package_name=package_name, idl_type=action.namespaced_type, message=action.goal, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) @@ -12,7 +12,7 @@ TEMPLATE( @{ TEMPLATE( '_msg_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=action.structure_type, + package_name=package_name, idl_type=action.namespaced_type, message=action.result, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) @@ -21,7 +21,7 @@ TEMPLATE( @{ TEMPLATE( '_msg_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=action.structure_type, + package_name=package_name, idl_type=action.namespaced_type, message=action.feedback, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) @@ -30,7 +30,7 @@ TEMPLATE( @{ TEMPLATE( '_srv_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=action.structure_type, + package_name=package_name, idl_type=action.namespaced_type, service=action.send_goal_service, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) @@ -39,7 +39,7 @@ TEMPLATE( @{ TEMPLATE( '_srv_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=action.structure_type, + package_name=package_name, idl_type=action.namespaced_type, service=action.get_result_service, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) @@ -48,7 +48,7 @@ TEMPLATE( @{ TEMPLATE( '_msg_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=action.structure_type, + package_name=package_name, idl_type=action.namespaced_type, message=action.feedback_message, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) @@ -56,12 +56,12 @@ TEMPLATE( @{ from rosidl_cmake import convert_camel_case_to_lower_case_underscore -type_name = convert_camel_case_to_lower_case_underscore(action.structure_type.name) +type_name = convert_camel_case_to_lower_case_underscore(action.namespaced_type.name) function_name = 'type_support' }@ @{ -register_function = '_register_action_type__' + '__'.join(action.structure_type.namespaces[1:] + [type_name]) +register_function = '_register_action_type__' + '__'.join(action.namespaced_type.namespaces[1:] + [type_name]) register_functions.append(register_function) }@ int8_t @@ -70,7 +70,7 @@ int8_t int8_t err; PyObject * pyobject_@(function_name) = NULL; pyobject_@(function_name) = PyCapsule_New( - (void *)ROSIDL_TYPESUPPORT_INTERFACE__ACTION_SYMBOL_NAME(rosidl_typesupport_c, @(', '.join(action.structure_type.namespaces + [action.structure_type.name])))(), + (void *)ROSIDL_TYPESUPPORT_INTERFACE__ACTION_SYMBOL_NAME(rosidl_typesupport_c, @(', '.join(action.namespaced_type.namespaces + [action.namespaced_type.name])))(), NULL, NULL); if (!pyobject_@(function_name)) { // previously added objects will be removed when the module is destroyed @@ -78,7 +78,7 @@ int8_t } err = PyModule_AddObject( pymodule, - "@(function_name)_action__@('__'.join(action.structure_type.namespaces[1:] + [type_name]))", + "@(function_name)_action__@('__'.join(action.namespaced_type.namespaces[1:] + [type_name]))", pyobject_@(function_name)); if (err) { // the created capsule needs to be decremented diff --git a/rosidl_generator_py/resource/_idl_pkg_typesupport_entry_point.c.em b/rosidl_generator_py/resource/_idl_pkg_typesupport_entry_point.c.em index 9807270c..5e4deae9 100644 --- a/rosidl_generator_py/resource/_idl_pkg_typesupport_entry_point.c.em +++ b/rosidl_generator_py/resource/_idl_pkg_typesupport_entry_point.c.em @@ -43,7 +43,7 @@ static struct PyModuleDef @(package_name)__module = { @{ TEMPLATE( '_msg_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=message.structure.type, message=message, + package_name=package_name, idl_type=message.structure.namespaced_type, message=message, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) }@ @@ -60,7 +60,7 @@ from rosidl_parser.definition import Service @{ TEMPLATE( '_srv_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=service.structure_type, + package_name=package_name, idl_type=service.namespaced_type, service=service, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) @@ -78,7 +78,7 @@ from rosidl_parser.definition import Action @{ TEMPLATE( '_action_pkg_typesupport_entry_point.c.em', - package_name=package_name, idl_type=action.structure_type, + package_name=package_name, idl_type=action.namespaced_type, action=action, typesupport_impl=typesupport_impl, include_directives=include_directives, register_functions=register_functions) diff --git a/rosidl_generator_py/resource/_msg.py.em b/rosidl_generator_py/resource/_msg.py.em index 3e1ae8a9..91a50b40 100644 --- a/rosidl_generator_py/resource/_msg.py.em +++ b/rosidl_generator_py/resource/_msg.py.em @@ -6,18 +6,18 @@ from rosidl_generator_py.generate_py_impl import constant_value_to_py from rosidl_generator_py.generate_py_impl import get_python_type from rosidl_generator_py.generate_py_impl import SPECIAL_NESTED_BASIC_TYPES from rosidl_generator_py.generate_py_impl import value_to_py +from rosidl_parser.definition import AbstractGenericString +from rosidl_parser.definition import AbstractNestedType +from rosidl_parser.definition import AbstractSequence +from rosidl_parser.definition import AbstractString +from rosidl_parser.definition import AbstractWString from rosidl_parser.definition import ACTION_FEEDBACK_SUFFIX from rosidl_parser.definition import ACTION_GOAL_SUFFIX from rosidl_parser.definition import ACTION_RESULT_SUFFIX from rosidl_parser.definition import Array from rosidl_parser.definition import BasicType -from rosidl_parser.definition import BaseString from rosidl_parser.definition import BoundedSequence from rosidl_parser.definition import NamespacedType -from rosidl_parser.definition import NestedType -from rosidl_parser.definition import Sequence -from rosidl_parser.definition import String -from rosidl_parser.definition import WString }@ @#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< @# Collect necessary import statements for all members @@ -27,14 +27,14 @@ import numpy imports = OrderedDict() for member in message.structure.members: if ( - isinstance(member.type, NestedType) and - isinstance(member.type.basetype, BasicType) and - member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES + isinstance(member.type, AbstractNestedType) and + isinstance(member.type.value_type, BasicType) and + member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES ): if isinstance(member.type, Array): member_names = imports.setdefault( 'import numpy', []) - elif isinstance(member.type, Sequence): + elif isinstance(member.type, AbstractSequence): member_names = imports.setdefault( 'import array', []) else: @@ -67,8 +67,8 @@ for member in message.structure.members: @#>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -class Metaclass_@(message.structure.type.name)(type): - """Metaclass of message '@(message.structure.type.name)'.""" +class Metaclass_@(message.structure.namespaced_type.name)(type): + """Metaclass of message '@(message.structure.namespaced_type.name)'.""" _CREATE_ROS_MESSAGE = None _CONVERT_FROM_PY = None @@ -77,7 +77,7 @@ class Metaclass_@(message.structure.type.name)(type): _TYPE_SUPPORT = None __constants = { -@[for constant in message.constants.values()]@ +@[for constant in message.constants]@ '@(constant.name)': @constant_value_to_py(constant.type, constant.value), @[end for]@ } @@ -91,13 +91,13 @@ class Metaclass_@(message.structure.type.name)(type): import logging import traceback logger = logging.getLogger( - '@('.'.join(message.structure.type.namespaces + [message.structure.type.name]))') + '@('.'.join(message.structure.namespaced_type.namespaces + [message.structure.namespaced_type.name]))') logger.debug( 'Failed to import needed modules for type support:\n' + traceback.format_exc()) else: @{ -suffix = '__'.join(message.structure.type.namespaces[1:]) + '__' + convert_camel_case_to_lower_case_underscore(message.structure.type.name) +suffix = '__'.join(message.structure.namespaced_type.namespaces[1:]) + '__' + convert_camel_case_to_lower_case_underscore(message.structure.namespaced_type.name) }@ cls._CREATE_ROS_MESSAGE = module.create_ros_message_msg__@(suffix) cls._CONVERT_FROM_PY = module.convert_from_py_msg__@(suffix) @@ -108,8 +108,8 @@ suffix = '__'.join(message.structure.type.namespaces[1:]) + '__' + convert_camel importable_typesupports = set() for member in message.structure.members: type_ = member.type - if isinstance(type_, NestedType): - type_ = type_.basetype + if isinstance(type_, AbstractNestedType): + type_ = type_.value_type if isinstance(type_, NamespacedType): if ( type_.name.endswith(ACTION_GOAL_SUFFIX) or @@ -135,7 +135,7 @@ for member in message.structure.members: # the message class under "Data and other attributes defined here:" # as well as populate each message instance return { -@[for constant in message.constants.values()]@ +@[for constant in message.constants]@ '@(constant.name)': cls.__constants['@(constant.name)'], @[end for]@ @[for member in message.structure.members]@ @@ -144,12 +144,12 @@ for member in message.structure.members: @[ end if]@ @[end for]@ } -@[for constant in message.constants.values()]@ +@[for constant in message.constants]@ @@property def @(constant.name)(self): """Message constant '@(constant.name)'.""" - return Metaclass_@(message.structure.type.name).__constants['@(constant.name)'] + return Metaclass_@(message.structure.namespaced_type.name).__constants['@(constant.name)'] @[end for]@ @[for member in message.structure.members]@ @[ if member.has_annotation('default')]@ @@ -162,15 +162,15 @@ for member in message.structure.members: @[end for]@ -class @(message.structure.type.name)(metaclass=Metaclass_@(message.structure.type.name)): +class @(message.structure.namespaced_type.name)(metaclass=Metaclass_@(message.structure.namespaced_type.name)): @[if not message.constants]@ - """Message class '@(message.structure.type.name)'.""" + """Message class '@(message.structure.namespaced_type.name)'.""" @[else]@ """ - Message class '@(message.structure.type.name)'. + Message class '@(message.structure.namespaced_type.name)'. Constants: -@[ for constant_name in message.constants.keys()]@ +@[ for constant_name in [c.name for c in message.constants]]@ @(constant_name) @[ end for]@ """ @@ -186,33 +186,33 @@ class @(message.structure.type.name)(metaclass=Metaclass_@(message.structure.typ @[for member in message.structure.members]@ @{ type_ = member.type -if isinstance(type_, NestedType): - type_ = type_.basetype +if isinstance(type_, AbstractNestedType): + type_ = type_.value_type }@ '@(member.name)': '@ @# the prefix for nested types -@[ if isinstance(member.type, Sequence)]@ +@[ if isinstance(member.type, AbstractSequence)]@ sequence<@ @[ end if]@ @# the typename of the non-nested type or the nested basetype @[ if isinstance(type_, BasicType)]@ -@(type_.type)@ -@[ elif isinstance(type_, BaseString)]@ +@(type_.typename)@ +@[ elif isinstance(type_, AbstractGenericString)]@ @ -@[ if isinstance(type_, WString)]@ +@[ if isinstance(type_, AbstractWString)]@ w@ @[ end if]@ string@ -@[ if type_.maximum_size is not None]@ +@[ if type_.has_maximum_size()]@ <@(type_.maximum_size)>@ @[ end if]@ @[ elif isinstance(type_, NamespacedType)]@ @('/'.join([type_.namespaces[0], type_.name]))@ @[ end if]@ @# the suffix for nested types -@[ if isinstance(member.type, Sequence)]@ +@[ if isinstance(member.type, AbstractSequence)]@ @[ if isinstance(member.type, BoundedSequence)]@ -, @(member.type.upper_bound)@ +, @(member.type.maximum_size)@ @[ end if]@ >@ @[ elif isinstance(member.type, Array)]@ @@ -229,14 +229,14 @@ string@ @[for member in message.structure.members]@ @{ type_ = member.type -if isinstance(type_, NestedType): - type_ = type_.basetype +if isinstance(type_, AbstractNestedType): + type_ = type_.value_type }@ @[ if member.has_annotation('default')]@ self.@(member.name) = kwargs.get( - '@(member.name)', @(message.structure.type.name).@(member.name.upper())__DEFAULT) + '@(member.name)', @(message.structure.namespaced_type.name).@(member.name.upper())__DEFAULT) @[ else]@ -@[ if isinstance(type_, NamespacedType) and not isinstance(member.type, Sequence)]@ +@[ if isinstance(type_, NamespacedType) and not isinstance(member.type, AbstractSequence)]@ @[ if ( type_.name.endswith(ACTION_GOAL_SUFFIX) or type_.name.endswith(ACTION_RESULT_SUFFIX) or @@ -248,22 +248,22 @@ if isinstance(type_, NestedType): @[ end if]@ @[ end if]@ @[ if isinstance(member.type, Array)]@ -@[ if isinstance(type_, BasicType) and type_.type == 'octet']@ +@[ if isinstance(type_, BasicType) and type_.typename == 'octet']@ self.@(member.name) = kwargs.get( '@(member.name)', [bytes([0]) for x in range(@(member.type.size))] ) -@[ elif isinstance(type_, BasicType) and type_.type in ('char', 'wchar')]@ +@[ elif isinstance(type_, BasicType) and type_.typename in ('char', 'wchar')]@ self.@(member.name) = kwargs.get( '@(member.name)', [chr(0) for x in range(@(member.type.size))] ) @[ else]@ -@[ if isinstance(member.type.basetype, BasicType) and member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES]@ +@[ if isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES]@ if '@(member.name)' not in kwargs: - self.@(member.name) = numpy.zeros(@(member.type.size), dtype=@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'])) + self.@(member.name) = numpy.zeros(@(member.type.size), dtype=@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'])) else: - self.@(member.name) = numpy.array(kwargs.get('@(member.name)'), dtype=@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'])) + self.@(member.name) = numpy.array(kwargs.get('@(member.name)'), dtype=@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'])) assert self.@(member.name).shape == (@(member.type.size), ) @[ else]@ self.@(member.name) = kwargs.get( @@ -272,15 +272,15 @@ if isinstance(type_, NestedType): ) @[ end if]@ @[ end if]@ -@[ elif isinstance(member.type, Sequence)]@ -@[ if isinstance(member.type.basetype, BasicType) and member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES]@ - self.@(member.name) = array.array('@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['type_code'])', kwargs.get('@(member.name)', [])) +@[ elif isinstance(member.type, AbstractSequence)]@ +@[ if isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES]@ + self.@(member.name) = array.array('@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['type_code'])', kwargs.get('@(member.name)', [])) @[ else]@ self.@(member.name) = kwargs.get('@(member.name)', []) @[ end if]@ -@[ elif isinstance(type_, BasicType) and type_.type == 'octet']@ +@[ elif isinstance(type_, BasicType) and type_.typename == 'octet']@ self.@(member.name) = kwargs.get('@(member.name)', bytes([0])) -@[ elif isinstance(type_, BasicType) and type_.type in ('char', 'wchar')]@ +@[ elif isinstance(type_, BasicType) and type_.typename in ('char', 'wchar')]@ self.@(member.name) = kwargs.get('@(member.name)', chr(0)) @[ else]@ self.@(member.name) = kwargs.get('@(member.name)', @(get_python_type(type_))()) @@ -299,7 +299,7 @@ if isinstance(type_, NestedType): if not isinstance(other, self.__class__): return False @[for member in message.structure.members]@ -@[ if isinstance(member.type, Array) and isinstance(member.type.basetype, BasicType) and member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES]@ +@[ if isinstance(member.type, Array) and isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES]@ if all(self.@(member.name) != other.@(member.name)): @[ else]@ if self.@(member.name) != other.@(member.name): @@ -316,8 +316,8 @@ if isinstance(type_, NestedType): @{ type_ = member.type -if isinstance(type_, NestedType): - type_ = type_.basetype +if isinstance(type_, AbstractNestedType): + type_ = type_.value_type import inspect import builtins @@ -332,22 +332,22 @@ if member.name in dict(inspect.getmembers(builtins)).keys(): @@@(member.name).setter@(noqa_string) def @(member.name)(self, value): -@[ if isinstance(member.type, NestedType) and isinstance(member.type.basetype, BasicType) and member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES]@ +@[ if isinstance(member.type, AbstractNestedType) and isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES]@ @[ if isinstance(member.type, Array)]@ if isinstance(value, numpy.ndarray): - assert value.dtype == @(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype']), \ - "The '@(member.name)' numpy.ndarray() must have the dtype of '@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'])'" + assert value.dtype == @(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype']), \ + "The '@(member.name)' numpy.ndarray() must have the dtype of '@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'])'" assert value.size == @(member.type.size), \ "The '@(member.name)' numpy.ndarray() must have a size of @(member.type.size)" self._@(member.name) = value return -@[ elif isinstance(member.type, Sequence)]@ +@[ elif isinstance(member.type, AbstractSequence)]@ if isinstance(value, array.array): - assert value.typecode == '@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['type_code'])', \ - "The '@(member.name)' array.array() must have the type code of '@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['type_code'])'" + assert value.typecode == '@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['type_code'])', \ + "The '@(member.name)' array.array() must have the type code of '@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['type_code'])'" @[ if isinstance(member.type, BoundedSequence)]@ - assert len(value) <= @(member.type.upper_bound), \ - "The '@(member.name)' array.array() must have a size <= @(member.type.upper_bound)" + assert len(value) <= @(member.type.maximum_size), \ + "The '@(member.name)' array.array() must have a size <= @(member.type.maximum_size)" @[ end if]@ self._@(member.name) = value return @@ -365,34 +365,34 @@ if member.name in dict(inspect.getmembers(builtins)).keys(): from @('.'.join(type_.namespaces)) import @(type_.name) @[ end if]@ @[ end if]@ -@[ if isinstance(member.type, NestedType)]@ +@[ if isinstance(member.type, AbstractNestedType)]@ from collections.abc import Sequence from collections.abc import Set from collections import UserList from collections import UserString -@[ elif isinstance(type_, String) and type_.maximum_size is not None]@ +@[ elif isinstance(type_, AbstractString) and type_.has_maximum_size()]@ from collections import UserString -@[ elif isinstance(type_, BasicType) and type_.type == 'octet']@ +@[ elif isinstance(type_, BasicType) and type_.typename == 'octet']@ from collections.abc import ByteString -@[ elif isinstance(type_, BasicType) and type_.type in ('char', 'wchar')]@ +@[ elif isinstance(type_, BasicType) and type_.typename in ('char', 'wchar')]@ from collections import UserString @[ end if]@ assert \ -@[ if isinstance(member.type, NestedType)]@ +@[ if isinstance(member.type, AbstractNestedType)]@ ((isinstance(value, Sequence) or isinstance(value, Set) or isinstance(value, UserList)) and not isinstance(value, str) and not isinstance(value, UserString) and @{assert_msg_suffixes = ['a set or sequence']}@ -@[ if isinstance(type_, String) and type_.maximum_size is not None]@ +@[ if isinstance(type_, AbstractString) and type_.has_maximum_size()]@ all(len(val) <= @(type_.maximum_size) for val in value) and @{assert_msg_suffixes.append('and each string value not longer than %d' % type_.maximum_size)}@ @[ end if]@ @[ if isinstance(member.type, Array) or isinstance(member.type, BoundedSequence)]@ @[ if isinstance(member.type, BoundedSequence)]@ - len(value) <= @(member.type.upper_bound) and -@{assert_msg_suffixes.insert(1, 'with length <= %d' % member.type.upper_bound)}@ + len(value) <= @(member.type.maximum_size) and +@{assert_msg_suffixes.insert(1, 'with length <= %d' % member.type.maximum_size)}@ @[ else]@ len(value) == @(member.type.size) and @{assert_msg_suffixes.insert(1, 'with length %d' % member.type.size)}@ @@ -400,28 +400,28 @@ if member.name in dict(inspect.getmembers(builtins)).keys(): @[ end if]@ all(isinstance(v, @(get_python_type(type_))) for v in value) and @{assert_msg_suffixes.append("and each value of type '%s'" % get_python_type(type_))}@ -@[ if isinstance(type_, BasicType) and type_.type.startswith('int')]@ +@[ if isinstance(type_, BasicType) and type_.typename.startswith('int')]@ @{ -nbits = int(type_.type[3:]) +nbits = int(type_.typename[3:]) bound = 2**(nbits - 1) }@ all(val >= -@(bound) and val < @(bound) for val in value)), \ @{assert_msg_suffixes.append('and each integer in [%d, %d]' % (-bound, bound - 1))}@ -@[ elif isinstance(type_, BasicType) and type_.type.startswith('uint')]@ +@[ elif isinstance(type_, BasicType) and type_.typename.startswith('uint')]@ @{ -nbits = int(type_.type[4:]) +nbits = int(type_.typename[4:]) bound = 2**nbits }@ all(val >= 0 and val < @(bound) for val in value)), \ @{assert_msg_suffixes.append('and each unsigned integer in [0, %d]' % (bound - 1))}@ -@[ elif isinstance(type_, BasicType) and type_.type == 'char']@ +@[ elif isinstance(type_, BasicType) and type_.typename == 'char']@ all(val >= 0 and val) < 256 for val in value)), \ @{assert_msg_suffixes.append('and each char in [0, 255]')}@ @[ else]@ True), \ @[ end if]@ "The '@(member.name)' field must be @(' '.join(assert_msg_suffixes))" -@[ elif isinstance(member.type, BaseString) and member.type.maximum_size is not None]@ +@[ elif isinstance(member.type, AbstractGenericString) and member.type.has_maximum_size()]@ ((isinstance(value, str) or isinstance(value, UserString)) and len(value) <= @(member.type.maximum_size)), \ "The '@(member.name)' field must be string value " \ @@ -429,19 +429,19 @@ bound = 2**nbits @[ elif isinstance(type_, NamespacedType)]@ isinstance(value, @(type_.name)), \ "The '@(member.name)' field must be a sub message of type '@(type_.name)'" -@[ elif isinstance(type_, BasicType) and type_.type == 'octet']@ +@[ elif isinstance(type_, BasicType) and type_.typename == 'octet']@ ((isinstance(value, bytes) or isinstance(value, ByteString)) and len(value) == 1), \ "The '@(member.name)' field must be of type 'bytes' or 'ByteString' with length 1" -@[ elif isinstance(type_, BasicType) and type_.type == 'char']@ +@[ elif isinstance(type_, BasicType) and type_.typename == 'char']@ ((isinstance(value, str) or isinstance(value, UserString)) and len(value) == 1 and ord(value) >= -128 and ord(value) < 128), \ "The '@(member.name)' field must be of type 'str' or 'UserString' " \ 'with length 1 and the character ord() in [-128, 127]' -@[ elif isinstance(type_, BaseString)]@ +@[ elif isinstance(type_, AbstractGenericString)]@ isinstance(value, str), \ "The '@(member.name)' field must be of type '@(get_python_type(type_))'" -@[ elif isinstance(type_, BasicType) and type_.type in [ +@[ elif isinstance(type_, BasicType) and type_.typename in [ 'boolean', 'float', 'double', 'int8', 'uint8', @@ -451,16 +451,16 @@ bound = 2**nbits ]]@ isinstance(value, @(get_python_type(type_))), \ "The '@(member.name)' field must be of type '@(get_python_type(type_))'" -@[ if type_.type.startswith('int')]@ +@[ if type_.typename.startswith('int')]@ @{ -nbits = int(type_.type[3:]) +nbits = int(type_.typename[3:]) bound = 2**(nbits - 1) }@ assert value >= -@(bound) and value < @(bound), \ "The '@(member.name)' field must be an integer in [@(-bound), @(bound - 1)]" -@[ elif type_.type.startswith('uint')]@ +@[ elif type_.typename.startswith('uint')]@ @{ -nbits = int(type_.type[4:]) +nbits = int(type_.typename[4:]) bound = 2**nbits }@ assert value >= 0 and value < @(bound), \ @@ -469,11 +469,11 @@ bound = 2**nbits @[ else]@ False @[ end if]@ -@[ if isinstance(member.type, NestedType) and isinstance(member.type.basetype, BasicType) and member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES]@ +@[ if isinstance(member.type, AbstractNestedType) and isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES]@ @[ if isinstance(member.type, Array)]@ - self._@(member.name) = numpy.array(value, dtype=@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'])) -@[ elif isinstance(member.type, Sequence)]@ - self._@(member.name) = array.array('@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['type_code'])', value) + self._@(member.name) = numpy.array(value, dtype=@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'])) +@[ elif isinstance(member.type, AbstractSequence)]@ + self._@(member.name) = array.array('@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['type_code'])', value) @[ end if]@ @[ else]@ self._@(member.name) = value diff --git a/rosidl_generator_py/resource/_msg_pkg_typesupport_entry_point.c.em b/rosidl_generator_py/resource/_msg_pkg_typesupport_entry_point.c.em index d9cda9ca..c8cb2559 100644 --- a/rosidl_generator_py/resource/_msg_pkg_typesupport_entry_point.c.em +++ b/rosidl_generator_py/resource/_msg_pkg_typesupport_entry_point.c.em @@ -33,33 +33,33 @@ header_files = [ @[end for]@ @ @{ -module_name = convert_camel_case_to_lower_case_underscore(message.structure.type.name) -msg_typename = '__'.join(message.structure.type.namespaces + [message.structure.type.name]) +module_name = convert_camel_case_to_lower_case_underscore(message.structure.namespaced_type.name) +msg_typename = '__'.join(message.structure.namespaced_type.namespaces + [message.structure.namespaced_type.name]) }@ -static void * @('__'.join(message.structure.type.namespaces + [module_name]))__create_ros_message(void) +static void * @('__'.join(message.structure.namespaced_type.namespaces + [module_name]))__create_ros_message(void) { return @(msg_typename)__create(); } -static void @('__'.join(message.structure.type.namespaces + [module_name]))__destroy_ros_message(void * raw_ros_message) +static void @('__'.join(message.structure.namespaced_type.namespaces + [module_name]))__destroy_ros_message(void * raw_ros_message) { @(msg_typename) * ros_message = (@(msg_typename) *)raw_ros_message; @(msg_typename)__destroy(ros_message); } ROSIDL_GENERATOR_C_IMPORT -bool @('__'.join(message.structure.type.namespaces + [module_name]))__convert_from_py(PyObject * _pymsg, void * ros_message); +bool @('__'.join(message.structure.namespaced_type.namespaces + [module_name]))__convert_from_py(PyObject * _pymsg, void * ros_message); ROSIDL_GENERATOR_C_IMPORT -PyObject * @('__'.join(message.structure.type.namespaces + [module_name]))__convert_to_py(void * raw_ros_message); +PyObject * @('__'.join(message.structure.namespaced_type.namespaces + [module_name]))__convert_to_py(void * raw_ros_message); ROSIDL_GENERATOR_C_IMPORT const rosidl_message_type_support_t * -ROSIDL_GET_MSG_TYPE_SUPPORT(@(', '.join(message.structure.type.namespaces + [message.structure.type.name]))); +ROSIDL_GET_MSG_TYPE_SUPPORT(@(', '.join(message.structure.namespaced_type.namespaces + [message.structure.namespaced_type.name]))); @{ -register_function = '_register_msg_type__' + '__'.join(message.structure.type.namespaces[1:] + [module_name]) +register_function = '_register_msg_type__' + '__'.join(message.structure.namespaced_type.namespaces[1:] + [module_name]) register_functions.append(register_function) }@ int8_t @@ -74,9 +74,9 @@ function_names = ['create_ros_message', 'destroy_ros_message', 'convert_from_py' PyObject * pyobject_@(function_name) = NULL; pyobject_@(function_name) = PyCapsule_New( @[ if function_name != 'type_support']@ - (void *)&@('__'.join(message.structure.type.namespaces + [module_name]))__@(function_name), + (void *)&@('__'.join(message.structure.namespaced_type.namespaces + [module_name]))__@(function_name), @[ else]@ - (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(@(', '.join(message.structure.type.namespaces + [message.structure.type.name]))), + (void *)ROSIDL_GET_MSG_TYPE_SUPPORT(@(', '.join(message.structure.namespaced_type.namespaces + [message.structure.namespaced_type.name]))), @[ end if]@ NULL, NULL); if (!pyobject_@(function_name)) { @@ -85,7 +85,7 @@ function_names = ['create_ros_message', 'destroy_ros_message', 'convert_from_py' } err = PyModule_AddObject( pymodule, - "@(function_name)_msg__@('__'.join(message.structure.type.namespaces[1:] + [module_name]))", + "@(function_name)_msg__@('__'.join(message.structure.namespaced_type.namespaces[1:] + [module_name]))", pyobject_@(function_name)); if (err) { // the created capsule needs to be decremented diff --git a/rosidl_generator_py/resource/_msg_support.c.em b/rosidl_generator_py/resource/_msg_support.c.em index 60248304..d2883a97 100644 --- a/rosidl_generator_py/resource/_msg_support.c.em +++ b/rosidl_generator_py/resource/_msg_support.c.em @@ -3,23 +3,23 @@ @{ from rosidl_cmake import convert_camel_case_to_lower_case_underscore from rosidl_generator_py.generate_py_impl import SPECIAL_NESTED_BASIC_TYPES +from rosidl_parser.definition import AbstractNestedType +from rosidl_parser.definition import AbstractSequence +from rosidl_parser.definition import AbstractString +from rosidl_parser.definition import AbstractWString from rosidl_parser.definition import Array from rosidl_parser.definition import BasicType from rosidl_parser.definition import NamespacedType -from rosidl_parser.definition import NestedType -from rosidl_parser.definition import Sequence -from rosidl_parser.definition import String -from rosidl_parser.definition import WString def primitive_msg_type_to_c(type_): from rosidl_generator_c import BASIC_IDL_TYPES_TO_C + from rosidl_parser.definition import AbstractString from rosidl_parser.definition import BasicType - from rosidl_parser.definition import String - if isinstance(type_, String): + if isinstance(type_, AbstractString): return 'rosidl_generator_c__String' assert isinstance(type_, BasicType) - return BASIC_IDL_TYPES_TO_C[type_.type] + return BASIC_IDL_TYPES_TO_C[type_.typename] include_parts = [package_name] + list(interface_path.parents[0].parts) + \ @@ -72,20 +72,20 @@ nested_types = set() @[for member in message.structure.members]@ @{ type_ = member.type -if isinstance(type_, NestedType): - type_ = type_.basetype +if isinstance(type_, AbstractNestedType): + type_ = type_.value_type header_files = [] -if isinstance(member.type, NestedType) and have_not_included_primitive_arrays: +if isinstance(member.type, AbstractNestedType) and have_not_included_primitive_arrays: have_not_included_primitive_arrays = False header_files += [ 'rosidl_generator_c/primitives_sequence.h', 'rosidl_generator_c/primitives_sequence_functions.h'] -if isinstance(type_, String) and have_not_included_string: +if isinstance(type_, AbstractString) and have_not_included_string: have_not_included_string = False header_files += [ 'rosidl_generator_c/string.h', 'rosidl_generator_c/string_functions.h'] -if isinstance(type_, WString) and have_not_included_wstring: +if isinstance(type_, AbstractWString) and have_not_included_wstring: have_not_included_wstring = False header_files += [ 'rosidl_generator_c/u16string.h', @@ -104,8 +104,8 @@ if isinstance(type_, WString) and have_not_included_wstring: @[end if]@ @{ -if isinstance(member.type, NestedType) and isinstance(member.type.basetype, NamespacedType): - nested_types.add((*member.type.basetype.namespaces, member.type.basetype.name)) +if isinstance(member.type, AbstractNestedType) and isinstance(member.type.value_type, NamespacedType): + nested_types.add((*member.type.value_type.namespaces, member.type.value_type.name)) }@ @[end for]@ @[if nested_types]@ @@ -116,14 +116,14 @@ if isinstance(member.type, NestedType) and isinstance(member.type.basetype, Name // end nested array functions include @[end if]@ @{ -msg_typename = '__'.join(message.structure.type.namespaces + [message.structure.type.name]) +msg_typename = '__'.join(message.structure.namespaced_type.namespaces + [message.structure.namespaced_type.name]) }@ @ @[for member in message.structure.members]@ @{ type_ = member.type -if isinstance(type_, NestedType): - type_ = type_.basetype +if isinstance(type_, AbstractNestedType): + type_ = type_.value_type }@ @[ if isinstance(type_, NamespacedType)]@ @[ if type_.namespaces[0] != package_name]@ @@ -141,10 +141,10 @@ PyObject * @('__'.join(type_.namespaces + [convert_camel_case_to_lower_case_unde module_name = '_' + convert_camel_case_to_lower_case_underscore(interface_path.stem) }@ ROSIDL_GENERATOR_C_EXPORT -bool @('__'.join(message.structure.type.namespaces + [convert_camel_case_to_lower_case_underscore(message.structure.type.name)]))__convert_from_py(PyObject * _pymsg, void * _ros_message) +bool @('__'.join(message.structure.namespaced_type.namespaces + [convert_camel_case_to_lower_case_underscore(message.structure.namespaced_type.name)]))__convert_from_py(PyObject * _pymsg, void * _ros_message) { @{ -full_classname = '%s.%s.%s' % ('.'.join(message.structure.type.namespaces), module_name, message.structure.type.name) +full_classname = '%s.%s.%s' % ('.'.join(message.structure.namespaced_type.namespaces), module_name, message.structure.namespaced_type.name) }@ // check that the passed message is of the expected Python class { @@ -181,8 +181,8 @@ full_classname = '%s.%s.%s' % ('.'.join(message.structure.type.namespaces), modu @[for member in message.structure.members]@ @{ type_ = member.type -if isinstance(type_, NestedType): - type_ = type_.basetype +if isinstance(type_, AbstractNestedType): + type_ = type_.value_type }@ { // @(member.name) PyObject * field = PyObject_GetAttrString(_pymsg, "@(member.name)"); @@ -193,13 +193,13 @@ if isinstance(type_, NestedType): @{ nested_type = '__'.join(type_.namespaces + [type_.name]) }@ -@[ if isinstance(member.type, NestedType)]@ +@[ if isinstance(member.type, AbstractNestedType)]@ PyObject * seq_field = PySequence_Fast(field, "expected a sequence in '@(member.name)'"); if (!seq_field) { Py_DECREF(field); return false; } -@[ if isinstance(member.type, Sequence)]@ +@[ if isinstance(member.type, AbstractSequence)]@ Py_ssize_t size = PySequence_Size(field); if (-1 == size) { Py_DECREF(seq_field); @@ -231,8 +231,8 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) return false; } @[ end if]@ -@[ elif isinstance(member.type, NestedType)]@ -@[ if isinstance(member.type, Array) and isinstance(member.type.basetype, BasicType) and member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES]@ +@[ elif isinstance(member.type, AbstractNestedType)]@ +@[ if isinstance(member.type, Array) and isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES]@ // TODO(dirk-thomas) use a better way to check the type before casting assert(field->ob_type != NULL); assert(field->ob_type->tp_name != NULL); @@ -240,7 +240,7 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) PyArrayObject * seq_field = (PyArrayObject *)field; Py_INCREF(seq_field); assert(PyArray_NDIM(seq_field) == 1); - assert(PyArray_TYPE(seq_field) == @(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'].replace('numpy.', 'NPY_').upper())); + assert(PyArray_TYPE(seq_field) == @(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'].replace('numpy.', 'NPY_').upper())); @[ else]@ PyObject * seq_field = PySequence_Fast(field, "expected a sequence in '@(member.name)'"); if (!seq_field) { @@ -248,14 +248,14 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) return false; } @[ end if]@ -@[ if isinstance(member.type, Sequence)]@ +@[ if isinstance(member.type, AbstractSequence)]@ Py_ssize_t size = PySequence_Size(field); if (-1 == size) { Py_DECREF(seq_field); Py_DECREF(field); return false; } -@[ if isinstance(member.type.basetype, String)]@ +@[ if isinstance(member.type.value_type, AbstractString)]@ if (!rosidl_generator_c__String__Sequence__init(&(ros_message->@(member.name)), size)) { PyErr_SetString(PyExc_RuntimeError, "unable to create String__Sequence ros_message"); Py_DECREF(seq_field); @@ -263,20 +263,20 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) return false; } @[ else]@ - if (!rosidl_generator_c__@(member.type.basetype.type)__Sequence__init(&(ros_message->@(member.name)), size)) { - PyErr_SetString(PyExc_RuntimeError, "unable to create @(member.type.basetype.type)__Sequence ros_message"); + if (!rosidl_generator_c__@(member.type.value_type.typename)__Sequence__init(&(ros_message->@(member.name)), size)) { + PyErr_SetString(PyExc_RuntimeError, "unable to create @(member.type.value_type.typename)__Sequence ros_message"); Py_DECREF(seq_field); Py_DECREF(field); return false; } @[ end if]@ - @primitive_msg_type_to_c(member.type.basetype) * dest = ros_message->@(member.name).data; + @primitive_msg_type_to_c(member.type.value_type) * dest = ros_message->@(member.name).data; @[ else]@ Py_ssize_t size = @(member.type.size); - @primitive_msg_type_to_c(member.type.basetype) * dest = ros_message->@(member.name); + @primitive_msg_type_to_c(member.type.value_type) * dest = ros_message->@(member.name); @[ end if]@ for (Py_ssize_t i = 0; i < size; ++i) { -@[ if not isinstance(member.type, Array) or not isinstance(member.type.basetype, BasicType) or member.type.basetype.type not in SPECIAL_NESTED_BASIC_TYPES]@ +@[ if not isinstance(member.type, Array) or not isinstance(member.type.value_type, BasicType) or member.type.value_type.typename not in SPECIAL_NESTED_BASIC_TYPES]@ PyObject * item = PySequence_Fast_GET_ITEM(seq_field, i); if (!item) { Py_DECREF(seq_field); @@ -284,9 +284,9 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) return false; } @[ end if]@ -@[ if isinstance(member.type, Array) and isinstance(member.type.basetype, BasicType) and member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES]@ - @primitive_msg_type_to_c(member.type.basetype) tmp = *(@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'].replace('numpy.', 'npy_')) *)PyArray_GETPTR1(seq_field, i); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'char']@ +@[ if isinstance(member.type, Array) and isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES]@ + @primitive_msg_type_to_c(member.type.value_type) tmp = *(@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'].replace('numpy.', 'npy_')) *)PyArray_GETPTR1(seq_field, i); +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'char']@ assert(PyUnicode_Check(item)); PyObject * encoded_item = PyUnicode_AsASCIIString(item); if (!encoded_item) { @@ -294,12 +294,12 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) Py_DECREF(field); return false; } - @primitive_msg_type_to_c(member.type.basetype) tmp = PyBytes_AS_STRING(encoded_item)[0]; + @primitive_msg_type_to_c(member.type.value_type) tmp = PyBytes_AS_STRING(encoded_item)[0]; Py_DECREF(encoded_item); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'octet']@ +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'octet']@ assert(PyBytes_Check(item)); - @primitive_msg_type_to_c(member.type.basetype) tmp = PyBytes_AS_STRING(item)[0]; -@[ elif isinstance(member.type.basetype, String)]@ + @primitive_msg_type_to_c(member.type.value_type) tmp = PyBytes_AS_STRING(item)[0]; +@[ elif isinstance(member.type.value_type, AbstractString)]@ assert(PyUnicode_Check(item)); PyObject * encoded_item = PyUnicode_AsASCIIString(item); if (!encoded_item) { @@ -309,47 +309,47 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) } rosidl_generator_c__String__assign(&dest[i], PyBytes_AS_STRING(encoded_item)); Py_DECREF(encoded_item); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'boolean']@ +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'boolean']@ assert(PyBool_Check(item)); - @primitive_msg_type_to_c(member.type.basetype) tmp = (item == Py_True); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type in ('float', 'double')]@ + @primitive_msg_type_to_c(member.type.value_type) tmp = (item == Py_True); +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in ('float', 'double')]@ assert(PyFloat_Check(item)); -@[ if member.type.basetype.type == 'float']@ - @primitive_msg_type_to_c(member.type.basetype) tmp = (float)PyFloat_AS_DOUBLE(item); +@[ if member.type.value_type.typename == 'float']@ + @primitive_msg_type_to_c(member.type.value_type) tmp = (float)PyFloat_AS_DOUBLE(item); @[ else]@ - @primitive_msg_type_to_c(member.type.basetype) tmp = PyFloat_AS_DOUBLE(item); + @primitive_msg_type_to_c(member.type.value_type) tmp = PyFloat_AS_DOUBLE(item); @[ end if]@ -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type in ( +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in ( 'int8', 'int16', 'int32', )]@ assert(PyLong_Check(item)); - @primitive_msg_type_to_c(member.type.basetype) tmp = (@(primitive_msg_type_to_c(member.type.basetype)))PyLong_AsLong(item); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type in ( + @primitive_msg_type_to_c(member.type.value_type) tmp = (@(primitive_msg_type_to_c(member.type.value_type)))PyLong_AsLong(item); +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in ( 'uint8', 'uint16', 'uint32', )]@ assert(PyLong_Check(item)); -@[ if isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'uint32']@ - @primitive_msg_type_to_c(member.type.basetype) tmp = PyLong_AsUnsignedLong(item); +@[ if isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'uint32']@ + @primitive_msg_type_to_c(member.type.value_type) tmp = PyLong_AsUnsignedLong(item); @[ else]@ - @primitive_msg_type_to_c(member.type.basetype) tmp = (@(primitive_msg_type_to_c(member.type.basetype)))PyLong_AsUnsignedLong(item); + @primitive_msg_type_to_c(member.type.value_type) tmp = (@(primitive_msg_type_to_c(member.type.value_type)))PyLong_AsUnsignedLong(item); @[ end if] -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'int64']@ +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'int64']@ assert(PyLong_Check(item)); - @primitive_msg_type_to_c(member.type.basetype) tmp = PyLong_AsLongLong(item); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'uint64']@ + @primitive_msg_type_to_c(member.type.value_type) tmp = PyLong_AsLongLong(item); +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'uint64']@ assert(PyLong_Check(item)); - @primitive_msg_type_to_c(member.type.basetype) tmp = PyLong_AsUnsignedLongLong(item); + @primitive_msg_type_to_c(member.type.value_type) tmp = PyLong_AsUnsignedLongLong(item); @[ end if]@ -@[ if isinstance(member.type.basetype, BasicType)]@ - memcpy(&dest[i], &tmp, sizeof(@primitive_msg_type_to_c(member.type.basetype))); +@[ if isinstance(member.type.value_type, BasicType)]@ + memcpy(&dest[i], &tmp, sizeof(@primitive_msg_type_to_c(member.type.value_type))); @[ end if]@ } Py_DECREF(seq_field); -@[ elif isinstance(member.type, BasicType) and member.type.type == 'char']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'char']@ assert(PyUnicode_Check(field)); PyObject * encoded_field = PyUnicode_AsASCIIString(field); if (!encoded_field) { @@ -358,10 +358,10 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) } ros_message->@(member.name) = PyBytes_AS_STRING(encoded_field)[0]; Py_DECREF(encoded_field); -@[ elif isinstance(member.type, BasicType) and member.type.type == 'octet']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'octet']@ assert(PyBytes_Check(field)); ros_message->@(member.name) = PyBytes_AS_STRING(field)[0]; -@[ elif isinstance(member.type, String)]@ +@[ elif isinstance(member.type, AbstractString)]@ assert(PyUnicode_Check(field)); PyObject * encoded_field = PyUnicode_AsASCIIString(field); if (!encoded_field) { @@ -370,38 +370,38 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) } rosidl_generator_c__String__assign(&ros_message->@(member.name), PyBytes_AS_STRING(encoded_field)); Py_DECREF(encoded_field); -@[ elif isinstance(member.type, BasicType) and member.type.type == 'boolean']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'boolean']@ assert(PyBool_Check(field)); ros_message->@(member.name) = (Py_True == field); -@[ elif isinstance(member.type, BasicType) and member.type.type in ('float', 'double')]@ +@[ elif isinstance(member.type, BasicType) and member.type.typename in ('float', 'double')]@ assert(PyFloat_Check(field)); -@[ if member.type.type == 'float']@ +@[ if member.type.typename == 'float']@ ros_message->@(member.name) = (float)PyFloat_AS_DOUBLE(field); @[ else]@ ros_message->@(member.name) = PyFloat_AS_DOUBLE(field); @[ end if]@ -@[ elif isinstance(member.type, BasicType) and member.type.type in ( +@[ elif isinstance(member.type, BasicType) and member.type.typename in ( 'int8', 'int16', 'int32', )]@ assert(PyLong_Check(field)); ros_message->@(member.name) = (@(primitive_msg_type_to_c(member.type)))PyLong_AsLong(field); -@[ elif isinstance(member.type, BasicType) and member.type.type in ( +@[ elif isinstance(member.type, BasicType) and member.type.typename in ( 'uint8', 'uint16', 'uint32', )]@ assert(PyLong_Check(field)); -@[ if member.type.type == 'uint32']@ +@[ if member.type.typename == 'uint32']@ ros_message->@(member.name) = PyLong_AsUnsignedLong(field); @[ else]@ ros_message->@(member.name) = (@(primitive_msg_type_to_c(member.type)))PyLong_AsUnsignedLong(field); @[ end if]@ -@[ elif isinstance(member.type, BasicType) and member.type.type == 'int64']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'int64']@ assert(PyLong_Check(field)); ros_message->@(member.name) = PyLong_AsLongLong(field); -@[ elif isinstance(member.type, BasicType) and member.type.type == 'uint64']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'uint64']@ assert(PyLong_Check(field)); ros_message->@(member.name) = PyLong_AsUnsignedLongLong(field); @[ else]@ @@ -415,14 +415,14 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) } ROSIDL_GENERATOR_C_EXPORT -PyObject * @('__'.join(message.structure.type.namespaces + [convert_camel_case_to_lower_case_underscore(message.structure.type.name)]))__convert_to_py(void * raw_ros_message) +PyObject * @('__'.join(message.structure.namespaced_type.namespaces + [convert_camel_case_to_lower_case_underscore(message.structure.namespaced_type.name)]))__convert_to_py(void * raw_ros_message) { - /* NOTE(esteve): Call constructor of @(message.structure.type.name) */ + /* NOTE(esteve): Call constructor of @(message.structure.namespaced_type.name) */ PyObject * _pymessage = NULL; { - PyObject * pymessage_module = PyImport_ImportModule("@('.'.join(message.structure.type.namespaces)).@(module_name)"); + PyObject * pymessage_module = PyImport_ImportModule("@('.'.join(message.structure.namespaced_type.namespaces)).@(module_name)"); assert(pymessage_module); - PyObject * pymessage_class = PyObject_GetAttrString(pymessage_module, "@(message.structure.type.name)"); + PyObject * pymessage_class = PyObject_GetAttrString(pymessage_module, "@(message.structure.namespaced_type.name)"); assert(pymessage_class); Py_DECREF(pymessage_module); _pymessage = PyObject_CallObject(pymessage_class, NULL); @@ -435,12 +435,12 @@ PyObject * @('__'.join(message.structure.type.namespaces + [convert_camel_case_t @[for member in message.structure.members]@ @{ type_ = member.type -if isinstance(type_, NestedType): - type_ = type_.basetype +if isinstance(type_, AbstractNestedType): + type_ = type_.value_type }@ { // @(member.name) PyObject * field = NULL; -@[ if isinstance(member.type, NestedType) and isinstance(member.type.basetype, BasicType) and member.type.basetype.type in SPECIAL_NESTED_BASIC_TYPES]@ +@[ if isinstance(member.type, AbstractNestedType) and isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in SPECIAL_NESTED_BASIC_TYPES]@ @[ if isinstance(member.type, Array)]@ field = PyObject_GetAttrString(_pymessage, "@(member.name)"); if (!field) { @@ -451,13 +451,13 @@ if isinstance(type_, NestedType): assert(strcmp(field->ob_type->tp_name, "numpy.ndarray") == 0); PyArrayObject * seq_field = (PyArrayObject *)field; assert(PyArray_NDIM(seq_field) == 1); - assert(PyArray_TYPE(seq_field) == @(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'].replace('numpy.', 'NPY_').upper())); - assert(sizeof(@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'].replace('numpy.', 'npy_'))) == sizeof(@primitive_msg_type_to_c(member.type.basetype))); - @(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'].replace('numpy.', 'npy_')) * dst = (@(SPECIAL_NESTED_BASIC_TYPES[member.type.basetype.type]['dtype'].replace('numpy.', 'npy_')) *)PyArray_GETPTR1(seq_field, 0); - @primitive_msg_type_to_c(member.type.basetype) * src = &(ros_message->@(member.name)[0]); - memcpy(dst, src, @(member.type.size) * sizeof(@primitive_msg_type_to_c(member.type.basetype))); + assert(PyArray_TYPE(seq_field) == @(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'].replace('numpy.', 'NPY_').upper())); + assert(sizeof(@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'].replace('numpy.', 'npy_'))) == sizeof(@primitive_msg_type_to_c(member.type.value_type))); + @(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'].replace('numpy.', 'npy_')) * dst = (@(SPECIAL_NESTED_BASIC_TYPES[member.type.value_type.typename]['dtype'].replace('numpy.', 'npy_')) *)PyArray_GETPTR1(seq_field, 0); + @primitive_msg_type_to_c(member.type.value_type) * src = &(ros_message->@(member.name)[0]); + memcpy(dst, src, @(member.type.size) * sizeof(@primitive_msg_type_to_c(member.type.value_type))); Py_DECREF(field); -@[ elif isinstance(member.type, Sequence)]@ +@[ elif isinstance(member.type, AbstractSequence)]@ if (ros_message->@(member.name).size > 0) { field = PyObject_GetAttrString(_pymessage, "@(member.name)"); if (!field) { @@ -471,7 +471,7 @@ if isinstance(type_, NestedType): assert(itemsize_attr != NULL); size_t itemsize = PyLong_AsSize_t(itemsize_attr); Py_DECREF(itemsize_attr); - if (itemsize != sizeof(@primitive_msg_type_to_c(member.type.basetype))) { + if (itemsize != sizeof(@primitive_msg_type_to_c(member.type.value_type))) { PyErr_SetString(PyExc_RuntimeError, "itemsize doesn't match expectation"); Py_DECREF(field); return NULL; @@ -479,8 +479,8 @@ if isinstance(type_, NestedType): // populating the array.array using the frombytes method PyObject * frombytes = PyObject_GetAttrString(field, "frombytes"); assert(frombytes != NULL); - @primitive_msg_type_to_c(member.type.basetype) * src = &(ros_message->@(member.name).data[0]); - PyObject * data = PyBytes_FromStringAndSize((const char *)src, ros_message->@(member.name).size * sizeof(@primitive_msg_type_to_c(member.type.basetype))); + @primitive_msg_type_to_c(member.type.value_type) * src = &(ros_message->@(member.name).data[0]); + PyObject * data = PyBytes_FromStringAndSize((const char *)src, ros_message->@(member.name).size * sizeof(@primitive_msg_type_to_c(member.type.value_type))); assert(data != NULL); PyObject * ret = PyObject_CallFunctionObjArgs(frombytes, data, NULL); Py_DECREF(data); @@ -498,8 +498,8 @@ if isinstance(type_, NestedType): @{ nested_type = '__'.join(type_.namespaces + [type_.name]) }@ -@[ if isinstance(member.type, NestedType)]@ -@[ if isinstance(member.type, Sequence)]@ +@[ if isinstance(member.type, AbstractNestedType)]@ +@[ if isinstance(member.type, AbstractSequence)]@ size_t size = ros_message->@(member.name).size; @[ else]@ size_t size = @(member.type.size); @@ -510,7 +510,7 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) } @(nested_type) * item; for (size_t i = 0; i < size; ++i) { -@[ if isinstance(member.type, Sequence)]@ +@[ if isinstance(member.type, AbstractSequence)]@ item = &(ros_message->@(member.name).data[i]); @[ else]@ item = &(ros_message->@(member.name)[i]); @@ -531,28 +531,28 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) return NULL; } @[ end if]@ -@[ elif isinstance(member.type, NestedType)]@ -@[ if isinstance(member.type, Sequence)]@ +@[ elif isinstance(member.type, AbstractNestedType)]@ +@[ if isinstance(member.type, AbstractSequence)]@ size_t size = ros_message->@(member.name).size; - @primitive_msg_type_to_c(member.type.basetype) * src = ros_message->@(member.name).data; + @primitive_msg_type_to_c(member.type.value_type) * src = ros_message->@(member.name).data; @[ else]@ size_t size = @(member.type.size); - @primitive_msg_type_to_c(member.type.basetype) * src = ros_message->@(member.name); + @primitive_msg_type_to_c(member.type.value_type) * src = ros_message->@(member.name); @[ end if]@ field = PyList_New(size); if (!field) { return NULL; } for (size_t i = 0; i < size; ++i) { -@[ if isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'char']@ +@[ if isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'char']@ int rc = PyList_SetItem(field, i, Py_BuildValue("C", src[i])); (void)rc; assert(rc == 0); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'octet']@ +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'octet']@ int rc = PyList_SetItem(field, i, PyBytes_FromStringAndSize((const char *)&src[i], 1)); (void)rc; assert(rc == 0); -@[ elif isinstance(member.type.basetype, String)]@ +@[ elif isinstance(member.type.value_type, AbstractString)]@ PyObject * decoded_item = PyUnicode_DecodeASCII(src[i].data, strlen(src[i].data), "strict"); if (!decoded_item) { return NULL; @@ -560,16 +560,16 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) int rc = PyList_SetItem(field, i, decoded_item); (void)rc; assert(rc == 0); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'boolean']@ +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'boolean']@ @# using PyBool_FromLong because PyList_SetItem will steal ownership of the passed item int rc = PyList_SetItem(field, i, PyBool_FromLong(src[i] ? 1 : 0)); (void)rc; assert(rc == 0); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type in ('float', 'double')]@ +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in ('float', 'double')]@ int rc = PyList_SetItem(field, i, PyFloat_FromDouble(src[i])); (void)rc; assert(rc == 0); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type in ( +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in ( 'int8', 'int16', 'int32', @@ -577,7 +577,7 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) int rc = PyList_SetItem(field, i, PyLong_FromLong(src[i])); (void)rc; assert(rc == 0); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type in ( +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename in ( 'uint8', 'uint16', 'uint32', @@ -585,28 +585,28 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) int rc = PyList_SetItem(field, i, PyLong_FromUnsignedLong(src[i])); (void)rc; assert(rc == 0); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'int64']@ +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'int64']@ int rc = PyList_SetItem(field, i, PyLong_FromLongLong(src[i])); (void)rc; assert(rc == 0); -@[ elif isinstance(member.type.basetype, BasicType) and member.type.basetype.type == 'uint64']@ +@[ elif isinstance(member.type.value_type, BasicType) and member.type.value_type.typename == 'uint64']@ int rc = PyList_SetItem(field, i, PyLong_FromUnsignedLongLong(src[i])); (void)rc; assert(rc == 0); @[ end if]@ } assert(PySequence_Check(field)); -@[ elif isinstance(member.type, BasicType) and member.type.type == 'char']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'char']@ field = Py_BuildValue("C", ros_message->@(member.name)); if (!field) { return NULL; } -@[ elif isinstance(member.type, BasicType) and member.type.type == 'octet']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'octet']@ field = PyBytes_FromStringAndSize((const char *)&ros_message->@(member.name), 1); if (!field) { return NULL; } -@[ elif isinstance(member.type, String)]@ +@[ elif isinstance(member.type, AbstractString)]@ field = PyUnicode_DecodeASCII( ros_message->@(member.name).data, strlen(ros_message->@(member.name).data), @@ -614,26 +614,26 @@ nested_type = '__'.join(type_.namespaces + [type_.name]) if (!field) { return NULL; } -@[ elif isinstance(member.type, BasicType) and member.type.type == 'boolean']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'boolean']@ @# using PyBool_FromLong allows treating the variable uniformly by calling Py_DECREF on it later field = PyBool_FromLong(ros_message->@(member.name) ? 1 : 0); -@[ elif isinstance(member.type, BasicType) and member.type.type in ('float', 'double')]@ +@[ elif isinstance(member.type, BasicType) and member.type.typename in ('float', 'double')]@ field = PyFloat_FromDouble(ros_message->@(member.name)); -@[ elif isinstance(member.type, BasicType) and member.type.type in ( +@[ elif isinstance(member.type, BasicType) and member.type.typename in ( 'int8', 'int16', 'int32', )]@ field = PyLong_FromLong(ros_message->@(member.name)); -@[ elif isinstance(member.type, BasicType) and member.type.type in ( +@[ elif isinstance(member.type, BasicType) and member.type.typename in ( 'uint8', 'uint16', 'uint32', )]@ field = PyLong_FromUnsignedLong(ros_message->@(member.name)); -@[ elif isinstance(member.type, BasicType) and member.type.type == 'int64']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'int64']@ field = PyLong_FromLongLong(ros_message->@(member.name)); -@[ elif isinstance(member.type, BasicType) and member.type.type == 'uint64']@ +@[ elif isinstance(member.type, BasicType) and member.type.typename == 'uint64']@ field = PyLong_FromUnsignedLongLong(ros_message->@(member.name)); @[ else]@ assert(false); diff --git a/rosidl_generator_py/resource/_srv.py.em b/rosidl_generator_py/resource/_srv.py.em index f0d25392..8b5a40d6 100644 --- a/rosidl_generator_py/resource/_srv.py.em +++ b/rosidl_generator_py/resource/_srv.py.em @@ -2,7 +2,7 @@ @{ from rosidl_cmake import convert_camel_case_to_lower_case_underscore -service_name = '_' + convert_camel_case_to_lower_case_underscore(service.structure_type.name) +service_name = '_' + convert_camel_case_to_lower_case_underscore(service.namespaced_type.name) module_name = '_' + convert_camel_case_to_lower_case_underscore(interface_path.stem) TEMPLATE( @@ -16,8 +16,8 @@ TEMPLATE( }@ -class Metaclass_@(service.structure_type.name)(type): - """Metaclass of service '@(service.structure_type.name)'.""" +class Metaclass_@(service.namespaced_type.name)(type): + """Metaclass of service '@(service.namespaced_type.name)'.""" _TYPE_SUPPORT = None @@ -30,23 +30,23 @@ class Metaclass_@(service.structure_type.name)(type): import logging import traceback logger = logging.getLogger( - '@('.'.join(service.structure_type.namespaces + [service.structure_type.name]))') + '@('.'.join(service.namespaced_type.namespaces + [service.namespaced_type.name]))') logger.debug( 'Failed to import needed modules for type support:\n' + traceback.format_exc()) else: - cls._TYPE_SUPPORT = module.type_support_srv__@('__'.join(service.structure_type.namespaces[1:]))_@(service_name) + cls._TYPE_SUPPORT = module.type_support_srv__@('__'.join(service.namespaced_type.namespaces[1:]))_@(service_name) - from @('.'.join(service.structure_type.namespaces)) import @(module_name) - if @(module_name).Metaclass_@(service.request_message.structure.type.name)._TYPE_SUPPORT is None: - @(module_name).Metaclass_@(service.request_message.structure.type.name).__import_type_support__() - if @(module_name).Metaclass_@(service.response_message.structure.type.name)._TYPE_SUPPORT is None: - @(module_name).Metaclass_@(service.response_message.structure.type.name).__import_type_support__() + from @('.'.join(service.namespaced_type.namespaces)) import @(module_name) + if @(module_name).Metaclass_@(service.request_message.structure.namespaced_type.name)._TYPE_SUPPORT is None: + @(module_name).Metaclass_@(service.request_message.structure.namespaced_type.name).__import_type_support__() + if @(module_name).Metaclass_@(service.response_message.structure.namespaced_type.name)._TYPE_SUPPORT is None: + @(module_name).Metaclass_@(service.response_message.structure.namespaced_type.name).__import_type_support__() -class @(service.structure_type.name)(metaclass=Metaclass_@(service.structure_type.name)): - from @('.'.join(service.structure_type.namespaces)).@(module_name) import @(service.request_message.structure.type.name) as Request - from @('.'.join(service.structure_type.namespaces)).@(module_name) import @(service.response_message.structure.type.name) as Response +class @(service.namespaced_type.name)(metaclass=Metaclass_@(service.namespaced_type.name)): + from @('.'.join(service.namespaced_type.namespaces)).@(module_name) import @(service.request_message.structure.namespaced_type.name) as Request + from @('.'.join(service.namespaced_type.namespaces)).@(module_name) import @(service.response_message.structure.namespaced_type.name) as Response def __init__(self): raise NotImplementedError('Service classes can not be instantiated') diff --git a/rosidl_generator_py/resource/_srv_pkg_typesupport_entry_point.c.em b/rosidl_generator_py/resource/_srv_pkg_typesupport_entry_point.c.em index 943b9bf6..179234c7 100644 --- a/rosidl_generator_py/resource/_srv_pkg_typesupport_entry_point.c.em +++ b/rosidl_generator_py/resource/_srv_pkg_typesupport_entry_point.c.em @@ -19,16 +19,16 @@ TEMPLATE( @ @{ from rosidl_cmake import convert_camel_case_to_lower_case_underscore -type_name = convert_camel_case_to_lower_case_underscore(service.structure_type.name) +type_name = convert_camel_case_to_lower_case_underscore(service.namespaced_type.name) function_name = 'type_support' }@ ROSIDL_GENERATOR_C_IMPORT const rosidl_service_type_support_t * -ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, @(', '.join(service.structure_type.namespaces + [service.structure_type.name])))(); +ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, @(', '.join(service.namespaced_type.namespaces + [service.namespaced_type.name])))(); @{ -register_function = '_register_srv_type__' + '__'.join(service.structure_type.namespaces[1:] + [type_name]) +register_function = '_register_srv_type__' + '__'.join(service.namespaced_type.namespaces[1:] + [type_name]) register_functions.append(register_function) }@ int8_t @@ -37,7 +37,7 @@ int8_t int8_t err; PyObject * pyobject_@(function_name) = NULL; pyobject_@(function_name) = PyCapsule_New( - (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, @(', '.join(service.structure_type.namespaces + [service.structure_type.name])))(), + (void *)ROSIDL_TYPESUPPORT_INTERFACE__SERVICE_SYMBOL_NAME(rosidl_typesupport_c, @(', '.join(service.namespaced_type.namespaces + [service.namespaced_type.name])))(), NULL, NULL); if (!pyobject_@(function_name)) { // previously added objects will be removed when the module is destroyed @@ -45,7 +45,7 @@ int8_t } err = PyModule_AddObject( pymodule, - "@(function_name)_srv__@('__'.join(service.structure_type.namespaces[1:] + [type_name]))", + "@(function_name)_srv__@('__'.join(service.namespaced_type.namespaces[1:] + [type_name]))", pyobject_@(function_name)); if (err) { // the created capsule needs to be decremented diff --git a/rosidl_generator_py/rosidl_generator_py/generate_py_impl.py b/rosidl_generator_py/rosidl_generator_py/generate_py_impl.py index b471dbc7..d59db7c5 100644 --- a/rosidl_generator_py/rosidl_generator_py/generate_py_impl.py +++ b/rosidl_generator_py/rosidl_generator_py/generate_py_impl.py @@ -21,14 +21,14 @@ from rosidl_cmake import generate_files from rosidl_cmake import get_newest_modification_time from rosidl_cmake import read_generator_arguments +from rosidl_parser.definition import AbstractNestedType +from rosidl_parser.definition import AbstractSequence +from rosidl_parser.definition import AbstractString from rosidl_parser.definition import Array from rosidl_parser.definition import BasicType from rosidl_parser.definition import IdlContent from rosidl_parser.definition import IdlLocator from rosidl_parser.definition import NamespacedType -from rosidl_parser.definition import NestedType -from rosidl_parser.definition import Sequence -from rosidl_parser.definition import String from rosidl_parser.parser import parse_idl_file SPECIAL_NESTED_BASIC_TYPES = { @@ -115,25 +115,25 @@ def generate_py(generator_arguments_file, typesupport_impls): def value_to_py(type_, value, array_as_tuple=False): assert value is not None - if not isinstance(type_, NestedType): + if not isinstance(type_, AbstractNestedType): return primitive_value_to_py(type_, value) py_values = [] for single_value in literal_eval(value): - py_value = primitive_value_to_py(type_.basetype, single_value) + py_value = primitive_value_to_py(type_.value_type, single_value) py_values.append(py_value) if ( - isinstance(type_.basetype, BasicType) and - type_.basetype.type in SPECIAL_NESTED_BASIC_TYPES + isinstance(type_.value_type, BasicType) and + type_.value_type.typename in SPECIAL_NESTED_BASIC_TYPES ): if isinstance(type_, Array): return 'numpy.array((%s, ), dtype=%s)' % ( ', '.join(py_values), - SPECIAL_NESTED_BASIC_TYPES[type_.basetype.type]['dtype']) - if isinstance(type_, Sequence): + SPECIAL_NESTED_BASIC_TYPES[type_.value_type.typename]['dtype']) + if isinstance(type_, AbstractSequence): return "array.array('%s', (%s, ))" % ( - SPECIAL_NESTED_BASIC_TYPES[type_.basetype.type]['type_code'], + SPECIAL_NESTED_BASIC_TYPES[type_.value_type.typename]['type_code'], ', '.join(py_values)) assert False if array_as_tuple: @@ -145,15 +145,15 @@ def value_to_py(type_, value, array_as_tuple=False): def primitive_value_to_py(type_, value): assert value is not None - if isinstance(type_, String): + if isinstance(type_, AbstractString): return quoted_string(value) assert isinstance(type_, BasicType) - if type_.type == 'boolean': + if type_.typename == 'boolean': return 'True' if value else 'False' - if type_.type in ( + if type_.typename in ( 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', @@ -161,26 +161,26 @@ def primitive_value_to_py(type_, value): ): return str(value) - if type_.type == 'char': + if type_.typename == 'char': return repr('%c' % value) - if type_.type == 'octet': + if type_.typename == 'octet': return repr(bytes([value])) - if type_.type in ('float', 'double'): + if type_.typename in ('float', 'double'): return '%s' % value - assert False, "unknown primitive type '%s'" % type_.type + assert False, "unknown primitive type '%s'" % type_.typename def constant_value_to_py(type_, value): assert value is not None if isinstance(type_, BasicType): - if type_.type == 'bool': + if type_.typename == 'bool': return 'True' if value else 'False' - if type_.type in ( + if type_.typename in ( 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', @@ -188,16 +188,16 @@ def constant_value_to_py(type_, value): ): return str(value) - if type_.type == 'char': + if type_.typename == 'char': return repr('%c' % value) - if type_.type == 'octet': + if type_.typename == 'octet': return repr(bytes([value])) - if type_.type in ('float', 'double'): + if type_.typename in ('float', 'double'): return '%s' % value - if isinstance(type_, String): + if isinstance(type_, AbstractString): return quoted_string(value) assert False, "unknown constant type '%s'" % type_ @@ -219,23 +219,26 @@ def get_python_type(type_): if isinstance(type_, NamespacedType): return type_.name - if isinstance(type_, String): + if isinstance(type_, AbstractString): return 'str' - if isinstance(type_, NestedType): - if isinstance(type_.basetype, BasicType) and type_.basetype.type == 'octet': + if isinstance(type_, AbstractNestedType): + if isinstance(type_.value_type, BasicType) and type_.value_type.typename == 'octet': return 'bytes' - if isinstance(type_.basetype, BasicType) and type_.basetype.type in ('char', 'wchar'): + if ( + isinstance(type_.value_type, BasicType) and + type_.value_type.typename in ('char', 'wchar') + ): return 'str' - if isinstance(type_, BasicType) and type_.type == 'boolean': + if isinstance(type_, BasicType) and type_.typename == 'boolean': return 'bool' - if isinstance(type_, BasicType) and type_.type == 'octet': + if isinstance(type_, BasicType) and type_.typename == 'octet': return 'bytes' - if isinstance(type_, BasicType) and type_.type in ( + if isinstance(type_, BasicType) and type_.typename in ( 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', @@ -243,12 +246,12 @@ def get_python_type(type_): ): return 'int' - if isinstance(type_, BasicType) and type_.type in ( + if isinstance(type_, BasicType) and type_.typename in ( 'float', 'double', ): return 'float' - if isinstance(type_, BasicType) and type_.type in ( + if isinstance(type_, BasicType) and type_.typename in ( 'char', 'wchar', ): return 'str'