SetTemplate.h

00001 #ifndef _ROS_SERVICE_SetTemplate_h
00002 #define _ROS_SERVICE_SetTemplate_h
00003 #include <stdint.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include "ros/msg.h"
00007 #include "sensor_msgs/Image.h"
00008 #include "geometry_msgs/Pose.h"
00009 
00010 namespace jsk_recognition_msgs
00011 {
00012 
00013 static const char SETTEMPLATE[] = "jsk_recognition_msgs/SetTemplate";
00014 
00015   class SetTemplateRequest : public ros::Msg
00016   {
00017     public:
00018       typedef const char* _type_type;
00019       _type_type type;
00020       typedef sensor_msgs::Image _image_type;
00021       _image_type image;
00022       typedef float _dimx_type;
00023       _dimx_type dimx;
00024       typedef float _dimy_type;
00025       _dimy_type dimy;
00026       typedef geometry_msgs::Pose _relativepose_type;
00027       _relativepose_type relativepose;
00028       typedef const char* _savefilename_type;
00029       _savefilename_type savefilename;
00030 
00031     SetTemplateRequest():
00032       type(""),
00033       image(),
00034       dimx(0),
00035       dimy(0),
00036       relativepose(),
00037       savefilename("")
00038     {
00039     }
00040 
00041     virtual int serialize(unsigned char *outbuffer) const
00042     {
00043       int offset = 0;
00044       uint32_t length_type = strlen(this->type);
00045       varToArr(outbuffer + offset, length_type);
00046       offset += 4;
00047       memcpy(outbuffer + offset, this->type, length_type);
00048       offset += length_type;
00049       offset += this->image.serialize(outbuffer + offset);
00050       union {
00051         float real;
00052         uint32_t base;
00053       } u_dimx;
00054       u_dimx.real = this->dimx;
00055       *(outbuffer + offset + 0) = (u_dimx.base >> (8 * 0)) & 0xFF;
00056       *(outbuffer + offset + 1) = (u_dimx.base >> (8 * 1)) & 0xFF;
00057       *(outbuffer + offset + 2) = (u_dimx.base >> (8 * 2)) & 0xFF;
00058       *(outbuffer + offset + 3) = (u_dimx.base >> (8 * 3)) & 0xFF;
00059       offset += sizeof(this->dimx);
00060       union {
00061         float real;
00062         uint32_t base;
00063       } u_dimy;
00064       u_dimy.real = this->dimy;
00065       *(outbuffer + offset + 0) = (u_dimy.base >> (8 * 0)) & 0xFF;
00066       *(outbuffer + offset + 1) = (u_dimy.base >> (8 * 1)) & 0xFF;
00067       *(outbuffer + offset + 2) = (u_dimy.base >> (8 * 2)) & 0xFF;
00068       *(outbuffer + offset + 3) = (u_dimy.base >> (8 * 3)) & 0xFF;
00069       offset += sizeof(this->dimy);
00070       offset += this->relativepose.serialize(outbuffer + offset);
00071       uint32_t length_savefilename = strlen(this->savefilename);
00072       varToArr(outbuffer + offset, length_savefilename);
00073       offset += 4;
00074       memcpy(outbuffer + offset, this->savefilename, length_savefilename);
00075       offset += length_savefilename;
00076       return offset;
00077     }
00078 
00079     virtual int deserialize(unsigned char *inbuffer)
00080     {
00081       int offset = 0;
00082       uint32_t length_type;
00083       arrToVar(length_type, (inbuffer + offset));
00084       offset += 4;
00085       for(unsigned int k= offset; k< offset+length_type; ++k){
00086           inbuffer[k-1]=inbuffer[k];
00087       }
00088       inbuffer[offset+length_type-1]=0;
00089       this->type = (char *)(inbuffer + offset-1);
00090       offset += length_type;
00091       offset += this->image.deserialize(inbuffer + offset);
00092       union {
00093         float real;
00094         uint32_t base;
00095       } u_dimx;
00096       u_dimx.base = 0;
00097       u_dimx.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00098       u_dimx.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00099       u_dimx.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00100       u_dimx.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00101       this->dimx = u_dimx.real;
00102       offset += sizeof(this->dimx);
00103       union {
00104         float real;
00105         uint32_t base;
00106       } u_dimy;
00107       u_dimy.base = 0;
00108       u_dimy.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00109       u_dimy.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00110       u_dimy.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00111       u_dimy.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00112       this->dimy = u_dimy.real;
00113       offset += sizeof(this->dimy);
00114       offset += this->relativepose.deserialize(inbuffer + offset);
00115       uint32_t length_savefilename;
00116       arrToVar(length_savefilename, (inbuffer + offset));
00117       offset += 4;
00118       for(unsigned int k= offset; k< offset+length_savefilename; ++k){
00119           inbuffer[k-1]=inbuffer[k];
00120       }
00121       inbuffer[offset+length_savefilename-1]=0;
00122       this->savefilename = (char *)(inbuffer + offset-1);
00123       offset += length_savefilename;
00124      return offset;
00125     }
00126 
00127     virtual const char * getType(){ return SETTEMPLATE; };
00128     virtual const char * getMD5(){ return "116fa80f27cbdfcd76d0b57a30ef79ec"; };
00129 
00130   };
00131 
00132   class SetTemplateResponse : public ros::Msg
00133   {
00134     public:
00135 
00136     SetTemplateResponse()
00137     {
00138     }
00139 
00140     virtual int serialize(unsigned char *outbuffer) const
00141     {
00142       int offset = 0;
00143       return offset;
00144     }
00145 
00146     virtual int deserialize(unsigned char *inbuffer)
00147     {
00148       int offset = 0;
00149      return offset;
00150     }
00151 
00152     virtual const char * getType(){ return SETTEMPLATE; };
00153     virtual const char * getMD5(){ return "d41d8cd98f00b204e9800998ecf8427e"; };
00154 
00155   };
00156 
00157   class SetTemplate {
00158     public:
00159     typedef SetTemplateRequest Request;
00160     typedef SetTemplateResponse Response;
00161   };
00162 
00163 }
00164 #endif