GripperCommandResult.h

00001 #ifndef _ROS_control_msgs_GripperCommandResult_h
00002 #define _ROS_control_msgs_GripperCommandResult_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 
00009 namespace control_msgs
00010 {
00011 
00012   class GripperCommandResult : public ros::Msg
00013   {
00014     public:
00015       typedef double _position_type;
00016       _position_type position;
00017       typedef double _effort_type;
00018       _effort_type effort;
00019       typedef bool _stalled_type;
00020       _stalled_type stalled;
00021       typedef bool _reached_goal_type;
00022       _reached_goal_type reached_goal;
00023 
00024     GripperCommandResult():
00025       position(0),
00026       effort(0),
00027       stalled(0),
00028       reached_goal(0)
00029     {
00030     }
00031 
00032     virtual int serialize(unsigned char *outbuffer) const
00033     {
00034       int offset = 0;
00035       union {
00036         double real;
00037         uint64_t base;
00038       } u_position;
00039       u_position.real = this->position;
00040       *(outbuffer + offset + 0) = (u_position.base >> (8 * 0)) & 0xFF;
00041       *(outbuffer + offset + 1) = (u_position.base >> (8 * 1)) & 0xFF;
00042       *(outbuffer + offset + 2) = (u_position.base >> (8 * 2)) & 0xFF;
00043       *(outbuffer + offset + 3) = (u_position.base >> (8 * 3)) & 0xFF;
00044       *(outbuffer + offset + 4) = (u_position.base >> (8 * 4)) & 0xFF;
00045       *(outbuffer + offset + 5) = (u_position.base >> (8 * 5)) & 0xFF;
00046       *(outbuffer + offset + 6) = (u_position.base >> (8 * 6)) & 0xFF;
00047       *(outbuffer + offset + 7) = (u_position.base >> (8 * 7)) & 0xFF;
00048       offset += sizeof(this->position);
00049       union {
00050         double real;
00051         uint64_t base;
00052       } u_effort;
00053       u_effort.real = this->effort;
00054       *(outbuffer + offset + 0) = (u_effort.base >> (8 * 0)) & 0xFF;
00055       *(outbuffer + offset + 1) = (u_effort.base >> (8 * 1)) & 0xFF;
00056       *(outbuffer + offset + 2) = (u_effort.base >> (8 * 2)) & 0xFF;
00057       *(outbuffer + offset + 3) = (u_effort.base >> (8 * 3)) & 0xFF;
00058       *(outbuffer + offset + 4) = (u_effort.base >> (8 * 4)) & 0xFF;
00059       *(outbuffer + offset + 5) = (u_effort.base >> (8 * 5)) & 0xFF;
00060       *(outbuffer + offset + 6) = (u_effort.base >> (8 * 6)) & 0xFF;
00061       *(outbuffer + offset + 7) = (u_effort.base >> (8 * 7)) & 0xFF;
00062       offset += sizeof(this->effort);
00063       union {
00064         bool real;
00065         uint8_t base;
00066       } u_stalled;
00067       u_stalled.real = this->stalled;
00068       *(outbuffer + offset + 0) = (u_stalled.base >> (8 * 0)) & 0xFF;
00069       offset += sizeof(this->stalled);
00070       union {
00071         bool real;
00072         uint8_t base;
00073       } u_reached_goal;
00074       u_reached_goal.real = this->reached_goal;
00075       *(outbuffer + offset + 0) = (u_reached_goal.base >> (8 * 0)) & 0xFF;
00076       offset += sizeof(this->reached_goal);
00077       return offset;
00078     }
00079 
00080     virtual int deserialize(unsigned char *inbuffer)
00081     {
00082       int offset = 0;
00083       union {
00084         double real;
00085         uint64_t base;
00086       } u_position;
00087       u_position.base = 0;
00088       u_position.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00089       u_position.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00090       u_position.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00091       u_position.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00092       u_position.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00093       u_position.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00094       u_position.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00095       u_position.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00096       this->position = u_position.real;
00097       offset += sizeof(this->position);
00098       union {
00099         double real;
00100         uint64_t base;
00101       } u_effort;
00102       u_effort.base = 0;
00103       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 0))) << (8 * 0);
00104       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 1))) << (8 * 1);
00105       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 2))) << (8 * 2);
00106       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 3))) << (8 * 3);
00107       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 4))) << (8 * 4);
00108       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 5))) << (8 * 5);
00109       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 6))) << (8 * 6);
00110       u_effort.base |= ((uint64_t) (*(inbuffer + offset + 7))) << (8 * 7);
00111       this->effort = u_effort.real;
00112       offset += sizeof(this->effort);
00113       union {
00114         bool real;
00115         uint8_t base;
00116       } u_stalled;
00117       u_stalled.base = 0;
00118       u_stalled.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00119       this->stalled = u_stalled.real;
00120       offset += sizeof(this->stalled);
00121       union {
00122         bool real;
00123         uint8_t base;
00124       } u_reached_goal;
00125       u_reached_goal.base = 0;
00126       u_reached_goal.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00127       this->reached_goal = u_reached_goal.real;
00128       offset += sizeof(this->reached_goal);
00129      return offset;
00130     }
00131 
00132     const char * getType(){ return "control_msgs/GripperCommandResult"; };
00133     const char * getMD5(){ return "e4cbff56d3562bcf113da5a5adeef91f"; };
00134 
00135   };
00136 
00137 }
00138 #endif