00001
00002 #ifndef VREP_COMMON_SERVICE_SIMROSSETSPHERICALJOINTMATRIX_H
00003 #define VREP_COMMON_SERVICE_SIMROSSETSPHERICALJOINTMATRIX_H
00004 #include <string>
00005 #include <vector>
00006 #include <map>
00007 #include <ostream>
00008 #include "ros/serialization.h"
00009 #include "ros/builtin_message_traits.h"
00010 #include "ros/message_operations.h"
00011 #include "ros/time.h"
00012
00013 #include "ros/macros.h"
00014
00015 #include "ros/assert.h"
00016
00017 #include "ros/service_traits.h"
00018
00019 #include "geometry_msgs/Quaternion.h"
00020
00021
00022
00023 namespace vrep_common
00024 {
00025 template <class ContainerAllocator>
00026 struct simRosSetSphericalJointMatrixRequest_ {
00027 typedef simRosSetSphericalJointMatrixRequest_<ContainerAllocator> Type;
00028
00029 simRosSetSphericalJointMatrixRequest_()
00030 : handle(0)
00031 , quaternion()
00032 {
00033 }
00034
00035 simRosSetSphericalJointMatrixRequest_(const ContainerAllocator& _alloc)
00036 : handle(0)
00037 , quaternion(_alloc)
00038 {
00039 }
00040
00041 typedef int32_t _handle_type;
00042 int32_t handle;
00043
00044 typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _quaternion_type;
00045 ::geometry_msgs::Quaternion_<ContainerAllocator> quaternion;
00046
00047
00048 typedef boost::shared_ptr< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> > Ptr;
00049 typedef boost::shared_ptr< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> const> ConstPtr;
00050 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00051 };
00052 typedef ::vrep_common::simRosSetSphericalJointMatrixRequest_<std::allocator<void> > simRosSetSphericalJointMatrixRequest;
00053
00054 typedef boost::shared_ptr< ::vrep_common::simRosSetSphericalJointMatrixRequest> simRosSetSphericalJointMatrixRequestPtr;
00055 typedef boost::shared_ptr< ::vrep_common::simRosSetSphericalJointMatrixRequest const> simRosSetSphericalJointMatrixRequestConstPtr;
00056
00057
00058 template <class ContainerAllocator>
00059 struct simRosSetSphericalJointMatrixResponse_ {
00060 typedef simRosSetSphericalJointMatrixResponse_<ContainerAllocator> Type;
00061
00062 simRosSetSphericalJointMatrixResponse_()
00063 : result(0)
00064 {
00065 }
00066
00067 simRosSetSphericalJointMatrixResponse_(const ContainerAllocator& _alloc)
00068 : result(0)
00069 {
00070 }
00071
00072 typedef int32_t _result_type;
00073 int32_t result;
00074
00075
00076 typedef boost::shared_ptr< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> > Ptr;
00077 typedef boost::shared_ptr< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> const> ConstPtr;
00078 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00079 };
00080 typedef ::vrep_common::simRosSetSphericalJointMatrixResponse_<std::allocator<void> > simRosSetSphericalJointMatrixResponse;
00081
00082 typedef boost::shared_ptr< ::vrep_common::simRosSetSphericalJointMatrixResponse> simRosSetSphericalJointMatrixResponsePtr;
00083 typedef boost::shared_ptr< ::vrep_common::simRosSetSphericalJointMatrixResponse const> simRosSetSphericalJointMatrixResponseConstPtr;
00084
00085 struct simRosSetSphericalJointMatrix
00086 {
00087
00088 typedef simRosSetSphericalJointMatrixRequest Request;
00089 typedef simRosSetSphericalJointMatrixResponse Response;
00090 Request request;
00091 Response response;
00092
00093 typedef Request RequestType;
00094 typedef Response ResponseType;
00095 };
00096 }
00097
00098 namespace ros
00099 {
00100 namespace message_traits
00101 {
00102 template<class ContainerAllocator> struct IsMessage< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> > : public TrueType {};
00103 template<class ContainerAllocator> struct IsMessage< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> const> : public TrueType {};
00104 template<class ContainerAllocator>
00105 struct MD5Sum< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> > {
00106 static const char* value()
00107 {
00108 return "b50ec6d9c510b5022a5f97f224455526";
00109 }
00110
00111 static const char* value(const ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> &) { return value(); }
00112 static const uint64_t static_value1 = 0xb50ec6d9c510b502ULL;
00113 static const uint64_t static_value2 = 0x2a5f97f224455526ULL;
00114 };
00115
00116 template<class ContainerAllocator>
00117 struct DataType< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> > {
00118 static const char* value()
00119 {
00120 return "vrep_common/simRosSetSphericalJointMatrixRequest";
00121 }
00122
00123 static const char* value(const ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> &) { return value(); }
00124 };
00125
00126 template<class ContainerAllocator>
00127 struct Definition< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> > {
00128 static const char* value()
00129 {
00130 return "\n\
00131 \n\
00132 \n\
00133 \n\
00134 int32 handle\n\
00135 geometry_msgs/Quaternion quaternion\n\
00136 \n\
00137 ================================================================================\n\
00138 MSG: geometry_msgs/Quaternion\n\
00139 # This represents an orientation in free space in quaternion form.\n\
00140 \n\
00141 float64 x\n\
00142 float64 y\n\
00143 float64 z\n\
00144 float64 w\n\
00145 \n\
00146 ";
00147 }
00148
00149 static const char* value(const ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> &) { return value(); }
00150 };
00151
00152 template<class ContainerAllocator> struct IsFixedSize< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> > : public TrueType {};
00153 }
00154 }
00155
00156
00157 namespace ros
00158 {
00159 namespace message_traits
00160 {
00161 template<class ContainerAllocator> struct IsMessage< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> > : public TrueType {};
00162 template<class ContainerAllocator> struct IsMessage< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> const> : public TrueType {};
00163 template<class ContainerAllocator>
00164 struct MD5Sum< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> > {
00165 static const char* value()
00166 {
00167 return "034a8e20d6a306665e3a5b340fab3f09";
00168 }
00169
00170 static const char* value(const ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> &) { return value(); }
00171 static const uint64_t static_value1 = 0x034a8e20d6a30666ULL;
00172 static const uint64_t static_value2 = 0x5e3a5b340fab3f09ULL;
00173 };
00174
00175 template<class ContainerAllocator>
00176 struct DataType< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> > {
00177 static const char* value()
00178 {
00179 return "vrep_common/simRosSetSphericalJointMatrixResponse";
00180 }
00181
00182 static const char* value(const ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> &) { return value(); }
00183 };
00184
00185 template<class ContainerAllocator>
00186 struct Definition< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> > {
00187 static const char* value()
00188 {
00189 return "int32 result\n\
00190 \n\
00191 \n\
00192 ";
00193 }
00194
00195 static const char* value(const ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> &) { return value(); }
00196 };
00197
00198 template<class ContainerAllocator> struct IsFixedSize< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> > : public TrueType {};
00199 }
00200 }
00201
00202 namespace ros
00203 {
00204 namespace serialization
00205 {
00206
00207 template<class ContainerAllocator> struct Serializer< ::vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> >
00208 {
00209 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00210 {
00211 stream.next(m.handle);
00212 stream.next(m.quaternion);
00213 }
00214
00215 ROS_DECLARE_ALLINONE_SERIALIZER;
00216 };
00217 }
00218 }
00219
00220
00221 namespace ros
00222 {
00223 namespace serialization
00224 {
00225
00226 template<class ContainerAllocator> struct Serializer< ::vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> >
00227 {
00228 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00229 {
00230 stream.next(m.result);
00231 }
00232
00233 ROS_DECLARE_ALLINONE_SERIALIZER;
00234 };
00235 }
00236 }
00237
00238 namespace ros
00239 {
00240 namespace service_traits
00241 {
00242 template<>
00243 struct MD5Sum<vrep_common::simRosSetSphericalJointMatrix> {
00244 static const char* value()
00245 {
00246 return "ff6022ac5ed35d4a73c1ed756bc036db";
00247 }
00248
00249 static const char* value(const vrep_common::simRosSetSphericalJointMatrix&) { return value(); }
00250 };
00251
00252 template<>
00253 struct DataType<vrep_common::simRosSetSphericalJointMatrix> {
00254 static const char* value()
00255 {
00256 return "vrep_common/simRosSetSphericalJointMatrix";
00257 }
00258
00259 static const char* value(const vrep_common::simRosSetSphericalJointMatrix&) { return value(); }
00260 };
00261
00262 template<class ContainerAllocator>
00263 struct MD5Sum<vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> > {
00264 static const char* value()
00265 {
00266 return "ff6022ac5ed35d4a73c1ed756bc036db";
00267 }
00268
00269 static const char* value(const vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> &) { return value(); }
00270 };
00271
00272 template<class ContainerAllocator>
00273 struct DataType<vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> > {
00274 static const char* value()
00275 {
00276 return "vrep_common/simRosSetSphericalJointMatrix";
00277 }
00278
00279 static const char* value(const vrep_common::simRosSetSphericalJointMatrixRequest_<ContainerAllocator> &) { return value(); }
00280 };
00281
00282 template<class ContainerAllocator>
00283 struct MD5Sum<vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> > {
00284 static const char* value()
00285 {
00286 return "ff6022ac5ed35d4a73c1ed756bc036db";
00287 }
00288
00289 static const char* value(const vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> &) { return value(); }
00290 };
00291
00292 template<class ContainerAllocator>
00293 struct DataType<vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> > {
00294 static const char* value()
00295 {
00296 return "vrep_common/simRosSetSphericalJointMatrix";
00297 }
00298
00299 static const char* value(const vrep_common::simRosSetSphericalJointMatrixResponse_<ContainerAllocator> &) { return value(); }
00300 };
00301
00302 }
00303 }
00304
00305 #endif // VREP_COMMON_SERVICE_SIMROSSETSPHERICALJOINTMATRIX_H
00306