Working towards recieving twists

Dependencies:   BufferedSerial

Fork of ros_lib_kinetic by Gary Servin

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers GetLinkProperties.h Source File

GetLinkProperties.h

00001 #ifndef _ROS_SERVICE_GetLinkProperties_h
00002 #define _ROS_SERVICE_GetLinkProperties_h
00003 #include <stdint.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include "ros/msg.h"
00007 #include "geometry_msgs/Pose.h"
00008 
00009 namespace gazebo_msgs
00010 {
00011 
00012 static const char GETLINKPROPERTIES[] = "gazebo_msgs/GetLinkProperties";
00013 
00014   class GetLinkPropertiesRequest : public ros::Msg
00015   {
00016     public:
00017       typedef const char* _link_name_type;
00018       _link_name_type link_name;
00019 
00020     GetLinkPropertiesRequest():
00021       link_name("")
00022     {
00023     }
00024 
00025     virtual int serialize(unsigned char *outbuffer) const
00026     {
00027       int offset = 0;
00028       uint32_t length_link_name = strlen(this->link_name);
00029       varToArr(outbuffer + offset, length_link_name);
00030       offset += 4;
00031       memcpy(outbuffer + offset, this->link_name, length_link_name);
00032       offset += length_link_name;
00033       return offset;
00034     }
00035 
00036     virtual int deserialize(unsigned char *inbuffer)
00037     {
00038       int offset = 0;
00039       uint32_t length_link_name;
00040       arrToVar(length_link_name, (inbuffer + offset));
00041       offset += 4;
00042       for(unsigned int k= offset; k< offset+length_link_name; ++k){
00043           inbuffer[k-1]=inbuffer[k];
00044       }
00045       inbuffer[offset+length_link_name-1]=0;
00046       this->link_name = (char *)(inbuffer + offset-1);
00047       offset += length_link_name;
00048      return offset;
00049     }
00050 
00051     const char * getType(){ return GETLINKPROPERTIES; };
00052     const char * getMD5(){ return "7d82d60381f1b66a30f2157f60884345"; };
00053 
00054   };
00055 
00056   class GetLinkPropertiesResponse : public ros::Msg
00057   {
00058     public:
00059       typedef geometry_msgs::Pose _com_type;
00060       _com_type com;
00061       typedef bool _gravity_mode_type;
00062       _gravity_mode_type gravity_mode;
00063       typedef double _mass_type;
00064       _mass_type mass;
00065       typedef double _ixx_type;
00066       _ixx_type ixx;
00067       typedef double _ixy_type;
00068       _ixy_type ixy;
00069       typedef double _ixz_type;
00070       _ixz_type ixz;
00071       typedef double _iyy_type;
00072       _iyy_type iyy;
00073       typedef double _iyz_type;
00074       _iyz_type iyz;
00075       typedef double _izz_type;
00076       _izz_type izz;
00077       typedef bool _success_type;
00078       _success_type success;
00079       typedef const char* _status_message_type;
00080       _status_message_type status_message;
00081 
00082     GetLinkPropertiesResponse():
00083       com(),
00084       gravity_mode(0),
00085       mass(0),
00086       ixx(0),
00087       ixy(0),
00088       ixz(0),
00089       iyy(0),
00090       iyz(0),
00091       izz(0),
00092       success(0),
00093       status_message("")
00094     {
00095     }
00096 
00097     virtual int serialize(unsigned char *outbuffer) const
00098     {
00099       int offset = 0;
00100       offset += this->com.serialize(outbuffer + offset);
00101       union {
00102         bool real;
00103         uint8_t base;
00104       } u_gravity_mode;
00105       u_gravity_mode.real = this->gravity_mode;
00106       *(outbuffer + offset + 0) = (u_gravity_mode.base >> (8 * 0)) & 0xFF;
00107       offset += sizeof(this->gravity_mode);
00108       union {
00109         double real;
00110         uint64_t base;
00111       } u_mass;
00112       u_mass.real = this->mass;
00113       *(outbuffer + offset + 0) = (u_mass.base >> (8 * 0)) & 0xFF;
00114       *(outbuffer + offset + 1) = (u_mass.base >> (8 * 1)) & 0xFF;
00115       *(outbuffer + offset + 2) = (u_mass.base >> (8 * 2)) & 0xFF;
00116       *(outbuffer + offset + 3) = (u_mass.base >> (8 * 3)) & 0xFF;
00117       *(outbuffer + offset + 4) = (u_mass.base >> (8 * 4)) & 0xFF;
00118       *(outbuffer + offset + 5) = (u_mass.base >> (8 * 5)) & 0xFF;
00119       *(outbuffer + offset + 6) = (u_mass.base >> (8 * 6)) & 0xFF;
00120       *(outbuffer + offset + 7) = (u_mass.base >> (8 * 7)) & 0xFF;
00121       offset += sizeof(this->mass);
00122       union {
00123         double real;
00124         uint64_t base;
00125       } u_ixx;
00126       u_ixx.real = this->ixx;
00127       *(outbuffer + offset + 0) = (u_ixx.base >> (8 * 0)) & 0xFF;
00128       *(outbuffer + offset + 1) = (u_ixx.base >> (8 * 1)) & 0xFF;
00129       *(outbuffer + offset + 2) = (u_ixx.base >> (8 * 2)) & 0xFF;
00130       *(outbuffer + offset + 3) = (u_ixx.base >> (8 * 3)) & 0xFF;
00131       *(outbuffer + offset + 4) = (u_ixx.base >> (8 * 4)) & 0xFF;
00132       *(outbuffer + offset + 5) = (u_ixx.base >> (8 * 5)) & 0xFF;
00133       *(outbuffer + offset + 6) = (u_ixx.base >> (8 * 6)) & 0xFF;
00134       *(outbuffer + offset + 7) = (u_ixx.base >> (8 * 7)) & 0xFF;
00135       offset += sizeof(this->ixx);
00136       union {
00137         double real;
00138         uint64_t base;
00139       } u_ixy;
00140       u_ixy.real = this->ixy;
00141       *(outbuffer + offset + 0) = (u_ixy.base >> (8 * 0)) & 0xFF;
00142       *(outbuffer + offset + 1) = (u_ixy.base >> (8 * 1)) & 0xFF;
00143       *(outbuffer + offset + 2) = (u_ixy.base >> (8 * 2)) & 0xFF;
00144       *(outbuffer + offset + 3) = (u_ixy.base >> (8 * 3)) & 0xFF;
00145       *(outbuffer + offset + 4) = (u_ixy.base >> (8 * 4)) & 0xFF;
00146       *(outbuffer + offset + 5) = (u_ixy.base >> (8 * 5)) & 0xFF;
00147       *(outbuffer + offset + 6) = (u_ixy.base >> (8 * 6)) & 0xFF;
00148       *(outbuffer + offset + 7) = (u_ixy.base >> (8 * 7)) & 0xFF;
00149       offset += sizeof(this->ixy);
00150       union {
00151         double real;
00152         uint64_t base;
00153       } u_ixz;
00154       u_ixz.real = this->ixz;
00155       *(outbuffer + offset + 0) = (u_ixz.base >> (8 * 0)) & 0xFF;
00156       *(outbuffer + offset + 1) = (u_ixz.base >> (8 * 1)) & 0xFF;
00157       *(outbuffer + offset + 2) = (u_ixz.base >> (8 * 2)) & 0xFF;
00158       *(outbuffer + offset + 3) = (u_ixz.base >> (8 * 3)) & 0xFF;
00159       *(outbuffer + offset + 4) = (u_ixz.base >> (8 * 4)) & 0xFF;
00160       *(outbuffer + offset + 5) = (u_ixz.base >> (8 * 5)) & 0xFF;
00161       *(outbuffer + offset + 6) = (u_ixz.base >> (8 * 6)) & 0xFF;
00162       *(outbuffer + offset + 7) = (u_ixz.base >> (8 * 7)) & 0xFF;
00163       offset += sizeof(this->ixz);
00164       union {
00165         double real;
00166         uint64_t base;
00167       } u_iyy;
00168       u_iyy.real = this->iyy;
00169       *(outbuffer + offset + 0) = (u_iyy.base >> (8 * 0)) & 0xFF;
00170       *(outbuffer + offset + 1) = (u_iyy.base >> (8 * 1)) & 0xFF;
00171       *(outbuffer + offset + 2) = (u_iyy.base >> (8 * 2)) & 0xFF;
00172       *(outbuffer + offset + 3) = (u_iyy.base >> (8 * 3)) & 0xFF;
00173       *(outbuffer + offset + 4) = (u_iyy.base >> (8 * 4)) & 0xFF;
00174       *(outbuffer + offset + 5) = (u_iyy.base >> (8 * 5)) & 0xFF;
00175       *(outbuffer + offset + 6) = (u_iyy.base >> (8 * 6)) & 0xFF;
00176       *(outbuffer + offset + 7) = (u_iyy.base >> (8 * 7)) & 0xFF;
00177       offset += sizeof(this->iyy);
00178       union {
00179         double real;
00180         uint64_t base;
00181       } u_iyz;
00182       u_iyz.real = this->iyz;
00183       *(outbuffer + offset + 0) = (u_iyz.base >> (8 * 0)) & 0xFF;
00184       *(outbuffer + offset + 1) = (u_iyz.base >> (8 * 1)) & 0xFF;
00185       *(outbuffer + offset + 2) = (u_iyz.base >> (8 * 2)) & 0xFF;
00186       *(outbuffer + offset + 3) = (u_iyz.base >> (8 * 3)) & 0xFF;
00187       *(outbuffer + offset + 4) = (u_iyz.base >> (8 * 4)) & 0xFF;
00188       *(outbuffer + offset + 5) = (u_iyz.base >> (8 * 5)) & 0xFF;
00189       *(outbuffer + offset + 6) = (u_iyz.base >> (8 * 6)) & 0xFF;
00190       *(outbuffer + offset + 7) = (u_iyz.base >> (8 * 7)) & 0xFF;
00191       offset += sizeof(this->iyz);
00192       union {
00193         double real;
00194         uint64_t base;
00195       } u_izz;
00196       u_izz.real = this->izz;
00197       *(outbuffer + offset + 0) = (u_izz.base >> (8 * 0)) & 0xFF;
00198       *(outbuffer + offset + 1) = (u_izz.base >> (8 * 1)) & 0xFF;
00199       *(outbuffer + offset + 2) = (u_izz.base >> (8 * 2)) & 0xFF;
00200       *(outbuffer + offset + 3) = (u_izz.base >> (8 * 3)) & 0xFF;
00201       *(outbuffer + offset + 4) = (u_izz.base >> (8 * 4)) & 0xFF;
00202       *(outbuffer + offset + 5) = (u_izz.base >> (8 * 5)) & 0xFF;
00203       *(outbuffer + offset + 6) = (u_izz.base >> (8 * 6)) & 0xFF;
00204       *(outbuffer + offset + 7) = (u_izz.base >> (8 * 7)) & 0xFF;
00205       offset += sizeof(this->izz);
00206       union {
00207         bool real;
00208         uint8_t base;
00209       } u_success;
00210       u_success.real = this->success;
00211       *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
00212       offset += sizeof(this->success);
00213       uint32_t length_status_message = strlen(this->status_message);
00214       varToArr(outbuffer + offset, length_status_message);
00215       offset += 4;
00216       memcpy(outbuffer + offset, this->status_message, length_status_message);
00217       offset += length_status_message;
00218       return offset;
00219     }
00220 
00221     virtual int deserialize(unsigned char *inbuffer)
00222     {
00223       int offset = 0;
00224       offset += this->com.deserialize(inbuffer + offset);
00225       union {
00226         bool real;
00227         uint8_t base;
00228       } u_gravity_mode;
00229       u_gravity_mode.base = 0;
00230       u_gravity_mode.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00231       this->gravity_mode = u_gravity_mode.real;
00232       offset += sizeof(this->gravity_mode);
00233       union {
00234         double real;
00235         uint64_t base;
00236       } u_mass;
00237       u_mass.base = 0;
00238       u_mass.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00239       u_mass.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00240       u_mass.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00241       u_mass.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00242       u_mass.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00243       u_mass.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00244       u_mass.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00245       u_mass.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00246       this->mass = u_mass.real;
00247       offset += sizeof(this->mass);
00248       union {
00249         double real;
00250         uint64_t base;
00251       } u_ixx;
00252       u_ixx.base = 0;
00253       u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00254       u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00255       u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00256       u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00257       u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00258       u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00259       u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00260       u_ixx.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00261       this->ixx = u_ixx.real;
00262       offset += sizeof(this->ixx);
00263       union {
00264         double real;
00265         uint64_t base;
00266       } u_ixy;
00267       u_ixy.base = 0;
00268       u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00269       u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00270       u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00271       u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00272       u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00273       u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00274       u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00275       u_ixy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00276       this->ixy = u_ixy.real;
00277       offset += sizeof(this->ixy);
00278       union {
00279         double real;
00280         uint64_t base;
00281       } u_ixz;
00282       u_ixz.base = 0;
00283       u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00284       u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00285       u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00286       u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00287       u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00288       u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00289       u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00290       u_ixz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00291       this->ixz = u_ixz.real;
00292       offset += sizeof(this->ixz);
00293       union {
00294         double real;
00295         uint64_t base;
00296       } u_iyy;
00297       u_iyy.base = 0;
00298       u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00299       u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00300       u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00301       u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00302       u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00303       u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00304       u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00305       u_iyy.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00306       this->iyy = u_iyy.real;
00307       offset += sizeof(this->iyy);
00308       union {
00309         double real;
00310         uint64_t base;
00311       } u_iyz;
00312       u_iyz.base = 0;
00313       u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00314       u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00315       u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00316       u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00317       u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00318       u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00319       u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00320       u_iyz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00321       this->iyz = u_iyz.real;
00322       offset += sizeof(this->iyz);
00323       union {
00324         double real;
00325         uint64_t base;
00326       } u_izz;
00327       u_izz.base = 0;
00328       u_izz.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00329       u_izz.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00330       u_izz.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00331       u_izz.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00332       u_izz.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00333       u_izz.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00334       u_izz.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00335       u_izz.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00336       this->izz = u_izz.real;
00337       offset += sizeof(this->izz);
00338       union {
00339         bool real;
00340         uint8_t base;
00341       } u_success;
00342       u_success.base = 0;
00343       u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00344       this->success = u_success.real;
00345       offset += sizeof(this->success);
00346       uint32_t length_status_message;
00347       arrToVar(length_status_message, (inbuffer + offset));
00348       offset += 4;
00349       for(unsigned int k= offset; k< offset+length_status_message; ++k){
00350           inbuffer[k-1]=inbuffer[k];
00351       }
00352       inbuffer[offset+length_status_message-1]=0;
00353       this->status_message = (char *)(inbuffer + offset-1);
00354       offset += length_status_message;
00355      return offset;
00356     }
00357 
00358     const char * getType(){ return GETLINKPROPERTIES; };
00359     const char * getMD5(){ return "a8619f92d17cfcc3958c0fd13299443d"; };
00360 
00361   };
00362 
00363   class GetLinkProperties {
00364     public:
00365     typedef GetLinkPropertiesRequest Request;
00366     typedef GetLinkPropertiesResponse Response;
00367   };
00368 
00369 }
00370 #endif