FixedArray.h

00001 #ifndef _ROS_roseus_FixedArray_h
00002 #define _ROS_roseus_FixedArray_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 FixedArray : public ros::Msg
00016   {
00017     public:
00018       float float32_data[3];
00019       double float64_data[3];
00020       int16_t int16_data[3];
00021       int32_t int32_data[3];
00022       int64_t int64_data[3];
00023       int8_t int8_data[3];
00024       uint16_t uint16_data[3];
00025       uint32_t uint32_data[3];
00026       uint64_t uint64_data[3];
00027       uint8_t uint8_data[17];
00028       bool bool_data[2];
00029       ros::Time time_data[2];
00030       ros::Duration duration_data[2];
00031       std_msgs::String string_data[2];
00032 
00033     FixedArray():
00034       float32_data(),
00035       float64_data(),
00036       int16_data(),
00037       int32_data(),
00038       int64_data(),
00039       int8_data(),
00040       uint16_data(),
00041       uint32_data(),
00042       uint64_data(),
00043       uint8_data(),
00044       bool_data(),
00045       time_data(),
00046       duration_data(),
00047       string_data()
00048     {
00049     }
00050 
00051     virtual int serialize(unsigned char *outbuffer) const
00052     {
00053       int offset = 0;
00054       for( uint32_t i = 0; i < 3; i++){
00055       union {
00056         float real;
00057         uint32_t base;
00058       } u_float32_datai;
00059       u_float32_datai.real = this->float32_data[i];
00060       *(outbuffer + offset + 0) = (u_float32_datai.base >> (8 * 0)) & 0xFF;
00061       *(outbuffer + offset + 1) = (u_float32_datai.base >> (8 * 1)) & 0xFF;
00062       *(outbuffer + offset + 2) = (u_float32_datai.base >> (8 * 2)) & 0xFF;
00063       *(outbuffer + offset + 3) = (u_float32_datai.base >> (8 * 3)) & 0xFF;
00064       offset += sizeof(this->float32_data[i]);
00065       }
00066       for( uint32_t i = 0; i < 3; i++){
00067       union {
00068         double real;
00069         uint64_t base;
00070       } u_float64_datai;
00071       u_float64_datai.real = this->float64_data[i];
00072       *(outbuffer + offset + 0) = (u_float64_datai.base >> (8 * 0)) & 0xFF;
00073       *(outbuffer + offset + 1) = (u_float64_datai.base >> (8 * 1)) & 0xFF;
00074       *(outbuffer + offset + 2) = (u_float64_datai.base >> (8 * 2)) & 0xFF;
00075       *(outbuffer + offset + 3) = (u_float64_datai.base >> (8 * 3)) & 0xFF;
00076       *(outbuffer + offset + 4) = (u_float64_datai.base >> (8 * 4)) & 0xFF;
00077       *(outbuffer + offset + 5) = (u_float64_datai.base >> (8 * 5)) & 0xFF;
00078       *(outbuffer + offset + 6) = (u_float64_datai.base >> (8 * 6)) & 0xFF;
00079       *(outbuffer + offset + 7) = (u_float64_datai.base >> (8 * 7)) & 0xFF;
00080       offset += sizeof(this->float64_data[i]);
00081       }
00082       for( uint32_t i = 0; i < 3; i++){
00083       union {
00084         int16_t real;
00085         uint16_t base;
00086       } u_int16_datai;
00087       u_int16_datai.real = this->int16_data[i];
00088       *(outbuffer + offset + 0) = (u_int16_datai.base >> (8 * 0)) & 0xFF;
00089       *(outbuffer + offset + 1) = (u_int16_datai.base >> (8 * 1)) & 0xFF;
00090       offset += sizeof(this->int16_data[i]);
00091       }
00092       for( uint32_t i = 0; i < 3; i++){
00093       union {
00094         int32_t real;
00095         uint32_t base;
00096       } u_int32_datai;
00097       u_int32_datai.real = this->int32_data[i];
00098       *(outbuffer + offset + 0) = (u_int32_datai.base >> (8 * 0)) & 0xFF;
00099       *(outbuffer + offset + 1) = (u_int32_datai.base >> (8 * 1)) & 0xFF;
00100       *(outbuffer + offset + 2) = (u_int32_datai.base >> (8 * 2)) & 0xFF;
00101       *(outbuffer + offset + 3) = (u_int32_datai.base >> (8 * 3)) & 0xFF;
00102       offset += sizeof(this->int32_data[i]);
00103       }
00104       for( uint32_t i = 0; i < 3; i++){
00105       union {
00106         int64_t real;
00107         uint64_t base;
00108       } u_int64_datai;
00109       u_int64_datai.real = this->int64_data[i];
00110       *(outbuffer + offset + 0) = (u_int64_datai.base >> (8 * 0)) & 0xFF;
00111       *(outbuffer + offset + 1) = (u_int64_datai.base >> (8 * 1)) & 0xFF;
00112       *(outbuffer + offset + 2) = (u_int64_datai.base >> (8 * 2)) & 0xFF;
00113       *(outbuffer + offset + 3) = (u_int64_datai.base >> (8 * 3)) & 0xFF;
00114       *(outbuffer + offset + 4) = (u_int64_datai.base >> (8 * 4)) & 0xFF;
00115       *(outbuffer + offset + 5) = (u_int64_datai.base >> (8 * 5)) & 0xFF;
00116       *(outbuffer + offset + 6) = (u_int64_datai.base >> (8 * 6)) & 0xFF;
00117       *(outbuffer + offset + 7) = (u_int64_datai.base >> (8 * 7)) & 0xFF;
00118       offset += sizeof(this->int64_data[i]);
00119       }
00120       for( uint32_t i = 0; i < 3; i++){
00121       union {
00122         int8_t real;
00123         uint8_t base;
00124       } u_int8_datai;
00125       u_int8_datai.real = this->int8_data[i];
00126       *(outbuffer + offset + 0) = (u_int8_datai.base >> (8 * 0)) & 0xFF;
00127       offset += sizeof(this->int8_data[i]);
00128       }
00129       for( uint32_t i = 0; i < 3; i++){
00130       *(outbuffer + offset + 0) = (this->uint16_data[i] >> (8 * 0)) & 0xFF;
00131       *(outbuffer + offset + 1) = (this->uint16_data[i] >> (8 * 1)) & 0xFF;
00132       offset += sizeof(this->uint16_data[i]);
00133       }
00134       for( uint32_t i = 0; i < 3; i++){
00135       *(outbuffer + offset + 0) = (this->uint32_data[i] >> (8 * 0)) & 0xFF;
00136       *(outbuffer + offset + 1) = (this->uint32_data[i] >> (8 * 1)) & 0xFF;
00137       *(outbuffer + offset + 2) = (this->uint32_data[i] >> (8 * 2)) & 0xFF;
00138       *(outbuffer + offset + 3) = (this->uint32_data[i] >> (8 * 3)) & 0xFF;
00139       offset += sizeof(this->uint32_data[i]);
00140       }
00141       for( uint32_t i = 0; i < 3; i++){
00142       union {
00143         uint64_t real;
00144         uint32_t base;
00145       } u_uint64_datai;
00146       u_uint64_datai.real = this->uint64_data[i];
00147       *(outbuffer + offset + 0) = (u_uint64_datai.base >> (8 * 0)) & 0xFF;
00148       *(outbuffer + offset + 1) = (u_uint64_datai.base >> (8 * 1)) & 0xFF;
00149       *(outbuffer + offset + 2) = (u_uint64_datai.base >> (8 * 2)) & 0xFF;
00150       *(outbuffer + offset + 3) = (u_uint64_datai.base >> (8 * 3)) & 0xFF;
00151       offset += sizeof(this->uint64_data[i]);
00152       }
00153       for( uint32_t i = 0; i < 17; i++){
00154       *(outbuffer + offset + 0) = (this->uint8_data[i] >> (8 * 0)) & 0xFF;
00155       offset += sizeof(this->uint8_data[i]);
00156       }
00157       for( uint32_t i = 0; i < 2; i++){
00158       union {
00159         bool real;
00160         uint8_t base;
00161       } u_bool_datai;
00162       u_bool_datai.real = this->bool_data[i];
00163       *(outbuffer + offset + 0) = (u_bool_datai.base >> (8 * 0)) & 0xFF;
00164       offset += sizeof(this->bool_data[i]);
00165       }
00166       for( uint32_t i = 0; i < 2; i++){
00167       *(outbuffer + offset + 0) = (this->time_data[i].sec >> (8 * 0)) & 0xFF;
00168       *(outbuffer + offset + 1) = (this->time_data[i].sec >> (8 * 1)) & 0xFF;
00169       *(outbuffer + offset + 2) = (this->time_data[i].sec >> (8 * 2)) & 0xFF;
00170       *(outbuffer + offset + 3) = (this->time_data[i].sec >> (8 * 3)) & 0xFF;
00171       offset += sizeof(this->time_data[i].sec);
00172       *(outbuffer + offset + 0) = (this->time_data[i].nsec >> (8 * 0)) & 0xFF;
00173       *(outbuffer + offset + 1) = (this->time_data[i].nsec >> (8 * 1)) & 0xFF;
00174       *(outbuffer + offset + 2) = (this->time_data[i].nsec >> (8 * 2)) & 0xFF;
00175       *(outbuffer + offset + 3) = (this->time_data[i].nsec >> (8 * 3)) & 0xFF;
00176       offset += sizeof(this->time_data[i].nsec);
00177       }
00178       for( uint32_t i = 0; i < 2; i++){
00179       *(outbuffer + offset + 0) = (this->duration_data[i].sec >> (8 * 0)) & 0xFF;
00180       *(outbuffer + offset + 1) = (this->duration_data[i].sec >> (8 * 1)) & 0xFF;
00181       *(outbuffer + offset + 2) = (this->duration_data[i].sec >> (8 * 2)) & 0xFF;
00182       *(outbuffer + offset + 3) = (this->duration_data[i].sec >> (8 * 3)) & 0xFF;
00183       offset += sizeof(this->duration_data[i].sec);
00184       *(outbuffer + offset + 0) = (this->duration_data[i].nsec >> (8 * 0)) & 0xFF;
00185       *(outbuffer + offset + 1) = (this->duration_data[i].nsec >> (8 * 1)) & 0xFF;
00186       *(outbuffer + offset + 2) = (this->duration_data[i].nsec >> (8 * 2)) & 0xFF;
00187       *(outbuffer + offset + 3) = (this->duration_data[i].nsec >> (8 * 3)) & 0xFF;
00188       offset += sizeof(this->duration_data[i].nsec);
00189       }
00190       for( uint32_t i = 0; i < 2; i++){
00191       offset += this->string_data[i].serialize(outbuffer + offset);
00192       }
00193       return offset;
00194     }
00195 
00196     virtual int deserialize(unsigned char *inbuffer)
00197     {
00198       int offset = 0;
00199       for( uint32_t i = 0; i < 3; i++){
00200       union {
00201         float real;
00202         uint32_t base;
00203       } u_float32_datai;
00204       u_float32_datai.base = 0;
00205       u_float32_datai.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00206       u_float32_datai.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00207       u_float32_datai.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00208       u_float32_datai.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00209       this->float32_data[i] = u_float32_datai.real;
00210       offset += sizeof(this->float32_data[i]);
00211       }
00212       for( uint32_t i = 0; i < 3; i++){
00213       union {
00214         double real;
00215         uint64_t base;
00216       } u_float64_datai;
00217       u_float64_datai.base = 0;
00218       u_float64_datai.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00219       u_float64_datai.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00220       u_float64_datai.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00221       u_float64_datai.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00222       u_float64_datai.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00223       u_float64_datai.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00224       u_float64_datai.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00225       u_float64_datai.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00226       this->float64_data[i] = u_float64_datai.real;
00227       offset += sizeof(this->float64_data[i]);
00228       }
00229       for( uint32_t i = 0; i < 3; i++){
00230       union {
00231         int16_t real;
00232         uint16_t base;
00233       } u_int16_datai;
00234       u_int16_datai.base = 0;
00235       u_int16_datai.base |= ((uint16_t) (*(inbuffer + offset + 0))) << (8 * 0);
00236       u_int16_datai.base |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
00237       this->int16_data[i] = u_int16_datai.real;
00238       offset += sizeof(this->int16_data[i]);
00239       }
00240       for( uint32_t i = 0; i < 3; i++){
00241       union {
00242         int32_t real;
00243         uint32_t base;
00244       } u_int32_datai;
00245       u_int32_datai.base = 0;
00246       u_int32_datai.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00247       u_int32_datai.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00248       u_int32_datai.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00249       u_int32_datai.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00250       this->int32_data[i] = u_int32_datai.real;
00251       offset += sizeof(this->int32_data[i]);
00252       }
00253       for( uint32_t i = 0; i < 3; i++){
00254       union {
00255         int64_t real;
00256         uint64_t base;
00257       } u_int64_datai;
00258       u_int64_datai.base = 0;
00259       u_int64_datai.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00260       u_int64_datai.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00261       u_int64_datai.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00262       u_int64_datai.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00263       u_int64_datai.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00264       u_int64_datai.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00265       u_int64_datai.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00266       u_int64_datai.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00267       this->int64_data[i] = u_int64_datai.real;
00268       offset += sizeof(this->int64_data[i]);
00269       }
00270       for( uint32_t i = 0; i < 3; i++){
00271       union {
00272         int8_t real;
00273         uint8_t base;
00274       } u_int8_datai;
00275       u_int8_datai.base = 0;
00276       u_int8_datai.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00277       this->int8_data[i] = u_int8_datai.real;
00278       offset += sizeof(this->int8_data[i]);
00279       }
00280       for( uint32_t i = 0; i < 3; i++){
00281       this->uint16_data[i] =  ((uint16_t) (*(inbuffer + offset)));
00282       this->uint16_data[i] |= ((uint16_t) (*(inbuffer + offset + 1))) << (8 * 1);
00283       offset += sizeof(this->uint16_data[i]);
00284       }
00285       for( uint32_t i = 0; i < 3; i++){
00286       this->uint32_data[i] =  ((uint32_t) (*(inbuffer + offset)));
00287       this->uint32_data[i] |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00288       this->uint32_data[i] |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00289       this->uint32_data[i] |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00290       offset += sizeof(this->uint32_data[i]);
00291       }
00292       for( uint32_t i = 0; i < 3; i++){
00293       union {
00294         uint64_t real;
00295         uint32_t base;
00296       } u_uint64_datai;
00297       u_uint64_datai.base = 0;
00298       u_uint64_datai.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00299       u_uint64_datai.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00300       u_uint64_datai.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00301       u_uint64_datai.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00302       this->uint64_data[i] = u_uint64_datai.real;
00303       offset += sizeof(this->uint64_data[i]);
00304       }
00305       for( uint32_t i = 0; i < 17; i++){
00306       this->uint8_data[i] =  ((uint8_t) (*(inbuffer + offset)));
00307       offset += sizeof(this->uint8_data[i]);
00308       }
00309       for( uint32_t i = 0; i < 2; i++){
00310       union {
00311         bool real;
00312         uint8_t base;
00313       } u_bool_datai;
00314       u_bool_datai.base = 0;
00315       u_bool_datai.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00316       this->bool_data[i] = u_bool_datai.real;
00317       offset += sizeof(this->bool_data[i]);
00318       }
00319       for( uint32_t i = 0; i < 2; i++){
00320       this->time_data[i].sec =  ((uint32_t) (*(inbuffer + offset)));
00321       this->time_data[i].sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00322       this->time_data[i].sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00323       this->time_data[i].sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00324       offset += sizeof(this->time_data[i].sec);
00325       this->time_data[i].nsec =  ((uint32_t) (*(inbuffer + offset)));
00326       this->time_data[i].nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00327       this->time_data[i].nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00328       this->time_data[i].nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00329       offset += sizeof(this->time_data[i].nsec);
00330       }
00331       for( uint32_t i = 0; i < 2; i++){
00332       this->duration_data[i].sec =  ((uint32_t) (*(inbuffer + offset)));
00333       this->duration_data[i].sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00334       this->duration_data[i].sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00335       this->duration_data[i].sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00336       offset += sizeof(this->duration_data[i].sec);
00337       this->duration_data[i].nsec =  ((uint32_t) (*(inbuffer + offset)));
00338       this->duration_data[i].nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00339       this->duration_data[i].nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00340       this->duration_data[i].nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00341       offset += sizeof(this->duration_data[i].nsec);
00342       }
00343       for( uint32_t i = 0; i < 2; i++){
00344       offset += this->string_data[i].deserialize(inbuffer + offset);
00345       }
00346      return offset;
00347     }
00348 
00349     virtual const char * getType(){ return "roseus/FixedArray"; };
00350     virtual const char * getMD5(){ return "6b30ccf11bc7409743664778a763a8c9"; };
00351 
00352   };
00353 
00354 }
00355 #endif