00001
00002 #ifndef TEST_ROSPY_SERVICE_CONSTANTSMULTIPLEX_H
00003 #define TEST_ROSPY_SERVICE_CONSTANTSMULTIPLEX_H
00004 #include <string>
00005 #include <vector>
00006 #include <ostream>
00007 #include "ros/serialization.h"
00008 #include "ros/builtin_message_traits.h"
00009 #include "ros/message_operations.h"
00010 #include "ros/message.h"
00011 #include "ros/time.h"
00012
00013 #include "ros/service_traits.h"
00014
00015
00016
00017
00018 namespace test_rospy
00019 {
00020 template <class ContainerAllocator>
00021 struct ConstantsMultiplexRequest_ : public ros::Message
00022 {
00023 typedef ConstantsMultiplexRequest_<ContainerAllocator> Type;
00024
00025 ConstantsMultiplexRequest_()
00026 : selection(0)
00027 {
00028 }
00029
00030 ConstantsMultiplexRequest_(const ContainerAllocator& _alloc)
00031 : selection(0)
00032 {
00033 }
00034
00035 typedef int8_t _selection_type;
00036 int8_t selection;
00037
00038 enum { BYTE_X = 0 };
00039 enum { BYTE_Y = 15 };
00040 enum { BYTE_Z = 5 };
00041 enum { INT32_X = 0 };
00042 enum { INT32_Y = -12345678 };
00043 enum { INT32_Z = 12345678 };
00044 enum { UINT32_X = 0 };
00045 enum { UINT32_Y = 12345678 };
00046 enum { UINT32_Z = 1 };
00047 static const float FLOAT32_X;
00048 static const float FLOAT32_Y;
00049 static const float FLOAT32_Z;
00050 enum { SELECT_X = 1 };
00051 enum { SELECT_Y = 2 };
00052 enum { SELECT_Z = 3 };
00053
00054 private:
00055 static const char* __s_getDataType_() { return "test_rospy/ConstantsMultiplexRequest"; }
00056 public:
00057 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00058
00059 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00060
00061 private:
00062 static const char* __s_getMD5Sum_() { return "3e3b2ecf5f3e7d25830bd97a7fd13b17"; }
00063 public:
00064 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00065
00066 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00067
00068 private:
00069 static const char* __s_getServerMD5Sum_() { return "bab86066b3f7801cb25df3932f644396"; }
00070 public:
00071 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00072
00073 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00074
00075 private:
00076 static const char* __s_getMessageDefinition_() { return "byte BYTE_X=0\n\
00077 byte BYTE_Y=15\n\
00078 byte BYTE_Z=5\n\
00079 int32 INT32_X=0\n\
00080 int32 INT32_Y=-12345678\n\
00081 int32 INT32_Z=12345678\n\
00082 uint32 UINT32_X=0\n\
00083 uint32 UINT32_Y=12345678\n\
00084 uint32 UINT32_Z=1\n\
00085 float32 FLOAT32_X=0.0\n\
00086 float32 FLOAT32_Y=-3.14159\n\
00087 float32 FLOAT32_Z=12345.78\n\
00088 byte SELECT_X=1\n\
00089 byte SELECT_Y=2\n\
00090 byte SELECT_Z=3\n\
00091 byte selection\n\
00092 \n\
00093 "; }
00094 public:
00095 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00096
00097 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00098
00099 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00100 {
00101 ros::serialization::OStream stream(write_ptr, 1000000000);
00102 ros::serialization::serialize(stream, selection);
00103 return stream.getData();
00104 }
00105
00106 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00107 {
00108 ros::serialization::IStream stream(read_ptr, 1000000000);
00109 ros::serialization::deserialize(stream, selection);
00110 return stream.getData();
00111 }
00112
00113 ROS_DEPRECATED virtual uint32_t serializationLength() const
00114 {
00115 uint32_t size = 0;
00116 size += ros::serialization::serializationLength(selection);
00117 return size;
00118 }
00119
00120 typedef boost::shared_ptr< ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> > Ptr;
00121 typedef boost::shared_ptr< ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> const> ConstPtr;
00122 };
00123 typedef ::test_rospy::ConstantsMultiplexRequest_<std::allocator<void> > ConstantsMultiplexRequest;
00124
00125 typedef boost::shared_ptr< ::test_rospy::ConstantsMultiplexRequest> ConstantsMultiplexRequestPtr;
00126 typedef boost::shared_ptr< ::test_rospy::ConstantsMultiplexRequest const> ConstantsMultiplexRequestConstPtr;
00127
00128
00129 template <class ContainerAllocator>
00130 struct ConstantsMultiplexResponse_ : public ros::Message
00131 {
00132 typedef ConstantsMultiplexResponse_<ContainerAllocator> Type;
00133
00134 ConstantsMultiplexResponse_()
00135 : select_confirm(0)
00136 , ret_byte(0)
00137 , ret_int32(0)
00138 , ret_uint32(0)
00139 , ret_float32(0.0)
00140 {
00141 }
00142
00143 ConstantsMultiplexResponse_(const ContainerAllocator& _alloc)
00144 : select_confirm(0)
00145 , ret_byte(0)
00146 , ret_int32(0)
00147 , ret_uint32(0)
00148 , ret_float32(0.0)
00149 {
00150 }
00151
00152 typedef int8_t _select_confirm_type;
00153 int8_t select_confirm;
00154
00155 typedef int8_t _ret_byte_type;
00156 int8_t ret_byte;
00157
00158 typedef int32_t _ret_int32_type;
00159 int32_t ret_int32;
00160
00161 typedef uint32_t _ret_uint32_type;
00162 uint32_t ret_uint32;
00163
00164 typedef float _ret_float32_type;
00165 float ret_float32;
00166
00167 enum { CONFIRM_X = 1 };
00168 enum { CONFIRM_Y = 2 };
00169 enum { CONFIRM_Z = 3 };
00170
00171 private:
00172 static const char* __s_getDataType_() { return "test_rospy/ConstantsMultiplexResponse"; }
00173 public:
00174 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00175
00176 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00177
00178 private:
00179 static const char* __s_getMD5Sum_() { return "012320975f41b58dcffb5b0e7a154691"; }
00180 public:
00181 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00182
00183 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00184
00185 private:
00186 static const char* __s_getServerMD5Sum_() { return "bab86066b3f7801cb25df3932f644396"; }
00187 public:
00188 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00189
00190 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00191
00192 private:
00193 static const char* __s_getMessageDefinition_() { return "\n\
00194 byte CONFIRM_X=1\n\
00195 byte CONFIRM_Y=2\n\
00196 byte CONFIRM_Z=3\n\
00197 byte select_confirm\n\
00198 byte ret_byte\n\
00199 int32 ret_int32\n\
00200 uint32 ret_uint32\n\
00201 float32 ret_float32\n\
00202 \n\
00203 "; }
00204 public:
00205 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00206
00207 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00208
00209 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00210 {
00211 ros::serialization::OStream stream(write_ptr, 1000000000);
00212 ros::serialization::serialize(stream, select_confirm);
00213 ros::serialization::serialize(stream, ret_byte);
00214 ros::serialization::serialize(stream, ret_int32);
00215 ros::serialization::serialize(stream, ret_uint32);
00216 ros::serialization::serialize(stream, ret_float32);
00217 return stream.getData();
00218 }
00219
00220 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00221 {
00222 ros::serialization::IStream stream(read_ptr, 1000000000);
00223 ros::serialization::deserialize(stream, select_confirm);
00224 ros::serialization::deserialize(stream, ret_byte);
00225 ros::serialization::deserialize(stream, ret_int32);
00226 ros::serialization::deserialize(stream, ret_uint32);
00227 ros::serialization::deserialize(stream, ret_float32);
00228 return stream.getData();
00229 }
00230
00231 ROS_DEPRECATED virtual uint32_t serializationLength() const
00232 {
00233 uint32_t size = 0;
00234 size += ros::serialization::serializationLength(select_confirm);
00235 size += ros::serialization::serializationLength(ret_byte);
00236 size += ros::serialization::serializationLength(ret_int32);
00237 size += ros::serialization::serializationLength(ret_uint32);
00238 size += ros::serialization::serializationLength(ret_float32);
00239 return size;
00240 }
00241
00242 typedef boost::shared_ptr< ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> > Ptr;
00243 typedef boost::shared_ptr< ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> const> ConstPtr;
00244 };
00245 typedef ::test_rospy::ConstantsMultiplexResponse_<std::allocator<void> > ConstantsMultiplexResponse;
00246
00247 typedef boost::shared_ptr< ::test_rospy::ConstantsMultiplexResponse> ConstantsMultiplexResponsePtr;
00248 typedef boost::shared_ptr< ::test_rospy::ConstantsMultiplexResponse const> ConstantsMultiplexResponseConstPtr;
00249
00250 struct ConstantsMultiplex
00251 {
00252
00253 typedef ConstantsMultiplexRequest Request;
00254 typedef ConstantsMultiplexResponse Response;
00255 Request request;
00256 Response response;
00257
00258 typedef Request RequestType;
00259 typedef Response ResponseType;
00260 };
00261 }
00262
00263 namespace ros
00264 {
00265 namespace message_traits
00266 {
00267 template<class ContainerAllocator>
00268 struct MD5Sum< ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> > {
00269 static const char* value()
00270 {
00271 return "3e3b2ecf5f3e7d25830bd97a7fd13b17";
00272 }
00273
00274 static const char* value(const ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> &) { return value(); }
00275 static const uint64_t static_value1 = 0x3e3b2ecf5f3e7d25ULL;
00276 static const uint64_t static_value2 = 0x830bd97a7fd13b17ULL;
00277 };
00278
00279 template<class ContainerAllocator>
00280 struct DataType< ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> > {
00281 static const char* value()
00282 {
00283 return "test_rospy/ConstantsMultiplexRequest";
00284 }
00285
00286 static const char* value(const ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> &) { return value(); }
00287 };
00288
00289 template<class ContainerAllocator>
00290 struct Definition< ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> > {
00291 static const char* value()
00292 {
00293 return "byte BYTE_X=0\n\
00294 byte BYTE_Y=15\n\
00295 byte BYTE_Z=5\n\
00296 int32 INT32_X=0\n\
00297 int32 INT32_Y=-12345678\n\
00298 int32 INT32_Z=12345678\n\
00299 uint32 UINT32_X=0\n\
00300 uint32 UINT32_Y=12345678\n\
00301 uint32 UINT32_Z=1\n\
00302 float32 FLOAT32_X=0.0\n\
00303 float32 FLOAT32_Y=-3.14159\n\
00304 float32 FLOAT32_Z=12345.78\n\
00305 byte SELECT_X=1\n\
00306 byte SELECT_Y=2\n\
00307 byte SELECT_Z=3\n\
00308 byte selection\n\
00309 \n\
00310 ";
00311 }
00312
00313 static const char* value(const ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> &) { return value(); }
00314 };
00315
00316 template<class ContainerAllocator> struct IsFixedSize< ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> > : public TrueType {};
00317 }
00318 }
00319
00320
00321 namespace ros
00322 {
00323 namespace message_traits
00324 {
00325 template<class ContainerAllocator>
00326 struct MD5Sum< ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> > {
00327 static const char* value()
00328 {
00329 return "012320975f41b58dcffb5b0e7a154691";
00330 }
00331
00332 static const char* value(const ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> &) { return value(); }
00333 static const uint64_t static_value1 = 0x012320975f41b58dULL;
00334 static const uint64_t static_value2 = 0xcffb5b0e7a154691ULL;
00335 };
00336
00337 template<class ContainerAllocator>
00338 struct DataType< ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> > {
00339 static const char* value()
00340 {
00341 return "test_rospy/ConstantsMultiplexResponse";
00342 }
00343
00344 static const char* value(const ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> &) { return value(); }
00345 };
00346
00347 template<class ContainerAllocator>
00348 struct Definition< ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> > {
00349 static const char* value()
00350 {
00351 return "\n\
00352 byte CONFIRM_X=1\n\
00353 byte CONFIRM_Y=2\n\
00354 byte CONFIRM_Z=3\n\
00355 byte select_confirm\n\
00356 byte ret_byte\n\
00357 int32 ret_int32\n\
00358 uint32 ret_uint32\n\
00359 float32 ret_float32\n\
00360 \n\
00361 ";
00362 }
00363
00364 static const char* value(const ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> &) { return value(); }
00365 };
00366
00367 template<class ContainerAllocator> struct IsFixedSize< ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> > : public TrueType {};
00368 }
00369 }
00370
00371 namespace ros
00372 {
00373 namespace serialization
00374 {
00375
00376 template<class ContainerAllocator> struct Serializer< ::test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> >
00377 {
00378 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00379 {
00380 stream.next(m.selection);
00381 }
00382
00383 ROS_DECLARE_ALLINONE_SERIALIZER;
00384 };
00385 }
00386 }
00387
00388
00389 namespace ros
00390 {
00391 namespace serialization
00392 {
00393
00394 template<class ContainerAllocator> struct Serializer< ::test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> >
00395 {
00396 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00397 {
00398 stream.next(m.select_confirm);
00399 stream.next(m.ret_byte);
00400 stream.next(m.ret_int32);
00401 stream.next(m.ret_uint32);
00402 stream.next(m.ret_float32);
00403 }
00404
00405 ROS_DECLARE_ALLINONE_SERIALIZER;
00406 };
00407 }
00408 }
00409
00410 namespace ros
00411 {
00412 namespace service_traits
00413 {
00414 template<>
00415 struct MD5Sum<test_rospy::ConstantsMultiplex> {
00416 static const char* value()
00417 {
00418 return "bab86066b3f7801cb25df3932f644396";
00419 }
00420
00421 static const char* value(const test_rospy::ConstantsMultiplex&) { return value(); }
00422 };
00423
00424 template<>
00425 struct DataType<test_rospy::ConstantsMultiplex> {
00426 static const char* value()
00427 {
00428 return "test_rospy/ConstantsMultiplex";
00429 }
00430
00431 static const char* value(const test_rospy::ConstantsMultiplex&) { return value(); }
00432 };
00433
00434 template<class ContainerAllocator>
00435 struct MD5Sum<test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> > {
00436 static const char* value()
00437 {
00438 return "bab86066b3f7801cb25df3932f644396";
00439 }
00440
00441 static const char* value(const test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> &) { return value(); }
00442 };
00443
00444 template<class ContainerAllocator>
00445 struct DataType<test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> > {
00446 static const char* value()
00447 {
00448 return "test_rospy/ConstantsMultiplex";
00449 }
00450
00451 static const char* value(const test_rospy::ConstantsMultiplexRequest_<ContainerAllocator> &) { return value(); }
00452 };
00453
00454 template<class ContainerAllocator>
00455 struct MD5Sum<test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> > {
00456 static const char* value()
00457 {
00458 return "bab86066b3f7801cb25df3932f644396";
00459 }
00460
00461 static const char* value(const test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> &) { return value(); }
00462 };
00463
00464 template<class ContainerAllocator>
00465 struct DataType<test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> > {
00466 static const char* value()
00467 {
00468 return "test_rospy/ConstantsMultiplex";
00469 }
00470
00471 static const char* value(const test_rospy::ConstantsMultiplexResponse_<ContainerAllocator> &) { return value(); }
00472 };
00473
00474 }
00475 }
00476
00477 #endif // TEST_ROSPY_SERVICE_CONSTANTSMULTIPLEX_H
00478