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 SetLinkProperties.h Source File

SetLinkProperties.h

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