RequestParam.h

00001 #ifndef _ROS_SERVICE_RequestParam_h
00002 #define _ROS_SERVICE_RequestParam_h
00003 #include <stdint.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include "ros/msg.h"
00007 
00008 namespace rosserial_msgs
00009 {
00010 
00011 static const char REQUESTPARAM[] = "rosserial_msgs/RequestParam";
00012 
00013   class RequestParamRequest : public ros::Msg
00014   {
00015     public:
00016       const char* name;
00017 
00018     RequestParamRequest():
00019       name("")
00020     {
00021     }
00022 
00023     virtual int serialize(unsigned char *outbuffer) const
00024     {
00025       int offset = 0;
00026       uint32_t length_name = strlen(this->name);
00027       memcpy(outbuffer + offset, &length_name, sizeof(uint32_t));
00028       offset += 4;
00029       memcpy(outbuffer + offset, this->name, length_name);
00030       offset += length_name;
00031       return offset;
00032     }
00033 
00034     virtual int deserialize(unsigned char *inbuffer)
00035     {
00036       int offset = 0;
00037       uint32_t length_name;
00038       memcpy(&length_name, (inbuffer + offset), sizeof(uint32_t));
00039       offset += 4;
00040       for(unsigned int k= offset; k< offset+length_name; ++k){
00041           inbuffer[k-1]=inbuffer[k];
00042       }
00043       inbuffer[offset+length_name-1]=0;
00044       this->name = (char *)(inbuffer + offset-1);
00045       offset += length_name;
00046      return offset;
00047     }
00048 
00049     const char * getType(){ return REQUESTPARAM; };
00050     const char * getMD5(){ return "c1f3d28f1b044c871e6eff2e9fc3c667"; };
00051 
00052   };
00053 
00054   class RequestParamResponse : public ros::Msg
00055   {
00056     public:
00057       uint8_t ints_length;
00058       int32_t st_ints;
00059       int32_t * ints;
00060       uint8_t floats_length;
00061       float st_floats;
00062       float * floats;
00063       uint8_t strings_length;
00064       char* st_strings;
00065       char* * strings;
00066 
00067     RequestParamResponse():
00068       ints_length(0), ints(NULL),
00069       floats_length(0), floats(NULL),
00070       strings_length(0), strings(NULL)
00071     {
00072     }
00073 
00074     virtual int serialize(unsigned char *outbuffer) const
00075     {
00076       int offset = 0;
00077       *(outbuffer + offset++) = ints_length;
00078       *(outbuffer + offset++) = 0;
00079       *(outbuffer + offset++) = 0;
00080       *(outbuffer + offset++) = 0;
00081       for( uint8_t i = 0; i < ints_length; i++){
00082       union {
00083         int32_t real;
00084         uint32_t base;
00085       } u_intsi;
00086       u_intsi.real = this->ints[i];
00087       *(outbuffer + offset + 0) = (u_intsi.base >> (8 * 0)) & 0xFF;
00088       *(outbuffer + offset + 1) = (u_intsi.base >> (8 * 1)) & 0xFF;
00089       *(outbuffer + offset + 2) = (u_intsi.base >> (8 * 2)) & 0xFF;
00090       *(outbuffer + offset + 3) = (u_intsi.base >> (8 * 3)) & 0xFF;
00091       offset += sizeof(this->ints[i]);
00092       }
00093       *(outbuffer + offset++) = floats_length;
00094       *(outbuffer + offset++) = 0;
00095       *(outbuffer + offset++) = 0;
00096       *(outbuffer + offset++) = 0;
00097       for( uint8_t i = 0; i < floats_length; i++){
00098       union {
00099         float real;
00100         uint32_t base;
00101       } u_floatsi;
00102       u_floatsi.real = this->floats[i];
00103       *(outbuffer + offset + 0) = (u_floatsi.base >> (8 * 0)) & 0xFF;
00104       *(outbuffer + offset + 1) = (u_floatsi.base >> (8 * 1)) & 0xFF;
00105       *(outbuffer + offset + 2) = (u_floatsi.base >> (8 * 2)) & 0xFF;
00106       *(outbuffer + offset + 3) = (u_floatsi.base >> (8 * 3)) & 0xFF;
00107       offset += sizeof(this->floats[i]);
00108       }
00109       *(outbuffer + offset++) = strings_length;
00110       *(outbuffer + offset++) = 0;
00111       *(outbuffer + offset++) = 0;
00112       *(outbuffer + offset++) = 0;
00113       for( uint8_t i = 0; i < strings_length; i++){
00114       uint32_t length_stringsi = strlen(this->strings[i]);
00115       memcpy(outbuffer + offset, &length_stringsi, sizeof(uint32_t));
00116       offset += 4;
00117       memcpy(outbuffer + offset, this->strings[i], length_stringsi);
00118       offset += length_stringsi;
00119       }
00120       return offset;
00121     }
00122 
00123     virtual int deserialize(unsigned char *inbuffer)
00124     {
00125       int offset = 0;
00126       uint8_t ints_lengthT = *(inbuffer + offset++);
00127       if(ints_lengthT > ints_length)
00128         this->ints = (int32_t*)realloc(this->ints, ints_lengthT * sizeof(int32_t));
00129       offset += 3;
00130       ints_length = ints_lengthT;
00131       for( uint8_t i = 0; i < ints_length; i++){
00132       union {
00133         int32_t real;
00134         uint32_t base;
00135       } u_st_ints;
00136       u_st_ints.base = 0;
00137       u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00138       u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00139       u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00140       u_st_ints.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00141       this->st_ints = u_st_ints.real;
00142       offset += sizeof(this->st_ints);
00143         memcpy( &(this->ints[i]), &(this->st_ints), sizeof(int32_t));
00144       }
00145       uint8_t floats_lengthT = *(inbuffer + offset++);
00146       if(floats_lengthT > floats_length)
00147         this->floats = (float*)realloc(this->floats, floats_lengthT * sizeof(float));
00148       offset += 3;
00149       floats_length = floats_lengthT;
00150       for( uint8_t i = 0; i < floats_length; i++){
00151       union {
00152         float real;
00153         uint32_t base;
00154       } u_st_floats;
00155       u_st_floats.base = 0;
00156       u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00157       u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00158       u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00159       u_st_floats.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00160       this->st_floats = u_st_floats.real;
00161       offset += sizeof(this->st_floats);
00162         memcpy( &(this->floats[i]), &(this->st_floats), sizeof(float));
00163       }
00164       uint8_t strings_lengthT = *(inbuffer + offset++);
00165       if(strings_lengthT > strings_length)
00166         this->strings = (char**)realloc(this->strings, strings_lengthT * sizeof(char*));
00167       offset += 3;
00168       strings_length = strings_lengthT;
00169       for( uint8_t i = 0; i < strings_length; i++){
00170       uint32_t length_st_strings;
00171       memcpy(&length_st_strings, (inbuffer + offset), sizeof(uint32_t));
00172       offset += 4;
00173       for(unsigned int k= offset; k< offset+length_st_strings; ++k){
00174           inbuffer[k-1]=inbuffer[k];
00175       }
00176       inbuffer[offset+length_st_strings-1]=0;
00177       this->st_strings = (char *)(inbuffer + offset-1);
00178       offset += length_st_strings;
00179         memcpy( &(this->strings[i]), &(this->st_strings), sizeof(char*));
00180       }
00181      return offset;
00182     }
00183 
00184     const char * getType(){ return REQUESTPARAM; };
00185     const char * getMD5(){ return "9f0e98bda65981986ddf53afa7a40e49"; };
00186 
00187   };
00188 
00189   class RequestParam {
00190     public:
00191     typedef RequestParamRequest Request;
00192     typedef RequestParamResponse Response;
00193   };
00194 
00195 }
00196 #endif