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