ApplyJointEffort.h

00001 #ifndef _ROS_SERVICE_ApplyJointEffort_h
00002 #define _ROS_SERVICE_ApplyJointEffort_h
00003 #include <stdint.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include "ros/msg.h"
00007 #include "ros/duration.h"
00008 #include "ros/time.h"
00009 
00010 namespace gazebo_msgs
00011 {
00012 
00013 static const char APPLYJOINTEFFORT[] = "gazebo_msgs/ApplyJointEffort";
00014 
00015   class ApplyJointEffortRequest : public ros::Msg
00016   {
00017     public:
00018       typedef const char* _joint_name_type;
00019       _joint_name_type joint_name;
00020       typedef double _effort_type;
00021       _effort_type effort;
00022       typedef ros::Time _start_time_type;
00023       _start_time_type start_time;
00024       typedef ros::Duration _duration_type;
00025       _duration_type duration;
00026 
00027     ApplyJointEffortRequest():
00028       joint_name(""),
00029       effort(0),
00030       start_time(),
00031       duration()
00032     {
00033     }
00034 
00035     virtual int serialize(unsigned char *outbuffer) const
00036     {
00037       int offset = 0;
00038       uint32_t length_joint_name = strlen(this->joint_name);
00039       varToArr(outbuffer + offset, length_joint_name);
00040       offset += 4;
00041       memcpy(outbuffer + offset, this->joint_name, length_joint_name);
00042       offset += length_joint_name;
00043       union {
00044         double real;
00045         uint64_t base;
00046       } u_effort;
00047       u_effort.real = this->effort;
00048       *(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
00049       *(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
00050       *(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
00051       *(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
00052       *(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
00053       *(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
00054       *(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
00055       *(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
00056       offset += sizeof(this->effort);
00057       *(outbuffer + offset + 0) = (this->start_time.sec >> (8 * 0)) & 0xFF;
00058       *(outbuffer + offset + 1) = (this->start_time.sec >> (8 * 1)) & 0xFF;
00059       *(outbuffer + offset + 2) = (this->start_time.sec >> (8 * 2)) & 0xFF;
00060       *(outbuffer + offset + 3) = (this->start_time.sec >> (8 * 3)) & 0xFF;
00061       offset += sizeof(this->start_time.sec);
00062       *(outbuffer + offset + 0) = (this->start_time.nsec >> (8 * 0)) & 0xFF;
00063       *(outbuffer + offset + 1) = (this->start_time.nsec >> (8 * 1)) & 0xFF;
00064       *(outbuffer + offset + 2) = (this->start_time.nsec >> (8 * 2)) & 0xFF;
00065       *(outbuffer + offset + 3) = (this->start_time.nsec >> (8 * 3)) & 0xFF;
00066       offset += sizeof(this->start_time.nsec);
00067       *(outbuffer + offset + 0) = (this->duration.sec >> (8 * 0)) & 0xFF;
00068       *(outbuffer + offset + 1) = (this->duration.sec >> (8 * 1)) & 0xFF;
00069       *(outbuffer + offset + 2) = (this->duration.sec >> (8 * 2)) & 0xFF;
00070       *(outbuffer + offset + 3) = (this->duration.sec >> (8 * 3)) & 0xFF;
00071       offset += sizeof(this->duration.sec);
00072       *(outbuffer + offset + 0) = (this->duration.nsec >> (8 * 0)) & 0xFF;
00073       *(outbuffer + offset + 1) = (this->duration.nsec >> (8 * 1)) & 0xFF;
00074       *(outbuffer + offset + 2) = (this->duration.nsec >> (8 * 2)) & 0xFF;
00075       *(outbuffer + offset + 3) = (this->duration.nsec >> (8 * 3)) & 0xFF;
00076       offset += sizeof(this->duration.nsec);
00077       return offset;
00078     }
00079 
00080     virtual int deserialize(unsigned char *inbuffer)
00081     {
00082       int offset = 0;
00083       uint32_t length_joint_name;
00084       arrToVar(length_joint_name, (inbuffer + offset));
00085       offset += 4;
00086       for(unsigned int k= offset; k< offset+length_joint_name; ++k){
00087           inbuffer[k-1]=inbuffer[k];
00088       }
00089       inbuffer[offset+length_joint_name-1]=0;
00090       this->joint_name = (char *)(inbuffer + offset-1);
00091       offset += length_joint_name;
00092       union {
00093         double real;
00094         uint64_t base;
00095       } u_effort;
00096       u_effort.base = 0;
00097       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00098       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00099       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00100       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00101       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00102       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00103       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00104       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00105       this->effort = u_effort.real;
00106       offset += sizeof(this->effort);
00107       this->start_time.sec =  ((uint32_t) (*(inbuffer + offset)));
00108       this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00109       this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00110       this->start_time.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00111       offset += sizeof(this->start_time.sec);
00112       this->start_time.nsec =  ((uint32_t) (*(inbuffer + offset)));
00113       this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00114       this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00115       this->start_time.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00116       offset += sizeof(this->start_time.nsec);
00117       this->duration.sec =  ((uint32_t) (*(inbuffer + offset)));
00118       this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00119       this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00120       this->duration.sec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00121       offset += sizeof(this->duration.sec);
00122       this->duration.nsec =  ((uint32_t) (*(inbuffer + offset)));
00123       this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00124       this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00125       this->duration.nsec |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00126       offset += sizeof(this->duration.nsec);
00127      return offset;
00128     }
00129 
00130     const char * getType(){ return APPLYJOINTEFFORT; };
00131     const char * getMD5(){ return "2c3396ab9af67a509ecd2167a8fe41a2"; };
00132 
00133   };
00134 
00135   class ApplyJointEffortResponse : public ros::Msg
00136   {
00137     public:
00138       typedef bool _success_type;
00139       _success_type success;
00140       typedef const char* _status_message_type;
00141       _status_message_type status_message;
00142 
00143     ApplyJointEffortResponse():
00144       success(0),
00145       status_message("")
00146     {
00147     }
00148 
00149     virtual int serialize(unsigned char *outbuffer) const
00150     {
00151       int offset = 0;
00152       union {
00153         bool real;
00154         uint8_t base;
00155       } u_success;
00156       u_success.real = this->success;
00157       *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
00158       offset += sizeof(this->success);
00159       uint32_t length_status_message = strlen(this->status_message);
00160       varToArr(outbuffer + offset, length_status_message);
00161       offset += 4;
00162       memcpy(outbuffer + offset, this->status_message, length_status_message);
00163       offset += length_status_message;
00164       return offset;
00165     }
00166 
00167     virtual int deserialize(unsigned char *inbuffer)
00168     {
00169       int offset = 0;
00170       union {
00171         bool real;
00172         uint8_t base;
00173       } u_success;
00174       u_success.base = 0;
00175       u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00176       this->success = u_success.real;
00177       offset += sizeof(this->success);
00178       uint32_t length_status_message;
00179       arrToVar(length_status_message, (inbuffer + offset));
00180       offset += 4;
00181       for(unsigned int k= offset; k< offset+length_status_message; ++k){
00182           inbuffer[k-1]=inbuffer[k];
00183       }
00184       inbuffer[offset+length_status_message-1]=0;
00185       this->status_message = (char *)(inbuffer + offset-1);
00186       offset += length_status_message;
00187      return offset;
00188     }
00189 
00190     const char * getType(){ return APPLYJOINTEFFORT; };
00191     const char * getMD5(){ return "2ec6f3eff0161f4257b808b12bc830c2"; };
00192 
00193   };
00194 
00195   class ApplyJointEffort {
00196     public:
00197     typedef ApplyJointEffortRequest Request;
00198     typedef ApplyJointEffortResponse Response;
00199   };
00200 
00201 }
00202 #endif