text: # generated from rosidl_generator_py/resource/_idl.py.em
  # with input from std_msgs:msg\Int16MultiArray.idl
  # generated code does not contain a copyright notice
  
  
  # Import statements for member types
  
  # Member 'data'
  import array  # noqa: E402, I100
  
  from rosidl_parser.rosidl_parser import definition as rosidl_parser_definition  # noqa: E402, I100
  
  
  class Metaclass_Int16MultiArray(type):
      """Metaclass of message 'Int16MultiArray'."""
  
      _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('std_msgs')
          except ImportError:
              import logging
              import traceback
              logger = logging.getLogger(
                  'std_msgs.msg.Int16MultiArray')
              logger.debug(
                  'Failed to import needed modules for type support:\n' +
                  traceback.format_exc())
          else:
              cls._CREATE_ROS_MESSAGE = module.create_ros_message_msg__msg__int16_multi_array
              cls._CONVERT_FROM_PY = module.convert_from_py_msg__msg__int16_multi_array
              cls._CONVERT_TO_PY = module.convert_to_py_msg__msg__int16_multi_array
              cls._TYPE_SUPPORT = module.type_support_msg__msg__int16_multi_array
              cls._DESTROY_ROS_MESSAGE = module.destroy_ros_message_msg__msg__int16_multi_array
  
              from std_msgs.msg import MultiArrayLayout
              if MultiArrayLayout.__class__._TYPE_SUPPORT is None:
                  MultiArrayLayout.__class__.__import_type_support__()
  
      @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 Int16MultiArray(metaclass=Metaclass_Int16MultiArray):
      """Message class 'Int16MultiArray'."""
  
      __slots__ = [
          '_layout',
          '_data',
      ]
  
      _fields_and_field_types = {
          'layout': 'std_msgs/MultiArrayLayout',
          'data': 'sequence<int16>',
      }
  
      SLOT_TYPES = (
          rosidl_parser_definition.NamespacedType(['std_msgs', 'msg'], 'MultiArrayLayout'),  # noqa: E501
          rosidl_parser_definition.UnboundedSequence(rosidl_parser_definition.BasicType('int16')),  # 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__))
          from std_msgs.msg import MultiArrayLayout
          self.layout = kwargs.get('layout', MultiArrayLayout())
          self.data = array.array('h', kwargs.get('data', []))
  
      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.layout != other.layout:
              return False
          if self.data != other.data:
              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 layout(self):
          """Message field 'layout'."""
          return self._layout
  
      @layout.setter
      def layout(self, value):
          if __debug__:
              from std_msgs.msg import MultiArrayLayout
              assert \
                  isinstance(value, MultiArrayLayout), \
                  "The 'layout' field must be a sub message of type 'MultiArrayLayout'"
          self._layout = value
  
      @property
      def data(self):
          """Message field 'data'."""
          return self._data
  
      @data.setter
      def data(self, value):
          if isinstance(value, array.array):
              assert value.typecode == 'h', \
                  "The 'data' array.array() must have the type code of 'h'"
              self._data = value
              return
          if __debug__:
              from collections.abc import Sequence
              from collections.abc import Set
              from collections import UserList
              from collections import UserString
              assert \
                  ((isinstance(value, Sequence) or
                    isinstance(value, Set) or
                    isinstance(value, UserList)) and
                   not isinstance(value, str) and
                   not isinstance(value, UserString) and
                   all(isinstance(v, int) for v in value) and
                   all(val >= -32768 and val < 32768 for val in value)), \
                  "The 'data' field must be a set or sequence and each value of type 'int' and each integer in [-32768, 32767]"
          self._data = array.array('h', value)
  