|
# generated from rosidl_generator_py/resource/_idl.py.em
|
|
# with input from turtle_interfaces:srv/Setcolor.idl
|
|
# generated code does not contain a copyright notice
|
|
|
|
|
|
# Import statements for member types
|
|
|
|
import rosidl_parser.definition # noqa: E402, I100
|
|
|
|
|
|
class Metaclass_Setcolor_Request(type):
|
|
"""Metaclass of message 'Setcolor_Request'."""
|
|
|
|
_CREATE_ROS_MESSAGE = None
|
|
_CONVERT_FROM_PY = None
|
|
_CONVERT_TO_PY = None
|
|
_DESTROY_ROS_MESSAGE = None
|
|
_TYPE_SUPPORT = None
|
|
|
|
__constants = {
|
|
}
|
|
|
|
@classmethod
|
|
def __import_type_support__(cls):
|
|
try:
|
|
from rosidl_generator_py import import_type_support
|
|
module = import_type_support('turtle_interfaces')
|
|
except ImportError:
|
|
import logging
|
|
import traceback
|
|
logger = logging.getLogger(
|
|
'turtle_interfaces.srv.Setcolor_Request')
|
|
logger.debug(
|
|
'Failed to import needed modules for type support:\n' +
|
|
traceback.format_exc())
|
|
else:
|
|
cls._CREATE_ROS_MESSAGE = module.create_ros_message_msg__srv__setcolor__request
|
|
cls._CONVERT_FROM_PY = module.convert_from_py_msg__srv__setcolor__request
|
|
cls._CONVERT_TO_PY = module.convert_to_py_msg__srv__setcolor__request
|
|
cls._TYPE_SUPPORT = module.type_support_msg__srv__setcolor__request
|
|
cls._DESTROY_ROS_MESSAGE = module.destroy_ros_message_msg__srv__setcolor__request
|
|
|
|
@classmethod
|
|
def __prepare__(cls, name, bases, **kwargs):
|
|
# list constant names here so that they appear in the help text of
|
|
# the message class under "Data and other attributes defined here:"
|
|
# as well as populate each message instance
|
|
return {
|
|
}
|
|
|
|
|
|
class Setcolor_Request(metaclass=Metaclass_Setcolor_Request):
|
|
"""Message class 'Setcolor_Request'."""
|
|
|
|
__slots__ = [
|
|
'_color',
|
|
]
|
|
|
|
_fields_and_field_types = {
|
|
'color': 'string',
|
|
}
|
|
|
|
SLOT_TYPES = (
|
|
rosidl_parser.definition.UnboundedString(), # noqa: E501
|
|
)
|
|
|
|
def __init__(self, **kwargs):
|
|
assert all('_' + key in self.__slots__ for key in kwargs.keys()), \
|
|
'Invalid arguments passed to constructor: %s' % \
|
|
', '.join(sorted(k for k in kwargs.keys() if '_' + k not in self.__slots__))
|
|
self.color = kwargs.get('color', str())
|
|
|
|
def __repr__(self):
|
|
typename = self.__class__.__module__.split('.')
|
|
typename.pop()
|
|
typename.append(self.__class__.__name__)
|
|
args = []
|
|
for s, t in zip(self.__slots__, self.SLOT_TYPES):
|
|
field = getattr(self, s)
|
|
fieldstr = repr(field)
|
|
# We use Python array type for fields that can be directly stored
|
|
# in them, and "normal" sequences for everything else. If it is
|
|
# a type that we store in an array, strip off the 'array' portion.
|
|
if (
|
|
isinstance(t, rosidl_parser.definition.AbstractSequence) and
|
|
isinstance(t.value_type, rosidl_parser.definition.BasicType) and
|
|
t.value_type.typename in ['float', 'double', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64']
|
|
):
|
|
if len(field) == 0:
|
|
fieldstr = '[]'
|
|
else:
|
|
assert fieldstr.startswith('array(')
|
|
prefix = "array('X', "
|
|
suffix = ')'
|
|
fieldstr = fieldstr[len(prefix):-len(suffix)]
|
|
args.append(s[1:] + '=' + fieldstr)
|
|
return '%s(%s)' % ('.'.join(typename), ', '.join(args))
|
|
|
|
def __eq__(self, other):
|
|
if not isinstance(other, self.__class__):
|
|
return False
|
|
if self.color != other.color:
|
|
return False
|
|
return True
|
|
|
|
@classmethod
|
|
def get_fields_and_field_types(cls):
|
|
from copy import copy
|
|
return copy(cls._fields_and_field_types)
|
|
|
|
@property
|
|
def color(self):
|
|
"""Message field 'color'."""
|
|
return self._color
|
|
|
|
@color.setter
|
|
def color(self, value):
|
|
if __debug__:
|
|
assert \
|
|
isinstance(value, str), \
|
|
"The 'color' field must be of type 'str'"
|
|
self._color = value
|
|
|
|
|
|
# Import statements for member types
|
|
|
|
# already imported above
|
|
# import rosidl_parser.definition
|
|
|
|
|
|
class Metaclass_Setcolor_Response(type):
|
|
"""Metaclass of message 'Setcolor_Response'."""
|
|
|
|
_CREATE_ROS_MESSAGE = None
|
|
_CONVERT_FROM_PY = None
|
|
_CONVERT_TO_PY = None
|
|
_DESTROY_ROS_MESSAGE = None
|
|
_TYPE_SUPPORT = None
|
|
|
|
__constants = {
|
|
}
|
|
|
|
@classmethod
|
|
def __import_type_support__(cls):
|
|
try:
|
|
from rosidl_generator_py import import_type_support
|
|
module = import_type_support('turtle_interfaces')
|
|
except ImportError:
|
|
import logging
|
|
import traceback
|
|
logger = logging.getLogger(
|
|
'turtle_interfaces.srv.Setcolor_Response')
|
|
logger.debug(
|
|
'Failed to import needed modules for type support:\n' +
|
|
traceback.format_exc())
|
|
else:
|
|
cls._CREATE_ROS_MESSAGE = module.create_ros_message_msg__srv__setcolor__response
|
|
cls._CONVERT_FROM_PY = module.convert_from_py_msg__srv__setcolor__response
|
|
cls._CONVERT_TO_PY = module.convert_to_py_msg__srv__setcolor__response
|
|
cls._TYPE_SUPPORT = module.type_support_msg__srv__setcolor__response
|
|
cls._DESTROY_ROS_MESSAGE = module.destroy_ros_message_msg__srv__setcolor__response
|
|
|
|
@classmethod
|
|
def __prepare__(cls, name, bases, **kwargs):
|
|
# list constant names here so that they appear in the help text of
|
|
# the message class under "Data and other attributes defined here:"
|
|
# as well as populate each message instance
|
|
return {
|
|
}
|
|
|
|
|
|
class Setcolor_Response(metaclass=Metaclass_Setcolor_Response):
|
|
"""Message class 'Setcolor_Response'."""
|
|
|
|
__slots__ = [
|
|
'_ret',
|
|
]
|
|
|
|
_fields_and_field_types = {
|
|
'ret': 'int8',
|
|
}
|
|
|
|
SLOT_TYPES = (
|
|
rosidl_parser.definition.BasicType('int8'), # noqa: E501
|
|
)
|
|
|
|
def __init__(self, **kwargs):
|
|
assert all('_' + key in self.__slots__ for key in kwargs.keys()), \
|
|
'Invalid arguments passed to constructor: %s' % \
|
|
', '.join(sorted(k for k in kwargs.keys() if '_' + k not in self.__slots__))
|
|
self.ret = kwargs.get('ret', int())
|
|
|
|
def __repr__(self):
|
|
typename = self.__class__.__module__.split('.')
|
|
typename.pop()
|
|
typename.append(self.__class__.__name__)
|
|
args = []
|
|
for s, t in zip(self.__slots__, self.SLOT_TYPES):
|
|
field = getattr(self, s)
|
|
fieldstr = repr(field)
|
|
# We use Python array type for fields that can be directly stored
|
|
# in them, and "normal" sequences for everything else. If it is
|
|
# a type that we store in an array, strip off the 'array' portion.
|
|
if (
|
|
isinstance(t, rosidl_parser.definition.AbstractSequence) and
|
|
isinstance(t.value_type, rosidl_parser.definition.BasicType) and
|
|
t.value_type.typename in ['float', 'double', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', 'uint64']
|
|
):
|
|
if len(field) == 0:
|
|
fieldstr = '[]'
|
|
else:
|
|
assert fieldstr.startswith('array(')
|
|
prefix = "array('X', "
|
|
suffix = ')'
|
|
fieldstr = fieldstr[len(prefix):-len(suffix)]
|
|
args.append(s[1:] + '=' + fieldstr)
|
|
return '%s(%s)' % ('.'.join(typename), ', '.join(args))
|
|
|
|
def __eq__(self, other):
|
|
if not isinstance(other, self.__class__):
|
|
return False
|
|
if self.ret != other.ret:
|
|
return False
|
|
return True
|
|
|
|
@classmethod
|
|
def get_fields_and_field_types(cls):
|
|
from copy import copy
|
|
return copy(cls._fields_and_field_types)
|
|
|
|
@property
|
|
def ret(self):
|
|
"""Message field 'ret'."""
|
|
return self._ret
|
|
|
|
@ret.setter
|
|
def ret(self, value):
|
|
if __debug__:
|
|
assert \
|
|
isinstance(value, int), \
|
|
"The 'ret' field must be of type 'int'"
|
|
assert value >= -128 and value < 128, \
|
|
"The 'ret' field must be an integer in [-128, 127]"
|
|
self._ret = value
|
|
|
|
|
|
class Metaclass_Setcolor(type):
|
|
"""Metaclass of service 'Setcolor'."""
|
|
|
|
_TYPE_SUPPORT = None
|
|
|
|
@classmethod
|
|
def __import_type_support__(cls):
|
|
try:
|
|
from rosidl_generator_py import import_type_support
|
|
module = import_type_support('turtle_interfaces')
|
|
except ImportError:
|
|
import logging
|
|
import traceback
|
|
logger = logging.getLogger(
|
|
'turtle_interfaces.srv.Setcolor')
|
|
logger.debug(
|
|
'Failed to import needed modules for type support:\n' +
|
|
traceback.format_exc())
|
|
else:
|
|
cls._TYPE_SUPPORT = module.type_support_srv__srv__setcolor
|
|
|
|
from turtle_interfaces.srv import _setcolor
|
|
if _setcolor.Metaclass_Setcolor_Request._TYPE_SUPPORT is None:
|
|
_setcolor.Metaclass_Setcolor_Request.__import_type_support__()
|
|
if _setcolor.Metaclass_Setcolor_Response._TYPE_SUPPORT is None:
|
|
_setcolor.Metaclass_Setcolor_Response.__import_type_support__()
|
|
|
|
|
|
class Setcolor(metaclass=Metaclass_Setcolor):
|
|
from turtle_interfaces.srv._setcolor import Setcolor_Request as Request
|
|
from turtle_interfaces.srv._setcolor import Setcolor_Response as Response
|
|
|
|
def __init__(self):
|
|
raise NotImplementedError('Service classes can not be instantiated')
|