InteractiveMarker.h

00001 #ifndef _ROS_visualization_msgs_InteractiveMarker_h
00002 #define _ROS_visualization_msgs_InteractiveMarker_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 #include "std_msgs/Header.h"
00009 #include "geometry_msgs/Pose.h"
00010 #include "visualization_msgs/MenuEntry.h"
00011 #include "visualization_msgs/InteractiveMarkerControl.h"
00012 
00013 namespace visualization_msgs
00014 {
00015 
00016   class InteractiveMarker : public ros::Msg
00017   {
00018     public:
00019       typedef std_msgs::Header _header_type;
00020       _header_type header;
00021       typedef geometry_msgs::Pose _pose_type;
00022       _pose_type pose;
00023       typedef const char* _name_type;
00024       _name_type name;
00025       typedef const char* _description_type;
00026       _description_type description;
00027       typedef float _scale_type;
00028       _scale_type scale;
00029       uint32_t menu_entries_length;
00030       typedef visualization_msgs::MenuEntry _menu_entries_type;
00031       _menu_entries_type st_menu_entries;
00032       _menu_entries_type * menu_entries;
00033       uint32_t controls_length;
00034       typedef visualization_msgs::InteractiveMarkerControl _controls_type;
00035       _controls_type st_controls;
00036       _controls_type * controls;
00037 
00038     InteractiveMarker():
00039       header(),
00040       pose(),
00041       name(""),
00042       description(""),
00043       scale(0),
00044       menu_entries_length(0), menu_entries(NULL),
00045       controls_length(0), controls(NULL)
00046     {
00047     }
00048 
00049     virtual int serialize(unsigned char *outbuffer) const
00050     {
00051       int offset = 0;
00052       offset += this->header.serialize(outbuffer + offset);
00053       offset += this->pose.serialize(outbuffer + offset);
00054       uint32_t length_name = strlen(this->name);
00055       varToArr(outbuffer + offset, length_name);
00056       offset += 4;
00057       memcpy(outbuffer + offset, this->name, length_name);
00058       offset += length_name;
00059       uint32_t length_description = strlen(this->description);
00060       varToArr(outbuffer + offset, length_description);
00061       offset += 4;
00062       memcpy(outbuffer + offset, this->description, length_description);
00063       offset += length_description;
00064       union {
00065         float real;
00066         uint32_t base;
00067       } u_scale;
00068       u_scale.real = this->scale;
00069       *(outbuffer + offset + 0) = (u_scale.base >> (8 * 0)) & 0xFF;
00070       *(outbuffer + offset + 1) = (u_scale.base >> (8 * 1)) & 0xFF;
00071       *(outbuffer + offset + 2) = (u_scale.base >> (8 * 2)) & 0xFF;
00072       *(outbuffer + offset + 3) = (u_scale.base >> (8 * 3)) & 0xFF;
00073       offset += sizeof(this->scale);
00074       *(outbuffer + offset + 0) = (this->menu_entries_length >> (8 * 0)) & 0xFF;
00075       *(outbuffer + offset + 1) = (this->menu_entries_length >> (8 * 1)) & 0xFF;
00076       *(outbuffer + offset + 2) = (this->menu_entries_length >> (8 * 2)) & 0xFF;
00077       *(outbuffer + offset + 3) = (this->menu_entries_length >> (8 * 3)) & 0xFF;
00078       offset += sizeof(this->menu_entries_length);
00079       for( uint32_t i = 0; i < menu_entries_length; i++){
00080       offset += this->menu_entries[i].serialize(outbuffer + offset);
00081       }
00082       *(outbuffer + offset + 0) = (this->controls_length >> (8 * 0)) & 0xFF;
00083       *(outbuffer + offset + 1) = (this->controls_length >> (8 * 1)) & 0xFF;
00084       *(outbuffer + offset + 2) = (this->controls_length >> (8 * 2)) & 0xFF;
00085       *(outbuffer + offset + 3) = (this->controls_length >> (8 * 3)) & 0xFF;
00086       offset += sizeof(this->controls_length);
00087       for( uint32_t i = 0; i < controls_length; i++){
00088       offset += this->controls[i].serialize(outbuffer + offset);
00089       }
00090       return offset;
00091     }
00092 
00093     virtual int deserialize(unsigned char *inbuffer)
00094     {
00095       int offset = 0;
00096       offset += this->header.deserialize(inbuffer + offset);
00097       offset += this->pose.deserialize(inbuffer + offset);
00098       uint32_t length_name;
00099       arrToVar(length_name, (inbuffer + offset));
00100       offset += 4;
00101       for(unsigned int k= offset; k< offset+length_name; ++k){
00102           inbuffer[k-1]=inbuffer[k];
00103       }
00104       inbuffer[offset+length_name-1]=0;
00105       this->name = (char *)(inbuffer + offset-1);
00106       offset += length_name;
00107       uint32_t length_description;
00108       arrToVar(length_description, (inbuffer + offset));
00109       offset += 4;
00110       for(unsigned int k= offset; k< offset+length_description; ++k){
00111           inbuffer[k-1]=inbuffer[k];
00112       }
00113       inbuffer[offset+length_description-1]=0;
00114       this->description = (char *)(inbuffer + offset-1);
00115       offset += length_description;
00116       union {
00117         float real;
00118         uint32_t base;
00119       } u_scale;
00120       u_scale.base = 0;
00121       u_scale.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
00122       u_scale.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
00123       u_scale.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
00124       u_scale.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
00125       this->scale = u_scale.real;
00126       offset += sizeof(this->scale);
00127       uint32_t menu_entries_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00128       menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00129       menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00130       menu_entries_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00131       offset += sizeof(this->menu_entries_length);
00132       if(menu_entries_lengthT > menu_entries_length)
00133         this->menu_entries = (visualization_msgs::MenuEntry*)realloc(this->menu_entries, menu_entries_lengthT * sizeof(visualization_msgs::MenuEntry));
00134       menu_entries_length = menu_entries_lengthT;
00135       for( uint32_t i = 0; i < menu_entries_length; i++){
00136       offset += this->st_menu_entries.deserialize(inbuffer + offset);
00137         memcpy( &(this->menu_entries[i]), &(this->st_menu_entries), sizeof(visualization_msgs::MenuEntry));
00138       }
00139       uint32_t controls_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00140       controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00141       controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00142       controls_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00143       offset += sizeof(this->controls_length);
00144       if(controls_lengthT > controls_length)
00145         this->controls = (visualization_msgs::InteractiveMarkerControl*)realloc(this->controls, controls_lengthT * sizeof(visualization_msgs::InteractiveMarkerControl));
00146       controls_length = controls_lengthT;
00147       for( uint32_t i = 0; i < controls_length; i++){
00148       offset += this->st_controls.deserialize(inbuffer + offset);
00149         memcpy( &(this->controls[i]), &(this->st_controls), sizeof(visualization_msgs::InteractiveMarkerControl));
00150       }
00151      return offset;
00152     }
00153 
00154     const char * getType(){ return "visualization_msgs/InteractiveMarker"; };
00155     const char * getMD5(){ return "dd86d22909d5a3364b384492e35c10af"; };
00156 
00157   };
00158 
00159 }
00160 #endif