AllowedCollisionMatrix.h

00001 #ifndef _ROS_moveit_msgs_AllowedCollisionMatrix_h
00002 #define _ROS_moveit_msgs_AllowedCollisionMatrix_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 #include "moveit_msgs/AllowedCollisionEntry.h"
00009 
00010 namespace moveit_msgs
00011 {
00012 
00013   class AllowedCollisionMatrix : public ros::Msg
00014   {
00015     public:
00016       uint32_t entry_names_length;
00017       typedef char* _entry_names_type;
00018       _entry_names_type st_entry_names;
00019       _entry_names_type * entry_names;
00020       uint32_t entry_values_length;
00021       typedef moveit_msgs::AllowedCollisionEntry _entry_values_type;
00022       _entry_values_type st_entry_values;
00023       _entry_values_type * entry_values;
00024       uint32_t default_entry_names_length;
00025       typedef char* _default_entry_names_type;
00026       _default_entry_names_type st_default_entry_names;
00027       _default_entry_names_type * default_entry_names;
00028       uint32_t default_entry_values_length;
00029       typedef bool _default_entry_values_type;
00030       _default_entry_values_type st_default_entry_values;
00031       _default_entry_values_type * default_entry_values;
00032 
00033     AllowedCollisionMatrix():
00034       entry_names_length(0), entry_names(NULL),
00035       entry_values_length(0), entry_values(NULL),
00036       default_entry_names_length(0), default_entry_names(NULL),
00037       default_entry_values_length(0), default_entry_values(NULL)
00038     {
00039     }
00040 
00041     virtual int serialize(unsigned char *outbuffer) const
00042     {
00043       int offset = 0;
00044       *(outbuffer + offset + 0) = (this->entry_names_length >> (8 * 0)) & 0xFF;
00045       *(outbuffer + offset + 1) = (this->entry_names_length >> (8 * 1)) & 0xFF;
00046       *(outbuffer + offset + 2) = (this->entry_names_length >> (8 * 2)) & 0xFF;
00047       *(outbuffer + offset + 3) = (this->entry_names_length >> (8 * 3)) & 0xFF;
00048       offset += sizeof(this->entry_names_length);
00049       for( uint32_t i = 0; i < entry_names_length; i++){
00050       uint32_t length_entry_namesi = strlen(this->entry_names[i]);
00051       varToArr(outbuffer + offset, length_entry_namesi);
00052       offset += 4;
00053       memcpy(outbuffer + offset, this->entry_names[i], length_entry_namesi);
00054       offset += length_entry_namesi;
00055       }
00056       *(outbuffer + offset + 0) = (this->entry_values_length >> (8 * 0)) & 0xFF;
00057       *(outbuffer + offset + 1) = (this->entry_values_length >> (8 * 1)) & 0xFF;
00058       *(outbuffer + offset + 2) = (this->entry_values_length >> (8 * 2)) & 0xFF;
00059       *(outbuffer + offset + 3) = (this->entry_values_length >> (8 * 3)) & 0xFF;
00060       offset += sizeof(this->entry_values_length);
00061       for( uint32_t i = 0; i < entry_values_length; i++){
00062       offset += this->entry_values[i].serialize(outbuffer + offset);
00063       }
00064       *(outbuffer + offset + 0) = (this->default_entry_names_length >> (8 * 0)) & 0xFF;
00065       *(outbuffer + offset + 1) = (this->default_entry_names_length >> (8 * 1)) & 0xFF;
00066       *(outbuffer + offset + 2) = (this->default_entry_names_length >> (8 * 2)) & 0xFF;
00067       *(outbuffer + offset + 3) = (this->default_entry_names_length >> (8 * 3)) & 0xFF;
00068       offset += sizeof(this->default_entry_names_length);
00069       for( uint32_t i = 0; i < default_entry_names_length; i++){
00070       uint32_t length_default_entry_namesi = strlen(this->default_entry_names[i]);
00071       varToArr(outbuffer + offset, length_default_entry_namesi);
00072       offset += 4;
00073       memcpy(outbuffer + offset, this->default_entry_names[i], length_default_entry_namesi);
00074       offset += length_default_entry_namesi;
00075       }
00076       *(outbuffer + offset + 0) = (this->default_entry_values_length >> (8 * 0)) & 0xFF;
00077       *(outbuffer + offset + 1) = (this->default_entry_values_length >> (8 * 1)) & 0xFF;
00078       *(outbuffer + offset + 2) = (this->default_entry_values_length >> (8 * 2)) & 0xFF;
00079       *(outbuffer + offset + 3) = (this->default_entry_values_length >> (8 * 3)) & 0xFF;
00080       offset += sizeof(this->default_entry_values_length);
00081       for( uint32_t i = 0; i < default_entry_values_length; i++){
00082       union {
00083         bool real;
00084         uint8_t base;
00085       } u_default_entry_valuesi;
00086       u_default_entry_valuesi.real = this->default_entry_values[i];
00087       *(outbuffer + offset + 0) = (u_default_entry_valuesi.base >> (8 * 0)) & 0xFF;
00088       offset += sizeof(this->default_entry_values[i]);
00089       }
00090       return offset;
00091     }
00092 
00093     virtual int deserialize(unsigned char *inbuffer)
00094     {
00095       int offset = 0;
00096       uint32_t entry_names_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00097       entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00098       entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00099       entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00100       offset += sizeof(this->entry_names_length);
00101       if(entry_names_lengthT > entry_names_length)
00102         this->entry_names = (char**)realloc(this->entry_names, entry_names_lengthT * sizeof(char*));
00103       entry_names_length = entry_names_lengthT;
00104       for( uint32_t i = 0; i < entry_names_length; i++){
00105       uint32_t length_st_entry_names;
00106       arrToVar(length_st_entry_names, (inbuffer + offset));
00107       offset += 4;
00108       for(unsigned int k= offset; k< offset+length_st_entry_names; ++k){
00109           inbuffer[k-1]=inbuffer[k];
00110       }
00111       inbuffer[offset+length_st_entry_names-1]=0;
00112       this->st_entry_names = (char *)(inbuffer + offset-1);
00113       offset += length_st_entry_names;
00114         memcpy( &(this->entry_names[i]), &(this->st_entry_names), sizeof(char*));
00115       }
00116       uint32_t entry_values_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00117       entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00118       entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00119       entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00120       offset += sizeof(this->entry_values_length);
00121       if(entry_values_lengthT > entry_values_length)
00122         this->entry_values = (moveit_msgs::AllowedCollisionEntry*)realloc(this->entry_values, entry_values_lengthT * sizeof(moveit_msgs::AllowedCollisionEntry));
00123       entry_values_length = entry_values_lengthT;
00124       for( uint32_t i = 0; i < entry_values_length; i++){
00125       offset += this->st_entry_values.deserialize(inbuffer + offset);
00126         memcpy( &(this->entry_values[i]), &(this->st_entry_values), sizeof(moveit_msgs::AllowedCollisionEntry));
00127       }
00128       uint32_t default_entry_names_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00129       default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00130       default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00131       default_entry_names_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00132       offset += sizeof(this->default_entry_names_length);
00133       if(default_entry_names_lengthT > default_entry_names_length)
00134         this->default_entry_names = (char**)realloc(this->default_entry_names, default_entry_names_lengthT * sizeof(char*));
00135       default_entry_names_length = default_entry_names_lengthT;
00136       for( uint32_t i = 0; i < default_entry_names_length; i++){
00137       uint32_t length_st_default_entry_names;
00138       arrToVar(length_st_default_entry_names, (inbuffer + offset));
00139       offset += 4;
00140       for(unsigned int k= offset; k< offset+length_st_default_entry_names; ++k){
00141           inbuffer[k-1]=inbuffer[k];
00142       }
00143       inbuffer[offset+length_st_default_entry_names-1]=0;
00144       this->st_default_entry_names = (char *)(inbuffer + offset-1);
00145       offset += length_st_default_entry_names;
00146         memcpy( &(this->default_entry_names[i]), &(this->st_default_entry_names), sizeof(char*));
00147       }
00148       uint32_t default_entry_values_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00149       default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00150       default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00151       default_entry_values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00152       offset += sizeof(this->default_entry_values_length);
00153       if(default_entry_values_lengthT > default_entry_values_length)
00154         this->default_entry_values = (bool*)realloc(this->default_entry_values, default_entry_values_lengthT * sizeof(bool));
00155       default_entry_values_length = default_entry_values_lengthT;
00156       for( uint32_t i = 0; i < default_entry_values_length; i++){
00157       union {
00158         bool real;
00159         uint8_t base;
00160       } u_st_default_entry_values;
00161       u_st_default_entry_values.base = 0;
00162       u_st_default_entry_values.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00163       this->st_default_entry_values = u_st_default_entry_values.real;
00164       offset += sizeof(this->st_default_entry_values);
00165         memcpy( &(this->default_entry_values[i]), &(this->st_default_entry_values), sizeof(bool));
00166       }
00167      return offset;
00168     }
00169 
00170     virtual const char * getType(){ return "moveit_msgs/AllowedCollisionMatrix"; };
00171     virtual const char * getMD5(){ return "aedce13587eef0d79165a075659c1879"; };
00172 
00173   };
00174 
00175 }
00176 #endif