Joy.h

00001 #ifndef _ROS_sensor_msgs_Joy_h
00002 #define _ROS_sensor_msgs_Joy_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 #include "std_msgs/Header.h"
00009 
00010 namespace sensor_msgs
00011 {
00012 
00013   class Joy : public ros::Msg
00014   {
00015     public:
00016       typedef std_msgs::Header _header_type;
00017       _header_type header;
00018       uint32_t axes_length;
00019       typedef float _axes_type;
00020       _axes_type st_axes;
00021       _axes_type * axes;
00022       uint32_t buttons_length;
00023       typedef int32_t _buttons_type;
00024       _buttons_type st_buttons;
00025       _buttons_type * buttons;
00026 
00027     Joy():
00028       header(),
00029       axes_length(0), axes(NULL),
00030       buttons_length(0), buttons(NULL)
00031     {
00032     }
00033 
00034     virtual int serialize(unsigned char *outbuffer) const
00035     {
00036       int offset = 0;
00037       offset += this->header.serialize(outbuffer + offset);
00038       *(outbuffer + offset + 0) = (this->axes_length >> (8 * 0)) & 0xFF;
00039       *(outbuffer + offset + 1) = (this->axes_length >> (8 * 1)) & 0xFF;
00040       *(outbuffer + offset + 2) = (this->axes_length >> (8 * 2)) & 0xFF;
00041       *(outbuffer + offset + 3) = (this->axes_length >> (8 * 3)) & 0xFF;
00042       offset += sizeof(this->axes_length);
00043       for( uint32_t i = 0; i < axes_length; i++){
00044       union {
00045         float real;
00046         uint32_t base;
00047       } u_axesi;
00048       u_axesi.real = this->axes[i];
00049       *(outbuffer + offset + 0) = (u_axesi.base >> (8 * 0)) & 0xFF;
00050       *(outbuffer + offset + 1) = (u_axesi.base >> (8 * 1)) & 0xFF;
00051       *(outbuffer + offset + 2) = (u_axesi.base >> (8 * 2)) & 0xFF;
00052       *(outbuffer + offset + 3) = (u_axesi.base >> (8 * 3)) & 0xFF;
00053       offset += sizeof(this->axes[i]);
00054       }
00055       *(outbuffer + offset + 0) = (this->buttons_length >> (8 * 0)) & 0xFF;
00056       *(outbuffer + offset + 1) = (this->buttons_length >> (8 * 1)) & 0xFF;
00057       *(outbuffer + offset + 2) = (this->buttons_length >> (8 * 2)) & 0xFF;
00058       *(outbuffer + offset + 3) = (this->buttons_length >> (8 * 3)) & 0xFF;
00059       offset += sizeof(this->buttons_length);
00060       for( uint32_t i = 0; i < buttons_length; i++){
00061       union {
00062         int32_t real;
00063         uint32_t base;
00064       } u_buttonsi;
00065       u_buttonsi.real = this->buttons[i];
00066       *(outbuffer + offset + 0) = (u_buttonsi.base >> (8 * 0)) & 0xFF;
00067       *(outbuffer + offset + 1) = (u_buttonsi.base >> (8 * 1)) & 0xFF;
00068       *(outbuffer + offset + 2) = (u_buttonsi.base >> (8 * 2)) & 0xFF;
00069       *(outbuffer + offset + 3) = (u_buttonsi.base >> (8 * 3)) & 0xFF;
00070       offset += sizeof(this->buttons[i]);
00071       }
00072       return offset;
00073     }
00074 
00075     virtual int deserialize(unsigned char *inbuffer)
00076     {
00077       int offset = 0;
00078       offset += this->header.deserialize(inbuffer + offset);
00079       uint32_t axes_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00080       axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00081       axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00082       axes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00083       offset += sizeof(this->axes_length);
00084       if(axes_lengthT > axes_length)
00085         this->axes = (float*)realloc(this->axes, axes_lengthT * sizeof(float));
00086       axes_length = axes_lengthT;
00087       for( uint32_t i = 0; i < axes_length; i++){
00088       union {
00089         float real;
00090         uint32_t base;
00091       } u_st_axes;
00092       u_st_axes.base = 0;
00093       u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00094       u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00095       u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00096       u_st_axes.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00097       this->st_axes = u_st_axes.real;
00098       offset += sizeof(this->st_axes);
00099         memcpy( &(this->axes[i]), &(this->st_axes), sizeof(float));
00100       }
00101       uint32_t buttons_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00102       buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00103       buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00104       buttons_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00105       offset += sizeof(this->buttons_length);
00106       if(buttons_lengthT > buttons_length)
00107         this->buttons = (int32_t*)realloc(this->buttons, buttons_lengthT * sizeof(int32_t));
00108       buttons_length = buttons_lengthT;
00109       for( uint32_t i = 0; i < buttons_length; i++){
00110       union {
00111         int32_t real;
00112         uint32_t base;
00113       } u_st_buttons;
00114       u_st_buttons.base = 0;
00115       u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00116       u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00117       u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00118       u_st_buttons.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00119       this->st_buttons = u_st_buttons.real;
00120       offset += sizeof(this->st_buttons);
00121         memcpy( &(this->buttons[i]), &(this->st_buttons), sizeof(int32_t));
00122       }
00123      return offset;
00124     }
00125 
00126     const char * getType(){ return "sensor_msgs/Joy"; };
00127     const char * getMD5(){ return "5a9ea5f83505693b71e785041e67a8bb"; };
00128 
00129   };
00130 
00131 }
00132 #endif