ChangeDriftDimensions.h

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