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