SmachContainerStructure.h

00001 #ifndef _ROS_smach_msgs_SmachContainerStructure_h
00002 #define _ROS_smach_msgs_SmachContainerStructure_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 
00010 namespace smach_msgs
00011 {
00012 
00013   class SmachContainerStructure : public ros::Msg
00014   {
00015     public:
00016       std_msgs::Header header;
00017       const char* path;
00018       uint8_t children_length;
00019       char* st_children;
00020       char* * children;
00021       uint8_t internal_outcomes_length;
00022       char* st_internal_outcomes;
00023       char* * internal_outcomes;
00024       uint8_t outcomes_from_length;
00025       char* st_outcomes_from;
00026       char* * outcomes_from;
00027       uint8_t outcomes_to_length;
00028       char* st_outcomes_to;
00029       char* * outcomes_to;
00030       uint8_t container_outcomes_length;
00031       char* st_container_outcomes;
00032       char* * container_outcomes;
00033 
00034     SmachContainerStructure():
00035       header(),
00036       path(""),
00037       children_length(0), children(NULL),
00038       internal_outcomes_length(0), internal_outcomes(NULL),
00039       outcomes_from_length(0), outcomes_from(NULL),
00040       outcomes_to_length(0), outcomes_to(NULL),
00041       container_outcomes_length(0), container_outcomes(NULL)
00042     {
00043     }
00044 
00045     virtual int serialize(unsigned char *outbuffer) const
00046     {
00047       int offset = 0;
00048       offset += this->header.serialize(outbuffer + offset);
00049       uint32_t length_path = strlen(this->path);
00050       memcpy(outbuffer + offset, &length_path, sizeof(uint32_t));
00051       offset += 4;
00052       memcpy(outbuffer + offset, this->path, length_path);
00053       offset += length_path;
00054       *(outbuffer + offset++) = children_length;
00055       *(outbuffer + offset++) = 0;
00056       *(outbuffer + offset++) = 0;
00057       *(outbuffer + offset++) = 0;
00058       for( uint8_t i = 0; i < children_length; i++){
00059       uint32_t length_childreni = strlen(this->children[i]);
00060       memcpy(outbuffer + offset, &length_childreni, sizeof(uint32_t));
00061       offset += 4;
00062       memcpy(outbuffer + offset, this->children[i], length_childreni);
00063       offset += length_childreni;
00064       }
00065       *(outbuffer + offset++) = internal_outcomes_length;
00066       *(outbuffer + offset++) = 0;
00067       *(outbuffer + offset++) = 0;
00068       *(outbuffer + offset++) = 0;
00069       for( uint8_t i = 0; i < internal_outcomes_length; i++){
00070       uint32_t length_internal_outcomesi = strlen(this->internal_outcomes[i]);
00071       memcpy(outbuffer + offset, &length_internal_outcomesi, sizeof(uint32_t));
00072       offset += 4;
00073       memcpy(outbuffer + offset, this->internal_outcomes[i], length_internal_outcomesi);
00074       offset += length_internal_outcomesi;
00075       }
00076       *(outbuffer + offset++) = outcomes_from_length;
00077       *(outbuffer + offset++) = 0;
00078       *(outbuffer + offset++) = 0;
00079       *(outbuffer + offset++) = 0;
00080       for( uint8_t i = 0; i < outcomes_from_length; i++){
00081       uint32_t length_outcomes_fromi = strlen(this->outcomes_from[i]);
00082       memcpy(outbuffer + offset, &length_outcomes_fromi, sizeof(uint32_t));
00083       offset += 4;
00084       memcpy(outbuffer + offset, this->outcomes_from[i], length_outcomes_fromi);
00085       offset += length_outcomes_fromi;
00086       }
00087       *(outbuffer + offset++) = outcomes_to_length;
00088       *(outbuffer + offset++) = 0;
00089       *(outbuffer + offset++) = 0;
00090       *(outbuffer + offset++) = 0;
00091       for( uint8_t i = 0; i < outcomes_to_length; i++){
00092       uint32_t length_outcomes_toi = strlen(this->outcomes_to[i]);
00093       memcpy(outbuffer + offset, &length_outcomes_toi, sizeof(uint32_t));
00094       offset += 4;
00095       memcpy(outbuffer + offset, this->outcomes_to[i], length_outcomes_toi);
00096       offset += length_outcomes_toi;
00097       }
00098       *(outbuffer + offset++) = container_outcomes_length;
00099       *(outbuffer + offset++) = 0;
00100       *(outbuffer + offset++) = 0;
00101       *(outbuffer + offset++) = 0;
00102       for( uint8_t i = 0; i < container_outcomes_length; i++){
00103       uint32_t length_container_outcomesi = strlen(this->container_outcomes[i]);
00104       memcpy(outbuffer + offset, &length_container_outcomesi, sizeof(uint32_t));
00105       offset += 4;
00106       memcpy(outbuffer + offset, this->container_outcomes[i], length_container_outcomesi);
00107       offset += length_container_outcomesi;
00108       }
00109       return offset;
00110     }
00111 
00112     virtual int deserialize(unsigned char *inbuffer)
00113     {
00114       int offset = 0;
00115       offset += this->header.deserialize(inbuffer + offset);
00116       uint32_t length_path;
00117       memcpy(&length_path, (inbuffer + offset), sizeof(uint32_t));
00118       offset += 4;
00119       for(unsigned int k= offset; k< offset+length_path; ++k){
00120           inbuffer[k-1]=inbuffer[k];
00121       }
00122       inbuffer[offset+length_path-1]=0;
00123       this->path = (char *)(inbuffer + offset-1);
00124       offset += length_path;
00125       uint8_t children_lengthT = *(inbuffer + offset++);
00126       if(children_lengthT > children_length)
00127         this->children = (char**)realloc(this->children, children_lengthT * sizeof(char*));
00128       offset += 3;
00129       children_length = children_lengthT;
00130       for( uint8_t i = 0; i < children_length; i++){
00131       uint32_t length_st_children;
00132       memcpy(&length_st_children, (inbuffer + offset), sizeof(uint32_t));
00133       offset += 4;
00134       for(unsigned int k= offset; k< offset+length_st_children; ++k){
00135           inbuffer[k-1]=inbuffer[k];
00136       }
00137       inbuffer[offset+length_st_children-1]=0;
00138       this->st_children = (char *)(inbuffer + offset-1);
00139       offset += length_st_children;
00140         memcpy( &(this->children[i]), &(this->st_children), sizeof(char*));
00141       }
00142       uint8_t internal_outcomes_lengthT = *(inbuffer + offset++);
00143       if(internal_outcomes_lengthT > internal_outcomes_length)
00144         this->internal_outcomes = (char**)realloc(this->internal_outcomes, internal_outcomes_lengthT * sizeof(char*));
00145       offset += 3;
00146       internal_outcomes_length = internal_outcomes_lengthT;
00147       for( uint8_t i = 0; i < internal_outcomes_length; i++){
00148       uint32_t length_st_internal_outcomes;
00149       memcpy(&length_st_internal_outcomes, (inbuffer + offset), sizeof(uint32_t));
00150       offset += 4;
00151       for(unsigned int k= offset; k< offset+length_st_internal_outcomes; ++k){
00152           inbuffer[k-1]=inbuffer[k];
00153       }
00154       inbuffer[offset+length_st_internal_outcomes-1]=0;
00155       this->st_internal_outcomes = (char *)(inbuffer + offset-1);
00156       offset += length_st_internal_outcomes;
00157         memcpy( &(this->internal_outcomes[i]), &(this->st_internal_outcomes), sizeof(char*));
00158       }
00159       uint8_t outcomes_from_lengthT = *(inbuffer + offset++);
00160       if(outcomes_from_lengthT > outcomes_from_length)
00161         this->outcomes_from = (char**)realloc(this->outcomes_from, outcomes_from_lengthT * sizeof(char*));
00162       offset += 3;
00163       outcomes_from_length = outcomes_from_lengthT;
00164       for( uint8_t i = 0; i < outcomes_from_length; i++){
00165       uint32_t length_st_outcomes_from;
00166       memcpy(&length_st_outcomes_from, (inbuffer + offset), sizeof(uint32_t));
00167       offset += 4;
00168       for(unsigned int k= offset; k< offset+length_st_outcomes_from; ++k){
00169           inbuffer[k-1]=inbuffer[k];
00170       }
00171       inbuffer[offset+length_st_outcomes_from-1]=0;
00172       this->st_outcomes_from = (char *)(inbuffer + offset-1);
00173       offset += length_st_outcomes_from;
00174         memcpy( &(this->outcomes_from[i]), &(this->st_outcomes_from), sizeof(char*));
00175       }
00176       uint8_t outcomes_to_lengthT = *(inbuffer + offset++);
00177       if(outcomes_to_lengthT > outcomes_to_length)
00178         this->outcomes_to = (char**)realloc(this->outcomes_to, outcomes_to_lengthT * sizeof(char*));
00179       offset += 3;
00180       outcomes_to_length = outcomes_to_lengthT;
00181       for( uint8_t i = 0; i < outcomes_to_length; i++){
00182       uint32_t length_st_outcomes_to;
00183       memcpy(&length_st_outcomes_to, (inbuffer + offset), sizeof(uint32_t));
00184       offset += 4;
00185       for(unsigned int k= offset; k< offset+length_st_outcomes_to; ++k){
00186           inbuffer[k-1]=inbuffer[k];
00187       }
00188       inbuffer[offset+length_st_outcomes_to-1]=0;
00189       this->st_outcomes_to = (char *)(inbuffer + offset-1);
00190       offset += length_st_outcomes_to;
00191         memcpy( &(this->outcomes_to[i]), &(this->st_outcomes_to), sizeof(char*));
00192       }
00193       uint8_t container_outcomes_lengthT = *(inbuffer + offset++);
00194       if(container_outcomes_lengthT > container_outcomes_length)
00195         this->container_outcomes = (char**)realloc(this->container_outcomes, container_outcomes_lengthT * sizeof(char*));
00196       offset += 3;
00197       container_outcomes_length = container_outcomes_lengthT;
00198       for( uint8_t i = 0; i < container_outcomes_length; i++){
00199       uint32_t length_st_container_outcomes;
00200       memcpy(&length_st_container_outcomes, (inbuffer + offset), sizeof(uint32_t));
00201       offset += 4;
00202       for(unsigned int k= offset; k< offset+length_st_container_outcomes; ++k){
00203           inbuffer[k-1]=inbuffer[k];
00204       }
00205       inbuffer[offset+length_st_container_outcomes-1]=0;
00206       this->st_container_outcomes = (char *)(inbuffer + offset-1);
00207       offset += length_st_container_outcomes;
00208         memcpy( &(this->container_outcomes[i]), &(this->st_container_outcomes), sizeof(char*));
00209       }
00210      return offset;
00211     }
00212 
00213     const char * getType(){ return "smach_msgs/SmachContainerStructure"; };
00214     const char * getMD5(){ return "3d3d1e0d0f99779ee9e58101a5dcf7ea"; };
00215 
00216   };
00217 
00218 }
00219 #endif