GetModelProperties.h

00001 #ifndef _ROS_SERVICE_GetModelProperties_h
00002 #define _ROS_SERVICE_GetModelProperties_h
00003 #include <stdint.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include "ros/msg.h"
00007 
00008 namespace gazebo_msgs
00009 {
00010 
00011 static const char GETMODELPROPERTIES[] = "gazebo_msgs/GetModelProperties";
00012 
00013   class GetModelPropertiesRequest : public ros::Msg
00014   {
00015     public:
00016       const char* model_name;
00017 
00018     GetModelPropertiesRequest():
00019       model_name("")
00020     {
00021     }
00022 
00023     virtual int serialize(unsigned char *outbuffer) const
00024     {
00025       int offset = 0;
00026       uint32_t length_model_name = strlen(this->model_name);
00027       memcpy(outbuffer + offset, &length_model_name, sizeof(uint32_t));
00028       offset += 4;
00029       memcpy(outbuffer + offset, this->model_name, length_model_name);
00030       offset += length_model_name;
00031       return offset;
00032     }
00033 
00034     virtual int deserialize(unsigned char *inbuffer)
00035     {
00036       int offset = 0;
00037       uint32_t length_model_name;
00038       memcpy(&length_model_name, (inbuffer + offset), sizeof(uint32_t));
00039       offset += 4;
00040       for(unsigned int k= offset; k< offset+length_model_name; ++k){
00041           inbuffer[k-1]=inbuffer[k];
00042       }
00043       inbuffer[offset+length_model_name-1]=0;
00044       this->model_name = (char *)(inbuffer + offset-1);
00045       offset += length_model_name;
00046      return offset;
00047     }
00048 
00049     const char * getType(){ return GETMODELPROPERTIES; };
00050     const char * getMD5(){ return "ea31c8eab6fc401383cf528a7c0984ba"; };
00051 
00052   };
00053 
00054   class GetModelPropertiesResponse : public ros::Msg
00055   {
00056     public:
00057       const char* parent_model_name;
00058       const char* canonical_body_name;
00059       uint8_t body_names_length;
00060       char* st_body_names;
00061       char* * body_names;
00062       uint8_t geom_names_length;
00063       char* st_geom_names;
00064       char* * geom_names;
00065       uint8_t joint_names_length;
00066       char* st_joint_names;
00067       char* * joint_names;
00068       uint8_t child_model_names_length;
00069       char* st_child_model_names;
00070       char* * child_model_names;
00071       bool is_static;
00072       bool success;
00073       const char* status_message;
00074 
00075     GetModelPropertiesResponse():
00076       parent_model_name(""),
00077       canonical_body_name(""),
00078       body_names_length(0), body_names(NULL),
00079       geom_names_length(0), geom_names(NULL),
00080       joint_names_length(0), joint_names(NULL),
00081       child_model_names_length(0), child_model_names(NULL),
00082       is_static(0),
00083       success(0),
00084       status_message("")
00085     {
00086     }
00087 
00088     virtual int serialize(unsigned char *outbuffer) const
00089     {
00090       int offset = 0;
00091       uint32_t length_parent_model_name = strlen(this->parent_model_name);
00092       memcpy(outbuffer + offset, &length_parent_model_name, sizeof(uint32_t));
00093       offset += 4;
00094       memcpy(outbuffer + offset, this->parent_model_name, length_parent_model_name);
00095       offset += length_parent_model_name;
00096       uint32_t length_canonical_body_name = strlen(this->canonical_body_name);
00097       memcpy(outbuffer + offset, &length_canonical_body_name, sizeof(uint32_t));
00098       offset += 4;
00099       memcpy(outbuffer + offset, this->canonical_body_name, length_canonical_body_name);
00100       offset += length_canonical_body_name;
00101       *(outbuffer + offset++) = body_names_length;
00102       *(outbuffer + offset++) = 0;
00103       *(outbuffer + offset++) = 0;
00104       *(outbuffer + offset++) = 0;
00105       for( uint8_t i = 0; i < body_names_length; i++){
00106       uint32_t length_body_namesi = strlen(this->body_names[i]);
00107       memcpy(outbuffer + offset, &length_body_namesi, sizeof(uint32_t));
00108       offset += 4;
00109       memcpy(outbuffer + offset, this->body_names[i], length_body_namesi);
00110       offset += length_body_namesi;
00111       }
00112       *(outbuffer + offset++) = geom_names_length;
00113       *(outbuffer + offset++) = 0;
00114       *(outbuffer + offset++) = 0;
00115       *(outbuffer + offset++) = 0;
00116       for( uint8_t i = 0; i < geom_names_length; i++){
00117       uint32_t length_geom_namesi = strlen(this->geom_names[i]);
00118       memcpy(outbuffer + offset, &length_geom_namesi, sizeof(uint32_t));
00119       offset += 4;
00120       memcpy(outbuffer + offset, this->geom_names[i], length_geom_namesi);
00121       offset += length_geom_namesi;
00122       }
00123       *(outbuffer + offset++) = joint_names_length;
00124       *(outbuffer + offset++) = 0;
00125       *(outbuffer + offset++) = 0;
00126       *(outbuffer + offset++) = 0;
00127       for( uint8_t i = 0; i < joint_names_length; i++){
00128       uint32_t length_joint_namesi = strlen(this->joint_names[i]);
00129       memcpy(outbuffer + offset, &length_joint_namesi, sizeof(uint32_t));
00130       offset += 4;
00131       memcpy(outbuffer + offset, this->joint_names[i], length_joint_namesi);
00132       offset += length_joint_namesi;
00133       }
00134       *(outbuffer + offset++) = child_model_names_length;
00135       *(outbuffer + offset++) = 0;
00136       *(outbuffer + offset++) = 0;
00137       *(outbuffer + offset++) = 0;
00138       for( uint8_t i = 0; i < child_model_names_length; i++){
00139       uint32_t length_child_model_namesi = strlen(this->child_model_names[i]);
00140       memcpy(outbuffer + offset, &length_child_model_namesi, sizeof(uint32_t));
00141       offset += 4;
00142       memcpy(outbuffer + offset, this->child_model_names[i], length_child_model_namesi);
00143       offset += length_child_model_namesi;
00144       }
00145       union {
00146         bool real;
00147         uint8_t base;
00148       } u_is_static;
00149       u_is_static.real = this->is_static;
00150       *(outbuffer + offset + 0) = (u_is_static.base >> (8 * 0)) & 0xFF;
00151       offset += sizeof(this->is_static);
00152       union {
00153         bool real;
00154         uint8_t base;
00155       } u_success;
00156       u_success.real = this->success;
00157       *(outbuffer + offset + 0) = (u_success.base >> (8 * 0)) & 0xFF;
00158       offset += sizeof(this->success);
00159       uint32_t length_status_message = strlen(this->status_message);
00160       memcpy(outbuffer + offset, &length_status_message, sizeof(uint32_t));
00161       offset += 4;
00162       memcpy(outbuffer + offset, this->status_message, length_status_message);
00163       offset += length_status_message;
00164       return offset;
00165     }
00166 
00167     virtual int deserialize(unsigned char *inbuffer)
00168     {
00169       int offset = 0;
00170       uint32_t length_parent_model_name;
00171       memcpy(&length_parent_model_name, (inbuffer + offset), sizeof(uint32_t));
00172       offset += 4;
00173       for(unsigned int k= offset; k< offset+length_parent_model_name; ++k){
00174           inbuffer[k-1]=inbuffer[k];
00175       }
00176       inbuffer[offset+length_parent_model_name-1]=0;
00177       this->parent_model_name = (char *)(inbuffer + offset-1);
00178       offset += length_parent_model_name;
00179       uint32_t length_canonical_body_name;
00180       memcpy(&length_canonical_body_name, (inbuffer + offset), sizeof(uint32_t));
00181       offset += 4;
00182       for(unsigned int k= offset; k< offset+length_canonical_body_name; ++k){
00183           inbuffer[k-1]=inbuffer[k];
00184       }
00185       inbuffer[offset+length_canonical_body_name-1]=0;
00186       this->canonical_body_name = (char *)(inbuffer + offset-1);
00187       offset += length_canonical_body_name;
00188       uint8_t body_names_lengthT = *(inbuffer + offset++);
00189       if(body_names_lengthT > body_names_length)
00190         this->body_names = (char**)realloc(this->body_names, body_names_lengthT * sizeof(char*));
00191       offset += 3;
00192       body_names_length = body_names_lengthT;
00193       for( uint8_t i = 0; i < body_names_length; i++){
00194       uint32_t length_st_body_names;
00195       memcpy(&length_st_body_names, (inbuffer + offset), sizeof(uint32_t));
00196       offset += 4;
00197       for(unsigned int k= offset; k< offset+length_st_body_names; ++k){
00198           inbuffer[k-1]=inbuffer[k];
00199       }
00200       inbuffer[offset+length_st_body_names-1]=0;
00201       this->st_body_names = (char *)(inbuffer + offset-1);
00202       offset += length_st_body_names;
00203         memcpy( &(this->body_names[i]), &(this->st_body_names), sizeof(char*));
00204       }
00205       uint8_t geom_names_lengthT = *(inbuffer + offset++);
00206       if(geom_names_lengthT > geom_names_length)
00207         this->geom_names = (char**)realloc(this->geom_names, geom_names_lengthT * sizeof(char*));
00208       offset += 3;
00209       geom_names_length = geom_names_lengthT;
00210       for( uint8_t i = 0; i < geom_names_length; i++){
00211       uint32_t length_st_geom_names;
00212       memcpy(&length_st_geom_names, (inbuffer + offset), sizeof(uint32_t));
00213       offset += 4;
00214       for(unsigned int k= offset; k< offset+length_st_geom_names; ++k){
00215           inbuffer[k-1]=inbuffer[k];
00216       }
00217       inbuffer[offset+length_st_geom_names-1]=0;
00218       this->st_geom_names = (char *)(inbuffer + offset-1);
00219       offset += length_st_geom_names;
00220         memcpy( &(this->geom_names[i]), &(this->st_geom_names), sizeof(char*));
00221       }
00222       uint8_t joint_names_lengthT = *(inbuffer + offset++);
00223       if(joint_names_lengthT > joint_names_length)
00224         this->joint_names = (char**)realloc(this->joint_names, joint_names_lengthT * sizeof(char*));
00225       offset += 3;
00226       joint_names_length = joint_names_lengthT;
00227       for( uint8_t i = 0; i < joint_names_length; i++){
00228       uint32_t length_st_joint_names;
00229       memcpy(&length_st_joint_names, (inbuffer + offset), sizeof(uint32_t));
00230       offset += 4;
00231       for(unsigned int k= offset; k< offset+length_st_joint_names; ++k){
00232           inbuffer[k-1]=inbuffer[k];
00233       }
00234       inbuffer[offset+length_st_joint_names-1]=0;
00235       this->st_joint_names = (char *)(inbuffer + offset-1);
00236       offset += length_st_joint_names;
00237         memcpy( &(this->joint_names[i]), &(this->st_joint_names), sizeof(char*));
00238       }
00239       uint8_t child_model_names_lengthT = *(inbuffer + offset++);
00240       if(child_model_names_lengthT > child_model_names_length)
00241         this->child_model_names = (char**)realloc(this->child_model_names, child_model_names_lengthT * sizeof(char*));
00242       offset += 3;
00243       child_model_names_length = child_model_names_lengthT;
00244       for( uint8_t i = 0; i < child_model_names_length; i++){
00245       uint32_t length_st_child_model_names;
00246       memcpy(&length_st_child_model_names, (inbuffer + offset), sizeof(uint32_t));
00247       offset += 4;
00248       for(unsigned int k= offset; k< offset+length_st_child_model_names; ++k){
00249           inbuffer[k-1]=inbuffer[k];
00250       }
00251       inbuffer[offset+length_st_child_model_names-1]=0;
00252       this->st_child_model_names = (char *)(inbuffer + offset-1);
00253       offset += length_st_child_model_names;
00254         memcpy( &(this->child_model_names[i]), &(this->st_child_model_names), sizeof(char*));
00255       }
00256       union {
00257         bool real;
00258         uint8_t base;
00259       } u_is_static;
00260       u_is_static.base = 0;
00261       u_is_static.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00262       this->is_static = u_is_static.real;
00263       offset += sizeof(this->is_static);
00264       union {
00265         bool real;
00266         uint8_t base;
00267       } u_success;
00268       u_success.base = 0;
00269       u_success.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
00270       this->success = u_success.real;
00271       offset += sizeof(this->success);
00272       uint32_t length_status_message;
00273       memcpy(&length_status_message, (inbuffer + offset), sizeof(uint32_t));
00274       offset += 4;
00275       for(unsigned int k= offset; k< offset+length_status_message; ++k){
00276           inbuffer[k-1]=inbuffer[k];
00277       }
00278       inbuffer[offset+length_status_message-1]=0;
00279       this->status_message = (char *)(inbuffer + offset-1);
00280       offset += length_status_message;
00281      return offset;
00282     }
00283 
00284     const char * getType(){ return GETMODELPROPERTIES; };
00285     const char * getMD5(){ return "b7f370938ef77b464b95f1bab3ec5028"; };
00286 
00287   };
00288 
00289   class GetModelProperties {
00290     public:
00291     typedef GetModelPropertiesRequest Request;
00292     typedef GetModelPropertiesResponse Response;
00293   };
00294 
00295 }
00296 #endif