catchrobo2022
/
catchrobo2022_mbed
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: mbed
Embed:
(wiki syntax)
Show/hide line numbers
VariableArray.h
00001 #ifndef _ROS_roseus_VariableArray_h 00002 #define _ROS_roseus_VariableArray_h 00003 00004 #include <stdint.h> 00005 #include <string.h> 00006 #include <stdlib.h> 00007 #include "ros/msg.h" 00008 #include "ros/time.h" 00009 #include "ros/duration.h" 00010 #include "std_msgs/String.h" 00011 00012 namespace roseus 00013 { 00014 00015 class VariableArray : public ros::Msg 00016 { 00017 public: 00018 uint32_t float32_data_length; 00019 typedef float _float32_data_type; 00020 _float32_data_type st_float32_data; 00021 _float32_data_type * float32_data; 00022 uint32_t float64_data_length; 00023 typedef double _float64_data_type; 00024 _float64_data_type st_float64_data; 00025 _float64_data_type * float64_data; 00026 uint32_t int16_data_length; 00027 typedef int16_t _int16_data_type; 00028 _int16_data_type st_int16_data; 00029 _int16_data_type * int16_data; 00030 uint32_t int32_data_length; 00031 typedef int32_t _int32_data_type; 00032 _int32_data_type st_int32_data; 00033 _int32_data_type * int32_data; 00034 uint32_t int64_data_length; 00035 typedef int64_t _int64_data_type; 00036 _int64_data_type st_int64_data; 00037 _int64_data_type * int64_data; 00038 uint32_t int8_data_length; 00039 typedef int8_t _int8_data_type; 00040 _int8_data_type st_int8_data; 00041 _int8_data_type * int8_data; 00042 uint32_t uint16_data_length; 00043 typedef uint16_t _uint16_data_type; 00044 _uint16_data_type st_uint16_data; 00045 _uint16_data_type * uint16_data; 00046 uint32_t uint32_data_length; 00047 typedef uint32_t _uint32_data_type; 00048 _uint32_data_type st_uint32_data; 00049 _uint32_data_type * uint32_data; 00050 uint32_t uint64_data_length; 00051 typedef uint64_t _uint64_data_type; 00052 _uint64_data_type st_uint64_data; 00053 _uint64_data_type * uint64_data; 00054 uint32_t uint8_data_length; 00055 typedef uint8_t _uint8_data_type; 00056 _uint8_data_type st_uint8_data; 00057 _uint8_data_type * uint8_data; 00058 uint32_t bool_data_length; 00059 typedef bool _bool_data_type; 00060 _bool_data_type st_bool_data; 00061 _bool_data_type * bool_data; 00062 uint32_t time_data_length; 00063 typedef ros::Time _time_data_type; 00064 _time_data_type st_time_data; 00065 _time_data_type * time_data; 00066 uint32_t duration_data_length; 00067 typedef ros::Duration _duration_data_type; 00068 _duration_data_type st_duration_data; 00069 _duration_data_type * duration_data; 00070 uint32_t string_data_length; 00071 typedef std_msgs::String _string_data_type; 00072 _string_data_type st_string_data; 00073 _string_data_type * string_data; 00074 00075 VariableArray(): 00076 float32_data_length(0), float32_data(NULL), 00077 float64_data_length(0), float64_data(NULL), 00078 int16_data_length(0), int16_data(NULL), 00079 int32_data_length(0), int32_data(NULL), 00080 int64_data_length(0), int64_data(NULL), 00081 int8_data_length(0), int8_data(NULL), 00082 uint16_data_length(0), uint16_data(NULL), 00083 uint32_data_length(0), uint32_data(NULL), 00084 uint64_data_length(0), uint64_data(NULL), 00085 uint8_data_length(0), uint8_data(NULL), 00086 bool_data_length(0), bool_data(NULL), 00087 time_data_length(0), time_data(NULL), 00088 duration_data_length(0), duration_data(NULL), 00089 string_data_length(0), string_data(NULL) 00090 { 00091 } 00092 00093 virtual int serialize(unsigned char *outbuffer) const 00094 { 00095 int offset = 0; 00096 *(outbuffer + offset + 0) = (this->float32_data_length >> (8 * 0)) & 0xFF; 00097 *(outbuffer + offset + 1) = (this->float32_data_length >> (8 * 1)) & 0xFF; 00098 *(outbuffer + offset + 2) = (this->float32_data_length >> (8 * 2)) & 0xFF; 00099 *(outbuffer + offset + 3) = (this->float32_data_length >> (8 * 3)) & 0xFF; 00100 offset += sizeof(this->float32_data_length); 00101 for( uint32_t i = 0; i < float32_data_length; i++){ 00102 union { 00103 float real; 00104 uint32_t base; 00105 } u_float32_datai; 00106 u_float32_datai.real = this->float32_data[i]; 00107 *(outbuffer + offset + 0) = (u_float32_datai.base >> (8 * 0)) & 0xFF; 00108 *(outbuffer + offset + 1) = (u_float32_datai.base >> (8 * 1)) & 0xFF; 00109 *(outbuffer + offset + 2) = (u_float32_datai.base >> (8 * 2)) & 0xFF; 00110 *(outbuffer + offset + 3) = (u_float32_datai.base >> (8 * 3)) & 0xFF; 00111 offset += sizeof(this->float32_data[i]); 00112 } 00113 *(outbuffer + offset + 0) = (this->float64_data_length >> (8 * 0)) & 0xFF; 00114 *(outbuffer + offset + 1) = (this->float64_data_length >> (8 * 1)) & 0xFF; 00115 *(outbuffer + offset + 2) = (this->float64_data_length >> (8 * 2)) & 0xFF; 00116 *(outbuffer + offset + 3) = (this->float64_data_length >> (8 * 3)) & 0xFF; 00117 offset += sizeof(this->float64_data_length); 00118 for( uint32_t i = 0; i < float64_data_length; i++){ 00119 union { 00120 double real; 00121 uint64_t base; 00122 } u_float64_datai; 00123 u_float64_datai.real = this->float64_data[i]; 00124 *(outbuffer + offset + 0) = (u_float64_datai.base >> (8 * 0)) & 0xFF; 00125 *(outbuffer + offset + 1) = (u_float64_datai.base >> (8 * 1)) & 0xFF; 00126 *(outbuffer + offset + 2) = (u_float64_datai.base >> (8 * 2)) & 0xFF; 00127 *(outbuffer + offset + 3) = (u_float64_datai.base >> (8 * 3)) & 0xFF; 00128 *(outbuffer + offset + 4) = (u_float64_datai.base >> (8 * 4)) & 0xFF; 00129 *(outbuffer + offset + 5) = (u_float64_datai.base >> (8 * 5)) & 0xFF; 00130 *(outbuffer + offset + 6) = (u_float64_datai.base >> (8 * 6)) & 0xFF; 00131 *(outbuffer + offset + 7) = (u_float64_datai.base >> (8 * 7)) & 0xFF; 00132 offset += sizeof(this->float64_data[i]); 00133 } 00134 *(outbuffer + offset + 0) = (this->int16_data_length >> (8 * 0)) & 0xFF; 00135 *(outbuffer + offset + 1) = (this->int16_data_length >> (8 * 1)) & 0xFF; 00136 *(outbuffer + offset + 2) = (this->int16_data_length >> (8 * 2)) & 0xFF; 00137 *(outbuffer + offset + 3) = (this->int16_data_length >> (8 * 3)) & 0xFF; 00138 offset += sizeof(this->int16_data_length); 00139 for( uint32_t i = 0; i < int16_data_length; i++){ 00140 union { 00141 int16_t real; 00142 uint16_t base; 00143 } u_int16_datai; 00144 u_int16_datai.real = this->int16_data[i]; 00145 *(outbuffer + offset + 0) = (u_int16_datai.base >> (8 * 0)) & 0xFF; 00146 *(outbuffer + offset + 1) = (u_int16_datai.base >> (8 * 1)) & 0xFF; 00147 offset += sizeof(this->int16_data[i]); 00148 } 00149 *(outbuffer + offset + 0) = (this->int32_data_length >> (8 * 0)) & 0xFF; 00150 *(outbuffer + offset + 1) = (this->int32_data_length >> (8 * 1)) & 0xFF; 00151 *(outbuffer + offset + 2) = (this->int32_data_length >> (8 * 2)) & 0xFF; 00152 *(outbuffer + offset + 3) = (this->int32_data_length >> (8 * 3)) & 0xFF; 00153 offset += sizeof(this->int32_data_length); 00154 for( uint32_t i = 0; i < int32_data_length; i++){ 00155 union { 00156 int32_t real; 00157 uint32_t base; 00158 } u_int32_datai; 00159 u_int32_datai.real = this->int32_data[i]; 00160 *(outbuffer + offset + 0) = (u_int32_datai.base >> (8 * 0)) & 0xFF; 00161 *(outbuffer + offset + 1) = (u_int32_datai.base >> (8 * 1)) & 0xFF; 00162 *(outbuffer + offset + 2) = (u_int32_datai.base >> (8 * 2)) & 0xFF; 00163 *(outbuffer + offset + 3) = (u_int32_datai.base >> (8 * 3)) & 0xFF; 00164 offset += sizeof(this->int32_data[i]); 00165 } 00166 *(outbuffer + offset + 0) = (this->int64_data_length >> (8 * 0)) & 0xFF; 00167 *(outbuffer + offset + 1) = (this->int64_data_length >> (8 * 1)) & 0xFF; 00168 *(outbuffer + offset + 2) = (this->int64_data_length >> (8 * 2)) & 0xFF; 00169 *(outbuffer + offset + 3) = (this->int64_data_length >> (8 * 3)) & 0xFF; 00170 offset += sizeof(this->int64_data_length); 00171 for( uint32_t i = 0; i < int64_data_length; i++){ 00172 union { 00173 int64_t real; 00174 uint64_t base; 00175 } u_int64_datai; 00176 u_int64_datai.real = this->int64_data[i]; 00177 *(outbuffer + offset + 0) = (u_int64_datai.base >> (8 * 0)) & 0xFF; 00178 *(outbuffer + offset + 1) = (u_int64_datai.base >> (8 * 1)) & 0xFF; 00179 *(outbuffer + offset + 2) = (u_int64_datai.base >> (8 * 2)) & 0xFF; 00180 *(outbuffer + offset + 3) = (u_int64_datai.base >> (8 * 3)) & 0xFF; 00181 *(outbuffer + offset + 4) = (u_int64_datai.base >> (8 * 4)) & 0xFF; 00182 *(outbuffer + offset + 5) = (u_int64_datai.base >> (8 * 5)) & 0xFF; 00183 *(outbuffer + offset + 6) = (u_int64_datai.base >> (8 * 6)) & 0xFF; 00184 *(outbuffer + offset + 7) = (u_int64_datai.base >> (8 * 7)) & 0xFF; 00185 offset += sizeof(this->int64_data[i]); 00186 } 00187 *(outbuffer + offset + 0) = (this->int8_data_length >> (8 * 0)) & 0xFF; 00188 *(outbuffer + offset + 1) = (this->int8_data_length >> (8 * 1)) & 0xFF; 00189 *(outbuffer + offset + 2) = (this->int8_data_length >> (8 * 2)) & 0xFF; 00190 *(outbuffer + offset + 3) = (this->int8_data_length >> (8 * 3)) & 0xFF; 00191 offset += sizeof(this->int8_data_length); 00192 for( uint32_t i = 0; i < int8_data_length; i++){ 00193 union { 00194 int8_t real; 00195 uint8_t base; 00196 } u_int8_datai; 00197 u_int8_datai.real = this->int8_data[i]; 00198 *(outbuffer + offset + 0) = (u_int8_datai.base >> (8 * 0)) & 0xFF; 00199 offset += sizeof(this->int8_data[i]); 00200 } 00201 *(outbuffer + offset + 0) = (this->uint16_data_length >> (8 * 0)) & 0xFF; 00202 *(outbuffer + offset + 1) = (this->uint16_data_length >> (8 * 1)) & 0xFF; 00203 *(outbuffer + offset + 2) = (this->uint16_data_length >> (8 * 2)) & 0xFF; 00204 *(outbuffer + offset + 3) = (this->uint16_data_length >> (8 * 3)) & 0xFF; 00205 offset += sizeof(this->uint16_data_length); 00206 for( uint32_t i = 0; i < uint16_data_length; i++){ 00207 *(outbuffer + offset + 0) = (this->uint16_data[i] >> (8 * 0)) & 0xFF; 00208 *(outbuffer + offset + 1) = (this->uint16_data[i] >> (8 * 1)) & 0xFF; 00209 offset += sizeof(this->uint16_data[i]); 00210 } 00211 *(outbuffer + offset + 0) = (this->uint32_data_length >> (8 * 0)) & 0xFF; 00212 *(outbuffer + offset + 1) = (this->uint32_data_length >> (8 * 1)) & 0xFF; 00213 *(outbuffer + offset + 2) = (this->uint32_data_length >> (8 * 2)) & 0xFF; 00214 *(outbuffer + offset + 3) = (this->uint32_data_length >> (8 * 3)) & 0xFF; 00215 offset += sizeof(this->uint32_data_length); 00216 for( uint32_t i = 0; i < uint32_data_length; i++){ 00217 *(outbuffer + offset + 0) = (this->uint32_data[i] >> (8 * 0)) & 0xFF; 00218 *(outbuffer + offset + 1) = (this->uint32_data[i] >> (8 * 1)) & 0xFF; 00219 *(outbuffer + offset + 2) = (this->uint32_data[i] >> (8 * 2)) & 0xFF; 00220 *(outbuffer + offset + 3) = (this->uint32_data[i] >> (8 * 3)) & 0xFF; 00221 offset += sizeof(this->uint32_data[i]); 00222 } 00223 *(outbuffer + offset + 0) = (this->uint64_data_length >> (8 * 0)) & 0xFF; 00224 *(outbuffer + offset + 1) = (this->uint64_data_length >> (8 * 1)) & 0xFF; 00225 *(outbuffer + offset + 2) = (this->uint64_data_length >> (8 * 2)) & 0xFF; 00226 *(outbuffer + offset + 3) = (this->uint64_data_length >> (8 * 3)) & 0xFF; 00227 offset += sizeof(this->uint64_data_length); 00228 for( uint32_t i = 0; i < uint64_data_length; i++){ 00229 union { 00230 uint64_t real; 00231 uint32_t base; 00232 } u_uint64_datai; 00233 u_uint64_datai.real = this->uint64_data[i]; 00234 *(outbuffer + offset + 0) = (u_uint64_datai.base >> (8 * 0)) & 0xFF; 00235 *(outbuffer + offset + 1) = (u_uint64_datai.base >> (8 * 1)) & 0xFF; 00236 *(outbuffer + offset + 2) = (u_uint64_datai.base >> (8 * 2)) & 0xFF; 00237 *(outbuffer + offset + 3) = (u_uint64_datai.base >> (8 * 3)) & 0xFF; 00238 offset += sizeof(this->uint64_data[i]); 00239 } 00240 *(outbuffer + offset + 0) = (this->uint8_data_length >> (8 * 0)) & 0xFF; 00241 *(outbuffer + offset + 1) = (this->uint8_data_length >> (8 * 1)) & 0xFF; 00242 *(outbuffer + offset + 2) = (this->uint8_data_length >> (8 * 2)) & 0xFF; 00243 *(outbuffer + offset + 3) = (this->uint8_data_length >> (8 * 3)) & 0xFF; 00244 offset += sizeof(this->uint8_data_length); 00245 for( uint32_t i = 0; i < uint8_data_length; i++){ 00246 *(outbuffer + offset + 0) = (this->uint8_data[i] >> (8 * 0)) & 0xFF; 00247 offset += sizeof(this->uint8_data[i]); 00248 } 00249 *(outbuffer + offset + 0) = (this->bool_data_length >> (8 * 0)) & 0xFF; 00250 *(outbuffer + offset + 1) = (this->bool_data_length >> (8 * 1)) & 0xFF; 00251 *(outbuffer + offset + 2) = (this->bool_data_length >> (8 * 2)) & 0xFF; 00252 *(outbuffer + offset + 3) = (this->bool_data_length >> (8 * 3)) & 0xFF; 00253 offset += sizeof(this->bool_data_length); 00254 for( uint32_t i = 0; i < bool_data_length; i++){ 00255 union { 00256 bool real; 00257 uint8_t base; 00258 } u_bool_datai; 00259 u_bool_datai.real = this->bool_data[i]; 00260 *(outbuffer + offset + 0) = (u_bool_datai.base >> (8 * 0)) & 0xFF; 00261 offset += sizeof(this->bool_data[i]); 00262 } 00263 *(outbuffer + offset + 0) = (this->time_data_length >> (8 * 0)) & 0xFF; 00264 *(outbuffer + offset + 1) = (this->time_data_length >> (8 * 1)) & 0xFF; 00265 *(outbuffer + offset + 2) = (this->time_data_length >> (8 * 2)) & 0xFF; 00266 *(outbuffer + offset + 3) = (this->time_data_length >> (8 * 3)) & 0xFF; 00267 offset += sizeof(this->time_data_length); 00268 for( uint32_t i = 0; i < time_data_length; i++){ 00269 *(outbuffer + offset + 0) = (this->time_data[i].sec >> (8 * 0)) & 0xFF; 00270 *(outbuffer + offset + 1) = (this->time_data[i].sec >> (8 * 1)) & 0xFF; 00271 *(outbuffer + offset + 2) = (this->time_data[i].sec >> (8 * 2)) & 0xFF; 00272 *(outbuffer + offset + 3) = (this->time_data[i].sec >> (8 * 3)) & 0xFF; 00273 offset += sizeof(this->time_data[i].sec); 00274 *(outbuffer + offset + 0) = (this->time_data[i].nsec >> (8 * 0)) & 0xFF; 00275 *(outbuffer + offset + 1) = (this->time_data[i].nsec >> (8 * 1)) & 0xFF; 00276 *(outbuffer + offset + 2) = (this->time_data[i].nsec >> (8 * 2)) & 0xFF; 00277 *(outbuffer + offset + 3) = (this->time_data[i].nsec >> (8 * 3)) & 0xFF; 00278 offset += sizeof(this->time_data[i].nsec); 00279 } 00280 *(outbuffer + offset + 0) = (this->duration_data_length >> (8 * 0)) & 0xFF; 00281 *(outbuffer + offset + 1) = (this->duration_data_length >> (8 * 1)) & 0xFF; 00282 *(outbuffer + offset + 2) = (this->duration_data_length >> (8 * 2)) & 0xFF; 00283 *(outbuffer + offset + 3) = (this->duration_data_length >> (8 * 3)) & 0xFF; 00284 offset += sizeof(this->duration_data_length); 00285 for( uint32_t i = 0; i < duration_data_length; i++){ 00286 *(outbuffer + offset + 0) = (this->duration_data[i].sec >> (8 * 0)) & 0xFF; 00287 *(outbuffer + offset + 1) = (this->duration_data[i].sec >> (8 * 1)) & 0xFF; 00288 *(outbuffer + offset + 2) = (this->duration_data[i].sec >> (8 * 2)) & 0xFF; 00289 *(outbuffer + offset + 3) = (this->duration_data[i].sec >> (8 * 3)) & 0xFF; 00290 offset += sizeof(this->duration_data[i].sec); 00291 *(outbuffer + offset + 0) = (this->duration_data[i].nsec >> (8 * 0)) & 0xFF; 00292 *(outbuffer + offset + 1) = (this->duration_data[i].nsec >> (8 * 1)) & 0xFF; 00293 *(outbuffer + offset + 2) = (this->duration_data[i].nsec >> (8 * 2)) & 0xFF; 00294 *(outbuffer + offset + 3) = (this->duration_data[i].nsec >> (8 * 3)) & 0xFF; 00295 offset += sizeof(this->duration_data[i].nsec); 00296 } 00297 *(outbuffer + offset + 0) = (this->string_data_length >> (8 * 0)) & 0xFF; 00298 *(outbuffer + offset + 1) = (this->string_data_length >> (8 * 1)) & 0xFF; 00299 *(outbuffer + offset + 2) = (this->string_data_length >> (8 * 2)) & 0xFF; 00300 *(outbuffer + offset + 3) = (this->string_data_length >> (8 * 3)) & 0xFF; 00301 offset += sizeof(this->string_data_length); 00302 for( uint32_t i = 0; i < string_data_length; i++){ 00303 offset += this->string_data[i].serialize(outbuffer + offset); 00304 } 00305 return offset; 00306 } 00307 00308 virtual int deserialize(unsigned char *inbuffer) 00309 { 00310 int offset = 0; 00311 uint32_t float32_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00312 float32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00313 float32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00314 float32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00315 offset += sizeof(this->float32_data_length); 00316 if(float32_data_lengthT > float32_data_length) 00317 this->float32_data = (float*)realloc(this->float32_data, float32_data_lengthT * sizeof(float)); 00318 float32_data_length = float32_data_lengthT; 00319 for( uint32_t i = 0; i < float32_data_length; i++){ 00320 union { 00321 float real; 00322 uint32_t base; 00323 } u_st_float32_data; 00324 u_st_float32_data.base = 0; 00325 u_st_float32_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00326 u_st_float32_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00327 u_st_float32_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00328 u_st_float32_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00329 this->st_float32_data = u_st_float32_data.real; 00330 offset += sizeof(this->st_float32_data); 00331 memcpy( &(this->float32_data[i]), &(this->st_float32_data), sizeof(float)); 00332 } 00333 uint32_t float64_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00334 float64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00335 float64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00336 float64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00337 offset += sizeof(this->float64_data_length); 00338 if(float64_data_lengthT > float64_data_length) 00339 this->float64_data = (double*)realloc(this->float64_data, float64_data_lengthT * sizeof(double)); 00340 float64_data_length = float64_data_lengthT; 00341 for( uint32_t i = 0; i < float64_data_length; i++){ 00342 union { 00343 double real; 00344 uint64_t base; 00345 } u_st_float64_data; 00346 u_st_float64_data.base = 0; 00347 u_st_float64_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); 00348 u_st_float64_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); 00349 u_st_float64_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); 00350 u_st_float64_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); 00351 u_st_float64_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); 00352 u_st_float64_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); 00353 u_st_float64_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); 00354 u_st_float64_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); 00355 this->st_float64_data = u_st_float64_data.real; 00356 offset += sizeof(this->st_float64_data); 00357 memcpy( &(this->float64_data[i]), &(this->st_float64_data), sizeof(double)); 00358 } 00359 uint32_t int16_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00360 int16_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00361 int16_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00362 int16_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00363 offset += sizeof(this->int16_data_length); 00364 if(int16_data_lengthT > int16_data_length) 00365 this->int16_data = (int16_t*)realloc(this->int16_data, int16_data_lengthT * sizeof(int16_t)); 00366 int16_data_length = int16_data_lengthT; 00367 for( uint32_t i = 0; i < int16_data_length; i++){ 00368 union { 00369 int16_t real; 00370 uint16_t base; 00371 } u_st_int16_data; 00372 u_st_int16_data.base = 0; 00373 u_st_int16_data.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0); 00374 u_st_int16_data.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); 00375 this->st_int16_data = u_st_int16_data.real; 00376 offset += sizeof(this->st_int16_data); 00377 memcpy( &(this->int16_data[i]), &(this->st_int16_data), sizeof(int16_t)); 00378 } 00379 uint32_t int32_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00380 int32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00381 int32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00382 int32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00383 offset += sizeof(this->int32_data_length); 00384 if(int32_data_lengthT > int32_data_length) 00385 this->int32_data = (int32_t*)realloc(this->int32_data, int32_data_lengthT * sizeof(int32_t)); 00386 int32_data_length = int32_data_lengthT; 00387 for( uint32_t i = 0; i < int32_data_length; i++){ 00388 union { 00389 int32_t real; 00390 uint32_t base; 00391 } u_st_int32_data; 00392 u_st_int32_data.base = 0; 00393 u_st_int32_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00394 u_st_int32_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00395 u_st_int32_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00396 u_st_int32_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00397 this->st_int32_data = u_st_int32_data.real; 00398 offset += sizeof(this->st_int32_data); 00399 memcpy( &(this->int32_data[i]), &(this->st_int32_data), sizeof(int32_t)); 00400 } 00401 uint32_t int64_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00402 int64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00403 int64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00404 int64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00405 offset += sizeof(this->int64_data_length); 00406 if(int64_data_lengthT > int64_data_length) 00407 this->int64_data = (int64_t*)realloc(this->int64_data, int64_data_lengthT * sizeof(int64_t)); 00408 int64_data_length = int64_data_lengthT; 00409 for( uint32_t i = 0; i < int64_data_length; i++){ 00410 union { 00411 int64_t real; 00412 uint64_t base; 00413 } u_st_int64_data; 00414 u_st_int64_data.base = 0; 00415 u_st_int64_data.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0); 00416 u_st_int64_data.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1); 00417 u_st_int64_data.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2); 00418 u_st_int64_data.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3); 00419 u_st_int64_data.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4); 00420 u_st_int64_data.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5); 00421 u_st_int64_data.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6); 00422 u_st_int64_data.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7); 00423 this->st_int64_data = u_st_int64_data.real; 00424 offset += sizeof(this->st_int64_data); 00425 memcpy( &(this->int64_data[i]), &(this->st_int64_data), sizeof(int64_t)); 00426 } 00427 uint32_t int8_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00428 int8_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00429 int8_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00430 int8_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00431 offset += sizeof(this->int8_data_length); 00432 if(int8_data_lengthT > int8_data_length) 00433 this->int8_data = (int8_t*)realloc(this->int8_data, int8_data_lengthT * sizeof(int8_t)); 00434 int8_data_length = int8_data_lengthT; 00435 for( uint32_t i = 0; i < int8_data_length; i++){ 00436 union { 00437 int8_t real; 00438 uint8_t base; 00439 } u_st_int8_data; 00440 u_st_int8_data.base = 0; 00441 u_st_int8_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); 00442 this->st_int8_data = u_st_int8_data.real; 00443 offset += sizeof(this->st_int8_data); 00444 memcpy( &(this->int8_data[i]), &(this->st_int8_data), sizeof(int8_t)); 00445 } 00446 uint32_t uint16_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00447 uint16_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00448 uint16_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00449 uint16_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00450 offset += sizeof(this->uint16_data_length); 00451 if(uint16_data_lengthT > uint16_data_length) 00452 this->uint16_data = (uint16_t*)realloc(this->uint16_data, uint16_data_lengthT * sizeof(uint16_t)); 00453 uint16_data_length = uint16_data_lengthT; 00454 for( uint32_t i = 0; i < uint16_data_length; i++){ 00455 this->st_uint16_data = ((uint16_t) (*(inbuffer + offset))); 00456 this->st_uint16_data |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1); 00457 offset += sizeof(this->st_uint16_data); 00458 memcpy( &(this->uint16_data[i]), &(this->st_uint16_data), sizeof(uint16_t)); 00459 } 00460 uint32_t uint32_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00461 uint32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00462 uint32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00463 uint32_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00464 offset += sizeof(this->uint32_data_length); 00465 if(uint32_data_lengthT > uint32_data_length) 00466 this->uint32_data = (uint32_t*)realloc(this->uint32_data, uint32_data_lengthT * sizeof(uint32_t)); 00467 uint32_data_length = uint32_data_lengthT; 00468 for( uint32_t i = 0; i < uint32_data_length; i++){ 00469 this->st_uint32_data = ((uint32_t) (*(inbuffer + offset))); 00470 this->st_uint32_data |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00471 this->st_uint32_data |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00472 this->st_uint32_data |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00473 offset += sizeof(this->st_uint32_data); 00474 memcpy( &(this->uint32_data[i]), &(this->st_uint32_data), sizeof(uint32_t)); 00475 } 00476 uint32_t uint64_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00477 uint64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00478 uint64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00479 uint64_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00480 offset += sizeof(this->uint64_data_length); 00481 if(uint64_data_lengthT > uint64_data_length) 00482 this->uint64_data = (uint64_t*)realloc(this->uint64_data, uint64_data_lengthT * sizeof(uint64_t)); 00483 uint64_data_length = uint64_data_lengthT; 00484 for( uint32_t i = 0; i < uint64_data_length; i++){ 00485 union { 00486 uint64_t real; 00487 uint32_t base; 00488 } u_st_uint64_data; 00489 u_st_uint64_data.base = 0; 00490 u_st_uint64_data.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0); 00491 u_st_uint64_data.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00492 u_st_uint64_data.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00493 u_st_uint64_data.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00494 this->st_uint64_data = u_st_uint64_data.real; 00495 offset += sizeof(this->st_uint64_data); 00496 memcpy( &(this->uint64_data[i]), &(this->st_uint64_data), sizeof(uint64_t)); 00497 } 00498 uint32_t uint8_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00499 uint8_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00500 uint8_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00501 uint8_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00502 offset += sizeof(this->uint8_data_length); 00503 if(uint8_data_lengthT > uint8_data_length) 00504 this->uint8_data = (uint8_t*)realloc(this->uint8_data, uint8_data_lengthT * sizeof(uint8_t)); 00505 uint8_data_length = uint8_data_lengthT; 00506 for( uint32_t i = 0; i < uint8_data_length; i++){ 00507 this->st_uint8_data = ((uint8_t) (*(inbuffer + offset))); 00508 offset += sizeof(this->st_uint8_data); 00509 memcpy( &(this->uint8_data[i]), &(this->st_uint8_data), sizeof(uint8_t)); 00510 } 00511 uint32_t bool_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00512 bool_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00513 bool_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00514 bool_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00515 offset += sizeof(this->bool_data_length); 00516 if(bool_data_lengthT > bool_data_length) 00517 this->bool_data = (bool*)realloc(this->bool_data, bool_data_lengthT * sizeof(bool)); 00518 bool_data_length = bool_data_lengthT; 00519 for( uint32_t i = 0; i < bool_data_length; i++){ 00520 union { 00521 bool real; 00522 uint8_t base; 00523 } u_st_bool_data; 00524 u_st_bool_data.base = 0; 00525 u_st_bool_data.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0); 00526 this->st_bool_data = u_st_bool_data.real; 00527 offset += sizeof(this->st_bool_data); 00528 memcpy( &(this->bool_data[i]), &(this->st_bool_data), sizeof(bool)); 00529 } 00530 uint32_t time_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00531 time_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00532 time_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00533 time_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00534 offset += sizeof(this->time_data_length); 00535 if(time_data_lengthT > time_data_length) 00536 this->time_data = (ros::Time*)realloc(this->time_data, time_data_lengthT * sizeof(ros::Time)); 00537 time_data_length = time_data_lengthT; 00538 for( uint32_t i = 0; i < time_data_length; i++){ 00539 this->st_time_data.sec = ((uint32_t) (*(inbuffer + offset))); 00540 this->st_time_data.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00541 this->st_time_data.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00542 this->st_time_data.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00543 offset += sizeof(this->st_time_data.sec); 00544 this->st_time_data.nsec = ((uint32_t) (*(inbuffer + offset))); 00545 this->st_time_data.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00546 this->st_time_data.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00547 this->st_time_data.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00548 offset += sizeof(this->st_time_data.nsec); 00549 memcpy( &(this->time_data[i]), &(this->st_time_data), sizeof(ros::Time)); 00550 } 00551 uint32_t duration_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00552 duration_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00553 duration_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00554 duration_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00555 offset += sizeof(this->duration_data_length); 00556 if(duration_data_lengthT > duration_data_length) 00557 this->duration_data = (ros::Duration*)realloc(this->duration_data, duration_data_lengthT * sizeof(ros::Duration)); 00558 duration_data_length = duration_data_lengthT; 00559 for( uint32_t i = 0; i < duration_data_length; i++){ 00560 this->st_duration_data.sec = ((uint32_t) (*(inbuffer + offset))); 00561 this->st_duration_data.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00562 this->st_duration_data.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00563 this->st_duration_data.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00564 offset += sizeof(this->st_duration_data.sec); 00565 this->st_duration_data.nsec = ((uint32_t) (*(inbuffer + offset))); 00566 this->st_duration_data.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00567 this->st_duration_data.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00568 this->st_duration_data.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00569 offset += sizeof(this->st_duration_data.nsec); 00570 memcpy( &(this->duration_data[i]), &(this->st_duration_data), sizeof(ros::Duration)); 00571 } 00572 uint32_t string_data_lengthT = ((uint32_t) (*(inbuffer + offset))); 00573 string_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 00574 string_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 00575 string_data_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 00576 offset += sizeof(this->string_data_length); 00577 if(string_data_lengthT > string_data_length) 00578 this->string_data = (std_msgs::String*)realloc(this->string_data, string_data_lengthT * sizeof(std_msgs::String)); 00579 string_data_length = string_data_lengthT; 00580 for( uint32_t i = 0; i < string_data_length; i++){ 00581 offset += this->st_string_data.deserialize(inbuffer + offset); 00582 memcpy( &(this->string_data[i]), &(this->st_string_data), sizeof(std_msgs::String)); 00583 } 00584 return offset; 00585 } 00586 00587 virtual const char * getType(){ return "roseus/VariableArray"; }; 00588 virtual const char * getMD5(){ return "aebf8af723dcbdb6782481457d175157"; }; 00589 00590 }; 00591 00592 } 00593 #endif
Generated on Mon Sep 26 2022 13:47:04 by
1.7.2