text: // generated from rosidl_generator_py/resource/_idl_support.c.em
  // with input from control_msgs:msg/InterfaceValue.idl
  // generated code does not contain a copyright notice
  #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
  #include <Python.h>
  #include <stdbool.h>
  #ifndef _WIN32
  # pragma GCC diagnostic push
  # pragma GCC diagnostic ignored "-Wunused-function"
  #endif
  #include "numpy/ndarrayobject.h"
  #ifndef _WIN32
  # pragma GCC diagnostic pop
  #endif
  #include "rosidl_runtime_c/visibility_control.h"
  #include "control_msgs/msg/detail/interface_value__struct.h"
  #include "control_msgs/msg/detail/interface_value__functions.h"
  
  #include "rosidl_runtime_c/primitives_sequence.h"
  #include "rosidl_runtime_c/primitives_sequence_functions.h"
  #include "rosidl_runtime_c/string.h"
  #include "rosidl_runtime_c/string_functions.h"
  
  
  ROSIDL_GENERATOR_C_EXPORT
  bool control_msgs__msg__interface_value__convert_from_py(PyObject * _pymsg, void * _ros_message)
  {
    // check that the passed message is of the expected Python class
    {
      char full_classname_dest[49];
      {
        char * class_name = NULL;
        char * module_name = NULL;
        {
          PyObject * class_attr = PyObject_GetAttrString(_pymsg, "__class__");
          if (class_attr) {
            PyObject * name_attr = PyObject_GetAttrString(class_attr, "__name__");
            if (name_attr) {
              class_name = (char *)PyUnicode_1BYTE_DATA(name_attr);
              Py_DECREF(name_attr);
            }
            PyObject * module_attr = PyObject_GetAttrString(class_attr, "__module__");
            if (module_attr) {
              module_name = (char *)PyUnicode_1BYTE_DATA(module_attr);
              Py_DECREF(module_attr);
            }
            Py_DECREF(class_attr);
          }
        }
        if (!class_name || !module_name) {
          return false;
        }
        snprintf(full_classname_dest, sizeof(full_classname_dest), "%s.%s", module_name, class_name);
      }
      assert(strncmp("control_msgs.msg._interface_value.InterfaceValue", full_classname_dest, 48) == 0);
    }
    control_msgs__msg__InterfaceValue * ros_message = _ros_message;
    {  // interface_names
      PyObject * field = PyObject_GetAttrString(_pymsg, "interface_names");
      if (!field) {
        return false;
      }
      PyObject * seq_field = PySequence_Fast(field, "expected a sequence in 'interface_names'");
      if (!seq_field) {
        Py_DECREF(field);
        return false;
      }
      Py_ssize_t size = PySequence_Size(field);
      if (-1 == size) {
        Py_DECREF(seq_field);
        Py_DECREF(field);
        return false;
      }
      if (!rosidl_runtime_c__String__Sequence__init(&(ros_message->interface_names), size)) {
        PyErr_SetString(PyExc_RuntimeError, "unable to create String__Sequence ros_message");
        Py_DECREF(seq_field);
        Py_DECREF(field);
        return false;
      }
      rosidl_runtime_c__String * dest = ros_message->interface_names.data;
      for (Py_ssize_t i = 0; i < size; ++i) {
        PyObject * item = PySequence_Fast_GET_ITEM(seq_field, i);
        if (!item) {
          Py_DECREF(seq_field);
          Py_DECREF(field);
          return false;
        }
        assert(PyUnicode_Check(item));
        PyObject * encoded_item = PyUnicode_AsUTF8String(item);
        if (!encoded_item) {
          Py_DECREF(seq_field);
          Py_DECREF(field);
          return false;
        }
        rosidl_runtime_c__String__assign(&dest[i], PyBytes_AS_STRING(encoded_item));
        Py_DECREF(encoded_item);
      }
      Py_DECREF(seq_field);
      Py_DECREF(field);
    }
    {  // values
      PyObject * field = PyObject_GetAttrString(_pymsg, "values");
      if (!field) {
        return false;
      }
      PyObject * seq_field = PySequence_Fast(field, "expected a sequence in 'values'");
      if (!seq_field) {
        Py_DECREF(field);
        return false;
      }
      Py_ssize_t size = PySequence_Size(field);
      if (-1 == size) {
        Py_DECREF(seq_field);
        Py_DECREF(field);
        return false;
      }
      if (!rosidl_runtime_c__double__Sequence__init(&(ros_message->values), size)) {
        PyErr_SetString(PyExc_RuntimeError, "unable to create double__Sequence ros_message");
        Py_DECREF(seq_field);
        Py_DECREF(field);
        return false;
      }
      double * dest = ros_message->values.data;
      for (Py_ssize_t i = 0; i < size; ++i) {
        PyObject * item = PySequence_Fast_GET_ITEM(seq_field, i);
        if (!item) {
          Py_DECREF(seq_field);
          Py_DECREF(field);
          return false;
        }
        assert(PyFloat_Check(item));
        double tmp = PyFloat_AS_DOUBLE(item);
        memcpy(&dest[i], &tmp, sizeof(double));
      }
      Py_DECREF(seq_field);
      Py_DECREF(field);
    }
  
    return true;
  }
  
  ROSIDL_GENERATOR_C_EXPORT
  PyObject * control_msgs__msg__interface_value__convert_to_py(void * raw_ros_message)
  {
    /* NOTE(esteve): Call constructor of InterfaceValue */
    PyObject * _pymessage = NULL;
    {
      PyObject * pymessage_module = PyImport_ImportModule("control_msgs.msg._interface_value");
      assert(pymessage_module);
      PyObject * pymessage_class = PyObject_GetAttrString(pymessage_module, "InterfaceValue");
      assert(pymessage_class);
      Py_DECREF(pymessage_module);
      _pymessage = PyObject_CallObject(pymessage_class, NULL);
      Py_DECREF(pymessage_class);
      if (!_pymessage) {
        return NULL;
      }
    }
    control_msgs__msg__InterfaceValue * ros_message = (control_msgs__msg__InterfaceValue *)raw_ros_message;
    {  // interface_names
      PyObject * field = NULL;
      size_t size = ros_message->interface_names.size;
      rosidl_runtime_c__String * src = ros_message->interface_names.data;
      field = PyList_New(size);
      if (!field) {
        return NULL;
      }
      for (size_t i = 0; i < size; ++i) {
        PyObject * decoded_item = PyUnicode_DecodeUTF8(src[i].data, strlen(src[i].data), "strict");
        if (!decoded_item) {
          return NULL;
        }
        int rc = PyList_SetItem(field, i, decoded_item);
        (void)rc;
        assert(rc == 0);
      }
      assert(PySequence_Check(field));
      {
        int rc = PyObject_SetAttrString(_pymessage, "interface_names", field);
        Py_DECREF(field);
        if (rc) {
          return NULL;
        }
      }
    }
    {  // values
      PyObject * field = NULL;
      field = PyObject_GetAttrString(_pymessage, "values");
      if (!field) {
        return NULL;
      }
      assert(field->ob_type != NULL);
      assert(field->ob_type->tp_name != NULL);
      assert(strcmp(field->ob_type->tp_name, "array.array") == 0);
      // ensure that itemsize matches the sizeof of the ROS message field
      PyObject * itemsize_attr = PyObject_GetAttrString(field, "itemsize");
      assert(itemsize_attr != NULL);
      size_t itemsize = PyLong_AsSize_t(itemsize_attr);
      Py_DECREF(itemsize_attr);
      if (itemsize != sizeof(double)) {
        PyErr_SetString(PyExc_RuntimeError, "itemsize doesn't match expectation");
        Py_DECREF(field);
        return NULL;
      }
      // clear the array, poor approach to remove potential default values
      Py_ssize_t length = PyObject_Length(field);
      if (-1 == length) {
        Py_DECREF(field);
        return NULL;
      }
      if (length > 0) {
        PyObject * pop = PyObject_GetAttrString(field, "pop");
        assert(pop != NULL);
        for (Py_ssize_t i = 0; i < length; ++i) {
          PyObject * ret = PyObject_CallFunctionObjArgs(pop, NULL);
          if (!ret) {
            Py_DECREF(pop);
            Py_DECREF(field);
            return NULL;
          }
          Py_DECREF(ret);
        }
        Py_DECREF(pop);
      }
      if (ros_message->values.size > 0) {
        // populating the array.array using the frombytes method
        PyObject * frombytes = PyObject_GetAttrString(field, "frombytes");
        assert(frombytes != NULL);
        double * src = &(ros_message->values.data[0]);
        PyObject * data = PyBytes_FromStringAndSize((const char *)src, ros_message->values.size * sizeof(double));
        assert(data != NULL);
        PyObject * ret = PyObject_CallFunctionObjArgs(frombytes, data, NULL);
        Py_DECREF(data);
        Py_DECREF(frombytes);
        if (!ret) {
          Py_DECREF(field);
          return NULL;
        }
        Py_DECREF(ret);
      }
      Py_DECREF(field);
    }
  
    // ownership of _pymessage is transferred to the caller
    return _pymessage;
  }
  