Config.h

00001 #ifndef _ROS_dynamic_reconfigure_Config_h
00002 #define _ROS_dynamic_reconfigure_Config_h
00003 
00004 #include <stdint.h>
00005 #include <string.h>
00006 #include <stdlib.h>
00007 #include "ros/msg.h"
00008 #include "dynamic_reconfigure/BoolParameter.h"
00009 #include "dynamic_reconfigure/IntParameter.h"
00010 #include "dynamic_reconfigure/StrParameter.h"
00011 #include "dynamic_reconfigure/DoubleParameter.h"
00012 #include "dynamic_reconfigure/GroupState.h"
00013 
00014 namespace dynamic_reconfigure
00015 {
00016 
00017   class Config : public ros::Msg
00018   {
00019     public:
00020       uint8_t bools_length;
00021       dynamic_reconfigure::BoolParameter st_bools;
00022       dynamic_reconfigure::BoolParameter * bools;
00023       uint8_t ints_length;
00024       dynamic_reconfigure::IntParameter st_ints;
00025       dynamic_reconfigure::IntParameter * ints;
00026       uint8_t strs_length;
00027       dynamic_reconfigure::StrParameter st_strs;
00028       dynamic_reconfigure::StrParameter * strs;
00029       uint8_t doubles_length;
00030       dynamic_reconfigure::DoubleParameter st_doubles;
00031       dynamic_reconfigure::DoubleParameter * doubles;
00032       uint8_t groups_length;
00033       dynamic_reconfigure::GroupState st_groups;
00034       dynamic_reconfigure::GroupState * groups;
00035 
00036     Config():
00037       bools_length(0), bools(NULL),
00038       ints_length(0), ints(NULL),
00039       strs_length(0), strs(NULL),
00040       doubles_length(0), doubles(NULL),
00041       groups_length(0), groups(NULL)
00042     {
00043     }
00044 
00045     virtual int serialize(unsigned char *outbuffer) const
00046     {
00047       int offset = 0;
00048       *(outbuffer + offset++) = bools_length;
00049       *(outbuffer + offset++) = 0;
00050       *(outbuffer + offset++) = 0;
00051       *(outbuffer + offset++) = 0;
00052       for( uint8_t i = 0; i < bools_length; i++){
00053       offset += this->bools[i].serialize(outbuffer + offset);
00054       }
00055       *(outbuffer + offset++) = ints_length;
00056       *(outbuffer + offset++) = 0;
00057       *(outbuffer + offset++) = 0;
00058       *(outbuffer + offset++) = 0;
00059       for( uint8_t i = 0; i < ints_length; i++){
00060       offset += this->ints[i].serialize(outbuffer + offset);
00061       }
00062       *(outbuffer + offset++) = strs_length;
00063       *(outbuffer + offset++) = 0;
00064       *(outbuffer + offset++) = 0;
00065       *(outbuffer + offset++) = 0;
00066       for( uint8_t i = 0; i < strs_length; i++){
00067       offset += this->strs[i].serialize(outbuffer + offset);
00068       }
00069       *(outbuffer + offset++) = doubles_length;
00070       *(outbuffer + offset++) = 0;
00071       *(outbuffer + offset++) = 0;
00072       *(outbuffer + offset++) = 0;
00073       for( uint8_t i = 0; i < doubles_length; i++){
00074       offset += this->doubles[i].serialize(outbuffer + offset);
00075       }
00076       *(outbuffer + offset++) = groups_length;
00077       *(outbuffer + offset++) = 0;
00078       *(outbuffer + offset++) = 0;
00079       *(outbuffer + offset++) = 0;
00080       for( uint8_t i = 0; i < groups_length; i++){
00081       offset += this->groups[i].serialize(outbuffer + offset);
00082       }
00083       return offset;
00084     }
00085 
00086     virtual int deserialize(unsigned char *inbuffer)
00087     {
00088       int offset = 0;
00089       uint8_t bools_lengthT = *(inbuffer + offset++);
00090       if(bools_lengthT > bools_length)
00091         this->bools = (dynamic_reconfigure::BoolParameter*)realloc(this->bools, bools_lengthT * sizeof(dynamic_reconfigure::BoolParameter));
00092       offset += 3;
00093       bools_length = bools_lengthT;
00094       for( uint8_t i = 0; i < bools_length; i++){
00095       offset += this->st_bools.deserialize(inbuffer + offset);
00096         memcpy( &(this->bools[i]), &(this->st_bools), sizeof(dynamic_reconfigure::BoolParameter));
00097       }
00098       uint8_t ints_lengthT = *(inbuffer + offset++);
00099       if(ints_lengthT > ints_length)
00100         this->ints = (dynamic_reconfigure::IntParameter*)realloc(this->ints, ints_lengthT * sizeof(dynamic_reconfigure::IntParameter));
00101       offset += 3;
00102       ints_length = ints_lengthT;
00103       for( uint8_t i = 0; i < ints_length; i++){
00104       offset += this->st_ints.deserialize(inbuffer + offset);
00105         memcpy( &(this->ints[i]), &(this->st_ints), sizeof(dynamic_reconfigure::IntParameter));
00106       }
00107       uint8_t strs_lengthT = *(inbuffer + offset++);
00108       if(strs_lengthT > strs_length)
00109         this->strs = (dynamic_reconfigure::StrParameter*)realloc(this->strs, strs_lengthT * sizeof(dynamic_reconfigure::StrParameter));
00110       offset += 3;
00111       strs_length = strs_lengthT;
00112       for( uint8_t i = 0; i < strs_length; i++){
00113       offset += this->st_strs.deserialize(inbuffer + offset);
00114         memcpy( &(this->strs[i]), &(this->st_strs), sizeof(dynamic_reconfigure::StrParameter));
00115       }
00116       uint8_t doubles_lengthT = *(inbuffer + offset++);
00117       if(doubles_lengthT > doubles_length)
00118         this->doubles = (dynamic_reconfigure::DoubleParameter*)realloc(this->doubles, doubles_lengthT * sizeof(dynamic_reconfigure::DoubleParameter));
00119       offset += 3;
00120       doubles_length = doubles_lengthT;
00121       for( uint8_t i = 0; i < doubles_length; i++){
00122       offset += this->st_doubles.deserialize(inbuffer + offset);
00123         memcpy( &(this->doubles[i]), &(this->st_doubles), sizeof(dynamic_reconfigure::DoubleParameter));
00124       }
00125       uint8_t groups_lengthT = *(inbuffer + offset++);
00126       if(groups_lengthT > groups_length)
00127         this->groups = (dynamic_reconfigure::GroupState*)realloc(this->groups, groups_lengthT * sizeof(dynamic_reconfigure::GroupState));
00128       offset += 3;
00129       groups_length = groups_lengthT;
00130       for( uint8_t i = 0; i < groups_length; i++){
00131       offset += this->st_groups.deserialize(inbuffer + offset);
00132         memcpy( &(this->groups[i]), &(this->st_groups), sizeof(dynamic_reconfigure::GroupState));
00133       }
00134      return offset;
00135     }
00136 
00137     const char * getType(){ return "dynamic_reconfigure/Config"; };
00138     const char * getMD5(){ return "958f16a05573709014982821e6822580"; };
00139 
00140   };
00141 
00142 }
00143 #endif