BoundingVolume.h

00001 #ifndef _ROS_moveit_msgs_BoundingVolume_h
00002 #define _ROS_moveit_msgs_BoundingVolume_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 #include "shape_msgs/SolidPrimitive.h"
00009 #include "geometry_msgs/Pose.h"
00010 #include "shape_msgs/Mesh.h"
00011 
00012 namespace moveit_msgs
00013 {
00014 
00015   class BoundingVolume : public ros::Msg
00016   {
00017     public:
00018       uint32_t primitives_length;
00019       typedef shape_msgs::SolidPrimitive _primitives_type;
00020       _primitives_type st_primitives;
00021       _primitives_type * primitives;
00022       uint32_t primitive_poses_length;
00023       typedef geometry_msgs::Pose _primitive_poses_type;
00024       _primitive_poses_type st_primitive_poses;
00025       _primitive_poses_type * primitive_poses;
00026       uint32_t meshes_length;
00027       typedef shape_msgs::Mesh _meshes_type;
00028       _meshes_type st_meshes;
00029       _meshes_type * meshes;
00030       uint32_t mesh_poses_length;
00031       typedef geometry_msgs::Pose _mesh_poses_type;
00032       _mesh_poses_type st_mesh_poses;
00033       _mesh_poses_type * mesh_poses;
00034 
00035     BoundingVolume():
00036       primitives_length(0), primitives(NULL),
00037       primitive_poses_length(0), primitive_poses(NULL),
00038       meshes_length(0), meshes(NULL),
00039       mesh_poses_length(0), mesh_poses(NULL)
00040     {
00041     }
00042 
00043     virtual int serialize(unsigned char *outbuffer) const
00044     {
00045       int offset = 0;
00046       *(outbuffer + offset + 0) = (this->primitives_length >> (8 * 0)) & 0xFF;
00047       *(outbuffer + offset + 1) = (this->primitives_length >> (8 * 1)) & 0xFF;
00048       *(outbuffer + offset + 2) = (this->primitives_length >> (8 * 2)) & 0xFF;
00049       *(outbuffer + offset + 3) = (this->primitives_length >> (8 * 3)) & 0xFF;
00050       offset += sizeof(this->primitives_length);
00051       for( uint32_t i = 0; i < primitives_length; i++){
00052       offset += this->primitives[i].serialize(outbuffer + offset);
00053       }
00054       *(outbuffer + offset + 0) = (this->primitive_poses_length >> (8 * 0)) & 0xFF;
00055       *(outbuffer + offset + 1) = (this->primitive_poses_length >> (8 * 1)) & 0xFF;
00056       *(outbuffer + offset + 2) = (this->primitive_poses_length >> (8 * 2)) & 0xFF;
00057       *(outbuffer + offset + 3) = (this->primitive_poses_length >> (8 * 3)) & 0xFF;
00058       offset += sizeof(this->primitive_poses_length);
00059       for( uint32_t i = 0; i < primitive_poses_length; i++){
00060       offset += this->primitive_poses[i].serialize(outbuffer + offset);
00061       }
00062       *(outbuffer + offset + 0) = (this->meshes_length >> (8 * 0)) & 0xFF;
00063       *(outbuffer + offset + 1) = (this->meshes_length >> (8 * 1)) & 0xFF;
00064       *(outbuffer + offset + 2) = (this->meshes_length >> (8 * 2)) & 0xFF;
00065       *(outbuffer + offset + 3) = (this->meshes_length >> (8 * 3)) & 0xFF;
00066       offset += sizeof(this->meshes_length);
00067       for( uint32_t i = 0; i < meshes_length; i++){
00068       offset += this->meshes[i].serialize(outbuffer + offset);
00069       }
00070       *(outbuffer + offset + 0) = (this->mesh_poses_length >> (8 * 0)) & 0xFF;
00071       *(outbuffer + offset + 1) = (this->mesh_poses_length >> (8 * 1)) & 0xFF;
00072       *(outbuffer + offset + 2) = (this->mesh_poses_length >> (8 * 2)) & 0xFF;
00073       *(outbuffer + offset + 3) = (this->mesh_poses_length >> (8 * 3)) & 0xFF;
00074       offset += sizeof(this->mesh_poses_length);
00075       for( uint32_t i = 0; i < mesh_poses_length; i++){
00076       offset += this->mesh_poses[i].serialize(outbuffer + offset);
00077       }
00078       return offset;
00079     }
00080 
00081     virtual int deserialize(unsigned char *inbuffer)
00082     {
00083       int offset = 0;
00084       uint32_t primitives_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00085       primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00086       primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00087       primitives_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00088       offset += sizeof(this->primitives_length);
00089       if(primitives_lengthT > primitives_length)
00090         this->primitives = (shape_msgs::SolidPrimitive*)realloc(this->primitives, primitives_lengthT * sizeof(shape_msgs::SolidPrimitive));
00091       primitives_length = primitives_lengthT;
00092       for( uint32_t i = 0; i < primitives_length; i++){
00093       offset += this->st_primitives.deserialize(inbuffer + offset);
00094         memcpy( &(this->primitives[i]), &(this->st_primitives), sizeof(shape_msgs::SolidPrimitive));
00095       }
00096       uint32_t primitive_poses_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00097       primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00098       primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00099       primitive_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00100       offset += sizeof(this->primitive_poses_length);
00101       if(primitive_poses_lengthT > primitive_poses_length)
00102         this->primitive_poses = (geometry_msgs::Pose*)realloc(this->primitive_poses, primitive_poses_lengthT * sizeof(geometry_msgs::Pose));
00103       primitive_poses_length = primitive_poses_lengthT;
00104       for( uint32_t i = 0; i < primitive_poses_length; i++){
00105       offset += this->st_primitive_poses.deserialize(inbuffer + offset);
00106         memcpy( &(this->primitive_poses[i]), &(this->st_primitive_poses), sizeof(geometry_msgs::Pose));
00107       }
00108       uint32_t meshes_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00109       meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00110       meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00111       meshes_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00112       offset += sizeof(this->meshes_length);
00113       if(meshes_lengthT > meshes_length)
00114         this->meshes = (shape_msgs::Mesh*)realloc(this->meshes, meshes_lengthT * sizeof(shape_msgs::Mesh));
00115       meshes_length = meshes_lengthT;
00116       for( uint32_t i = 0; i < meshes_length; i++){
00117       offset += this->st_meshes.deserialize(inbuffer + offset);
00118         memcpy( &(this->meshes[i]), &(this->st_meshes), sizeof(shape_msgs::Mesh));
00119       }
00120       uint32_t mesh_poses_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00121       mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00122       mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00123       mesh_poses_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00124       offset += sizeof(this->mesh_poses_length);
00125       if(mesh_poses_lengthT > mesh_poses_length)
00126         this->mesh_poses = (geometry_msgs::Pose*)realloc(this->mesh_poses, mesh_poses_lengthT * sizeof(geometry_msgs::Pose));
00127       mesh_poses_length = mesh_poses_lengthT;
00128       for( uint32_t i = 0; i < mesh_poses_length; i++){
00129       offset += this->st_mesh_poses.deserialize(inbuffer + offset);
00130         memcpy( &(this->mesh_poses[i]), &(this->st_mesh_poses), sizeof(geometry_msgs::Pose));
00131       }
00132      return offset;
00133     }
00134 
00135     virtual const char * getType(){ return "moveit_msgs/BoundingVolume"; };
00136     virtual const char * getMD5(){ return "22db94010f39e9198032cb4a1aeda26e"; };
00137 
00138   };
00139 
00140 }
00141 #endif