ChangeControlDimensions.h

00001 #ifndef _ROS_SERVICE_ChangeControlDimensions_h
00002 #define _ROS_SERVICE_ChangeControlDimensions_h
00003 #include <stdint.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include "ros/msg.h"
00007 
00008 namespace moveit_msgs
00009 {
00010 
00011 static const char CHANGECONTROLDIMENSIONS[] = "moveit_msgs/ChangeControlDimensions";
00012 
00013   class ChangeControlDimensionsRequest : public ros::Msg
00014   {
00015     public:
00016       typedef bool _control_x_translation_type;
00017       _control_x_translation_type control_x_translation;
00018       typedef bool _control_y_translation_type;
00019       _control_y_translation_type control_y_translation;
00020       typedef bool _control_z_translation_type;
00021       _control_z_translation_type control_z_translation;
00022       typedef bool _control_x_rotation_type;
00023       _control_x_rotation_type control_x_rotation;
00024       typedef bool _control_y_rotation_type;
00025       _control_y_rotation_type control_y_rotation;
00026       typedef bool _control_z_rotation_type;
00027       _control_z_rotation_type control_z_rotation;
00028 
00029     ChangeControlDimensionsRequest():
00030       control_x_translation(0),
00031       control_y_translation(0),
00032       control_z_translation(0),
00033       control_x_rotation(0),
00034       control_y_rotation(0),
00035       control_z_rotation(0)
00036     {
00037     }
00038 
00039     virtual int serialize(unsigned char *outbuffer) const
00040     {
00041       int offset = 0;
00042       union {
00043         bool real;
00044         uint8_t base;
00045       } u_control_x_translation;
00046       u_control_x_translation.real = this->control_x_translation;
00047       *(outbuffer + offset + 0) = (u_control_x_translation.base >> (8 * 0)) & 0xFF;
00048       offset += sizeof(this->control_x_translation);
00049       union {
00050         bool real;
00051         uint8_t base;
00052       } u_control_y_translation;
00053       u_control_y_translation.real = this->control_y_translation;
00054       *(outbuffer + offset + 0) = (u_control_y_translation.base >> (8 * 0)) & 0xFF;
00055       offset += sizeof(this->control_y_translation);
00056       union {
00057         bool real;
00058         uint8_t base;
00059       } u_control_z_translation;
00060       u_control_z_translation.real = this->control_z_translation;
00061       *(outbuffer + offset + 0) = (u_control_z_translation.base >> (8 * 0)) & 0xFF;
00062       offset += sizeof(this->control_z_translation);
00063       union {
00064         bool real;
00065         uint8_t base;
00066       } u_control_x_rotation;
00067       u_control_x_rotation.real = this->control_x_rotation;
00068       *(outbuffer + offset + 0) = (u_control_x_rotation.base >> (8 * 0)) & 0xFF;
00069       offset += sizeof(this->control_x_rotation);
00070       union {
00071         bool real;
00072         uint8_t base;
00073       } u_control_y_rotation;
00074       u_control_y_rotation.real = this->control_y_rotation;
00075       *(outbuffer + offset + 0) = (u_control_y_rotation.base >> (8 * 0)) & 0xFF;
00076       offset += sizeof(this->control_y_rotation);
00077       union {
00078         bool real;
00079         uint8_t base;
00080       } u_control_z_rotation;
00081       u_control_z_rotation.real = this->control_z_rotation;
00082       *(outbuffer + offset + 0) = (u_control_z_rotation.base >> (8 * 0)) & 0xFF;
00083       offset += sizeof(this->control_z_rotation);
00084       return offset;
00085     }
00086 
00087     virtual int deserialize(unsigned char *inbuffer)
00088     {
00089       int offset = 0;
00090       union {
00091         bool real;
00092         uint8_t base;
00093       } u_control_x_translation;
00094       u_control_x_translation.base = 0;
00095       u_control_x_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00096       this->control_x_translation = u_control_x_translation.real;
00097       offset += sizeof(this->control_x_translation);
00098       union {
00099         bool real;
00100         uint8_t base;
00101       } u_control_y_translation;
00102       u_control_y_translation.base = 0;
00103       u_control_y_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00104       this->control_y_translation = u_control_y_translation.real;
00105       offset += sizeof(this->control_y_translation);
00106       union {
00107         bool real;
00108         uint8_t base;
00109       } u_control_z_translation;
00110       u_control_z_translation.base = 0;
00111       u_control_z_translation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00112       this->control_z_translation = u_control_z_translation.real;
00113       offset += sizeof(this->control_z_translation);
00114       union {
00115         bool real;
00116         uint8_t base;
00117       } u_control_x_rotation;
00118       u_control_x_rotation.base = 0;
00119       u_control_x_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00120       this->control_x_rotation = u_control_x_rotation.real;
00121       offset += sizeof(this->control_x_rotation);
00122       union {
00123         bool real;
00124         uint8_t base;
00125       } u_control_y_rotation;
00126       u_control_y_rotation.base = 0;
00127       u_control_y_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00128       this->control_y_rotation = u_control_y_rotation.real;
00129       offset += sizeof(this->control_y_rotation);
00130       union {
00131         bool real;
00132         uint8_t base;
00133       } u_control_z_rotation;
00134       u_control_z_rotation.base = 0;
00135       u_control_z_rotation.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00136       this->control_z_rotation = u_control_z_rotation.real;
00137       offset += sizeof(this->control_z_rotation);
00138      return offset;
00139     }
00140 
00141     virtual const char * getType(){ return CHANGECONTROLDIMENSIONS; };
00142     virtual const char * getMD5(){ return "64c0dd6d519e78f5ce2626b06dab34c1"; };
00143 
00144   };
00145 
00146   class ChangeControlDimensionsResponse : public ros::Msg
00147   {
00148     public:
00149       typedef bool _success_type;
00150       _success_type success;
00151 
00152     ChangeControlDimensionsResponse():
00153       success(0)
00154     {
00155     }
00156 
00157     virtual int serialize(unsigned char *outbuffer) const
00158     {
00159       int offset = 0;
00160       union {
00161         bool real;
00162         uint8_t base;
00163       } u_success;
00164       u_success.real = this->success;
00165       *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
00166       offset += sizeof(this->success);
00167       return offset;
00168     }
00169 
00170     virtual int deserialize(unsigned char *inbuffer)
00171     {
00172       int offset = 0;
00173       union {
00174         bool real;
00175         uint8_t base;
00176       } u_success;
00177       u_success.base = 0;
00178       u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00179       this->success = u_success.real;
00180       offset += sizeof(this->success);
00181      return offset;
00182     }
00183 
00184     virtual const char * getType(){ return CHANGECONTROLDIMENSIONS; };
00185     virtual const char * getMD5(){ return "358e233cde0c8a8bcfea4ce193f8fc15"; };
00186 
00187   };
00188 
00189   class ChangeControlDimensions {
00190     public:
00191     typedef ChangeControlDimensionsRequest Request;
00192     typedef ChangeControlDimensionsResponse Response;
00193   };
00194 
00195 }
00196 #endif