PlannerParams.h

00001 #ifndef _ROS_moveit_msgs_PlannerParams_h
00002 #define _ROS_moveit_msgs_PlannerParams_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 
00009 namespace moveit_msgs
00010 {
00011 
00012   class PlannerParams : public ros::Msg
00013   {
00014     public:
00015       uint32_t keys_length;
00016       typedef char* _keys_type;
00017       _keys_type st_keys;
00018       _keys_type * keys;
00019       uint32_t values_length;
00020       typedef char* _values_type;
00021       _values_type st_values;
00022       _values_type * values;
00023       uint32_t descriptions_length;
00024       typedef char* _descriptions_type;
00025       _descriptions_type st_descriptions;
00026       _descriptions_type * descriptions;
00027 
00028     PlannerParams():
00029       keys_length(0), keys(NULL),
00030       values_length(0), values(NULL),
00031       descriptions_length(0), descriptions(NULL)
00032     {
00033     }
00034 
00035     virtual int serialize(unsigned char *outbuffer) const
00036     {
00037       int offset = 0;
00038       *(outbuffer + offset + 0) = (this->keys_length >> (8 * 0)) & 0xFF;
00039       *(outbuffer + offset + 1) = (this->keys_length >> (8 * 1)) & 0xFF;
00040       *(outbuffer + offset + 2) = (this->keys_length >> (8 * 2)) & 0xFF;
00041       *(outbuffer + offset + 3) = (this->keys_length >> (8 * 3)) & 0xFF;
00042       offset += sizeof(this->keys_length);
00043       for( uint32_t i = 0; i < keys_length; i++){
00044       uint32_t length_keysi = strlen(this->keys[i]);
00045       varToArr(outbuffer + offset, length_keysi);
00046       offset += 4;
00047       memcpy(outbuffer + offset, this->keys[i], length_keysi);
00048       offset += length_keysi;
00049       }
00050       *(outbuffer + offset + 0) = (this->values_length >> (8 * 0)) & 0xFF;
00051       *(outbuffer + offset + 1) = (this->values_length >> (8 * 1)) & 0xFF;
00052       *(outbuffer + offset + 2) = (this->values_length >> (8 * 2)) & 0xFF;
00053       *(outbuffer + offset + 3) = (this->values_length >> (8 * 3)) & 0xFF;
00054       offset += sizeof(this->values_length);
00055       for( uint32_t i = 0; i < values_length; i++){
00056       uint32_t length_valuesi = strlen(this->values[i]);
00057       varToArr(outbuffer + offset, length_valuesi);
00058       offset += 4;
00059       memcpy(outbuffer + offset, this->values[i], length_valuesi);
00060       offset += length_valuesi;
00061       }
00062       *(outbuffer + offset + 0) = (this->descriptions_length >> (8 * 0)) & 0xFF;
00063       *(outbuffer + offset + 1) = (this->descriptions_length >> (8 * 1)) & 0xFF;
00064       *(outbuffer + offset + 2) = (this->descriptions_length >> (8 * 2)) & 0xFF;
00065       *(outbuffer + offset + 3) = (this->descriptions_length >> (8 * 3)) & 0xFF;
00066       offset += sizeof(this->descriptions_length);
00067       for( uint32_t i = 0; i < descriptions_length; i++){
00068       uint32_t length_descriptionsi = strlen(this->descriptions[i]);
00069       varToArr(outbuffer + offset, length_descriptionsi);
00070       offset += 4;
00071       memcpy(outbuffer + offset, this->descriptions[i], length_descriptionsi);
00072       offset += length_descriptionsi;
00073       }
00074       return offset;
00075     }
00076 
00077     virtual int deserialize(unsigned char *inbuffer)
00078     {
00079       int offset = 0;
00080       uint32_t keys_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00081       keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00082       keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00083       keys_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00084       offset += sizeof(this->keys_length);
00085       if(keys_lengthT > keys_length)
00086         this->keys = (char**)realloc(this->keys, keys_lengthT * sizeof(char*));
00087       keys_length = keys_lengthT;
00088       for( uint32_t i = 0; i < keys_length; i++){
00089       uint32_t length_st_keys;
00090       arrToVar(length_st_keys, (inbuffer + offset));
00091       offset += 4;
00092       for(unsigned int k= offset; k< offset+length_st_keys; ++k){
00093           inbuffer[k-1]=inbuffer[k];
00094       }
00095       inbuffer[offset+length_st_keys-1]=0;
00096       this->st_keys = (char *)(inbuffer + offset-1);
00097       offset += length_st_keys;
00098         memcpy( &(this->keys[i]), &(this->st_keys), sizeof(char*));
00099       }
00100       uint32_t values_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00101       values_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00102       values_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00103       values_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00104       offset += sizeof(this->values_length);
00105       if(values_lengthT > values_length)
00106         this->values = (char**)realloc(this->values, values_lengthT * sizeof(char*));
00107       values_length = values_lengthT;
00108       for( uint32_t i = 0; i < values_length; i++){
00109       uint32_t length_st_values;
00110       arrToVar(length_st_values, (inbuffer + offset));
00111       offset += 4;
00112       for(unsigned int k= offset; k< offset+length_st_values; ++k){
00113           inbuffer[k-1]=inbuffer[k];
00114       }
00115       inbuffer[offset+length_st_values-1]=0;
00116       this->st_values = (char *)(inbuffer + offset-1);
00117       offset += length_st_values;
00118         memcpy( &(this->values[i]), &(this->st_values), sizeof(char*));
00119       }
00120       uint32_t descriptions_lengthT = ((uint32_t) (*(inbuffer + offset))); 
00121       descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
00122       descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
00123       descriptions_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
00124       offset += sizeof(this->descriptions_length);
00125       if(descriptions_lengthT > descriptions_length)
00126         this->descriptions = (char**)realloc(this->descriptions, descriptions_lengthT * sizeof(char*));
00127       descriptions_length = descriptions_lengthT;
00128       for( uint32_t i = 0; i < descriptions_length; i++){
00129       uint32_t length_st_descriptions;
00130       arrToVar(length_st_descriptions, (inbuffer + offset));
00131       offset += 4;
00132       for(unsigned int k= offset; k< offset+length_st_descriptions; ++k){
00133           inbuffer[k-1]=inbuffer[k];
00134       }
00135       inbuffer[offset+length_st_descriptions-1]=0;
00136       this->st_descriptions = (char *)(inbuffer + offset-1);
00137       offset += length_st_descriptions;
00138         memcpy( &(this->descriptions[i]), &(this->st_descriptions), sizeof(char*));
00139       }
00140      return offset;
00141     }
00142 
00143     virtual const char * getType(){ return "moveit_msgs/PlannerParams"; };
00144     virtual const char * getMD5(){ return "cebdf4927996b9026bcf59a160d64145"; };
00145 
00146   };
00147 
00148 }
00149 #endif