00001
00002 #ifndef TEST_ROSLISP_SERVICE_TEST_H
00003 #define TEST_ROSLISP_SERVICE_TEST_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 #include "test_roslisp/TwoInts.h"
00016
00017
00018
00019 namespace test_roslisp
00020 {
00021 template <class ContainerAllocator>
00022 struct TestRequest_ : public ros::Message
00023 {
00024 typedef TestRequest_<ContainerAllocator> Type;
00025
00026 TestRequest_()
00027 : m()
00028 {
00029 }
00030
00031 TestRequest_(const ContainerAllocator& _alloc)
00032 : m(_alloc)
00033 {
00034 }
00035
00036 typedef ::test_roslisp::TwoInts_<ContainerAllocator> _m_type;
00037 ::test_roslisp::TwoInts_<ContainerAllocator> m;
00038
00039
00040 private:
00041 static const char* __s_getDataType_() { return "test_roslisp/TestRequest"; }
00042 public:
00043 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00044
00045 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00046
00047 private:
00048 static const char* __s_getMD5Sum_() { return "5d7b4abd379a003f0e74b4d5f3491f60"; }
00049 public:
00050 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00051
00052 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00053
00054 private:
00055 static const char* __s_getServerMD5Sum_() { return "2e11e73de6ca62ddbaed898362aba0ad"; }
00056 public:
00057 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00058
00059 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00060
00061 private:
00062 static const char* __s_getMessageDefinition_() { return "test_roslisp/TwoInts m\n\
00063 \n\
00064 ================================================================================\n\
00065 MSG: test_roslisp/TwoInts\n\
00066 std_msgs/Int16 a\n\
00067 std_msgs/Int16 b\n\
00068 \n\
00069 ================================================================================\n\
00070 MSG: std_msgs/Int16\n\
00071 int16 data\n\
00072 \n\
00073 "; }
00074 public:
00075 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00076
00077 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00078
00079 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00080 {
00081 ros::serialization::OStream stream(write_ptr, 1000000000);
00082 ros::serialization::serialize(stream, m);
00083 return stream.getData();
00084 }
00085
00086 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00087 {
00088 ros::serialization::IStream stream(read_ptr, 1000000000);
00089 ros::serialization::deserialize(stream, m);
00090 return stream.getData();
00091 }
00092
00093 ROS_DEPRECATED virtual uint32_t serializationLength() const
00094 {
00095 uint32_t size = 0;
00096 size += ros::serialization::serializationLength(m);
00097 return size;
00098 }
00099
00100 typedef boost::shared_ptr< ::test_roslisp::TestRequest_<ContainerAllocator> > Ptr;
00101 typedef boost::shared_ptr< ::test_roslisp::TestRequest_<ContainerAllocator> const> ConstPtr;
00102 };
00103 typedef ::test_roslisp::TestRequest_<std::allocator<void> > TestRequest;
00104
00105 typedef boost::shared_ptr< ::test_roslisp::TestRequest> TestRequestPtr;
00106 typedef boost::shared_ptr< ::test_roslisp::TestRequest const> TestRequestConstPtr;
00107
00108
00109 template <class ContainerAllocator>
00110 struct TestResponse_ : public ros::Message
00111 {
00112 typedef TestResponse_<ContainerAllocator> Type;
00113
00114 TestResponse_()
00115 : sum(0)
00116 {
00117 }
00118
00119 TestResponse_(const ContainerAllocator& _alloc)
00120 : sum(0)
00121 {
00122 }
00123
00124 typedef int64_t _sum_type;
00125 int64_t sum;
00126
00127
00128 private:
00129 static const char* __s_getDataType_() { return "test_roslisp/TestResponse"; }
00130 public:
00131 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00132
00133 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00134
00135 private:
00136 static const char* __s_getMD5Sum_() { return "b88405221c77b1878a3cbbfff53428d7"; }
00137 public:
00138 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00139
00140 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00141
00142 private:
00143 static const char* __s_getServerMD5Sum_() { return "2e11e73de6ca62ddbaed898362aba0ad"; }
00144 public:
00145 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00146
00147 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00148
00149 private:
00150 static const char* __s_getMessageDefinition_() { return "int64 sum\n\
00151 \n\
00152 "; }
00153 public:
00154 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00155
00156 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00157
00158 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00159 {
00160 ros::serialization::OStream stream(write_ptr, 1000000000);
00161 ros::serialization::serialize(stream, sum);
00162 return stream.getData();
00163 }
00164
00165 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00166 {
00167 ros::serialization::IStream stream(read_ptr, 1000000000);
00168 ros::serialization::deserialize(stream, sum);
00169 return stream.getData();
00170 }
00171
00172 ROS_DEPRECATED virtual uint32_t serializationLength() const
00173 {
00174 uint32_t size = 0;
00175 size += ros::serialization::serializationLength(sum);
00176 return size;
00177 }
00178
00179 typedef boost::shared_ptr< ::test_roslisp::TestResponse_<ContainerAllocator> > Ptr;
00180 typedef boost::shared_ptr< ::test_roslisp::TestResponse_<ContainerAllocator> const> ConstPtr;
00181 };
00182 typedef ::test_roslisp::TestResponse_<std::allocator<void> > TestResponse;
00183
00184 typedef boost::shared_ptr< ::test_roslisp::TestResponse> TestResponsePtr;
00185 typedef boost::shared_ptr< ::test_roslisp::TestResponse const> TestResponseConstPtr;
00186
00187 struct Test
00188 {
00189
00190 typedef TestRequest Request;
00191 typedef TestResponse Response;
00192 Request request;
00193 Response response;
00194
00195 typedef Request RequestType;
00196 typedef Response ResponseType;
00197 };
00198 }
00199
00200 namespace ros
00201 {
00202 namespace message_traits
00203 {
00204 template<class ContainerAllocator>
00205 struct MD5Sum< ::test_roslisp::TestRequest_<ContainerAllocator> > {
00206 static const char* value()
00207 {
00208 return "5d7b4abd379a003f0e74b4d5f3491f60";
00209 }
00210
00211 static const char* value(const ::test_roslisp::TestRequest_<ContainerAllocator> &) { return value(); }
00212 static const uint64_t static_value1 = 0x5d7b4abd379a003fULL;
00213 static const uint64_t static_value2 = 0x0e74b4d5f3491f60ULL;
00214 };
00215
00216 template<class ContainerAllocator>
00217 struct DataType< ::test_roslisp::TestRequest_<ContainerAllocator> > {
00218 static const char* value()
00219 {
00220 return "test_roslisp/TestRequest";
00221 }
00222
00223 static const char* value(const ::test_roslisp::TestRequest_<ContainerAllocator> &) { return value(); }
00224 };
00225
00226 template<class ContainerAllocator>
00227 struct Definition< ::test_roslisp::TestRequest_<ContainerAllocator> > {
00228 static const char* value()
00229 {
00230 return "test_roslisp/TwoInts m\n\
00231 \n\
00232 ================================================================================\n\
00233 MSG: test_roslisp/TwoInts\n\
00234 std_msgs/Int16 a\n\
00235 std_msgs/Int16 b\n\
00236 \n\
00237 ================================================================================\n\
00238 MSG: std_msgs/Int16\n\
00239 int16 data\n\
00240 \n\
00241 ";
00242 }
00243
00244 static const char* value(const ::test_roslisp::TestRequest_<ContainerAllocator> &) { return value(); }
00245 };
00246
00247 template<class ContainerAllocator> struct IsFixedSize< ::test_roslisp::TestRequest_<ContainerAllocator> > : public TrueType {};
00248 }
00249 }
00250
00251
00252 namespace ros
00253 {
00254 namespace message_traits
00255 {
00256 template<class ContainerAllocator>
00257 struct MD5Sum< ::test_roslisp::TestResponse_<ContainerAllocator> > {
00258 static const char* value()
00259 {
00260 return "b88405221c77b1878a3cbbfff53428d7";
00261 }
00262
00263 static const char* value(const ::test_roslisp::TestResponse_<ContainerAllocator> &) { return value(); }
00264 static const uint64_t static_value1 = 0xb88405221c77b187ULL;
00265 static const uint64_t static_value2 = 0x8a3cbbfff53428d7ULL;
00266 };
00267
00268 template<class ContainerAllocator>
00269 struct DataType< ::test_roslisp::TestResponse_<ContainerAllocator> > {
00270 static const char* value()
00271 {
00272 return "test_roslisp/TestResponse";
00273 }
00274
00275 static const char* value(const ::test_roslisp::TestResponse_<ContainerAllocator> &) { return value(); }
00276 };
00277
00278 template<class ContainerAllocator>
00279 struct Definition< ::test_roslisp::TestResponse_<ContainerAllocator> > {
00280 static const char* value()
00281 {
00282 return "int64 sum\n\
00283 \n\
00284 ";
00285 }
00286
00287 static const char* value(const ::test_roslisp::TestResponse_<ContainerAllocator> &) { return value(); }
00288 };
00289
00290 template<class ContainerAllocator> struct IsFixedSize< ::test_roslisp::TestResponse_<ContainerAllocator> > : public TrueType {};
00291 }
00292 }
00293
00294 namespace ros
00295 {
00296 namespace serialization
00297 {
00298
00299 template<class ContainerAllocator> struct Serializer< ::test_roslisp::TestRequest_<ContainerAllocator> >
00300 {
00301 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00302 {
00303 stream.next(m.m);
00304 }
00305
00306 ROS_DECLARE_ALLINONE_SERIALIZER;
00307 };
00308 }
00309 }
00310
00311
00312 namespace ros
00313 {
00314 namespace serialization
00315 {
00316
00317 template<class ContainerAllocator> struct Serializer< ::test_roslisp::TestResponse_<ContainerAllocator> >
00318 {
00319 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00320 {
00321 stream.next(m.sum);
00322 }
00323
00324 ROS_DECLARE_ALLINONE_SERIALIZER;
00325 };
00326 }
00327 }
00328
00329 namespace ros
00330 {
00331 namespace service_traits
00332 {
00333 template<>
00334 struct MD5Sum<test_roslisp::Test> {
00335 static const char* value()
00336 {
00337 return "2e11e73de6ca62ddbaed898362aba0ad";
00338 }
00339
00340 static const char* value(const test_roslisp::Test&) { return value(); }
00341 };
00342
00343 template<>
00344 struct DataType<test_roslisp::Test> {
00345 static const char* value()
00346 {
00347 return "test_roslisp/Test";
00348 }
00349
00350 static const char* value(const test_roslisp::Test&) { return value(); }
00351 };
00352
00353 template<class ContainerAllocator>
00354 struct MD5Sum<test_roslisp::TestRequest_<ContainerAllocator> > {
00355 static const char* value()
00356 {
00357 return "2e11e73de6ca62ddbaed898362aba0ad";
00358 }
00359
00360 static const char* value(const test_roslisp::TestRequest_<ContainerAllocator> &) { return value(); }
00361 };
00362
00363 template<class ContainerAllocator>
00364 struct DataType<test_roslisp::TestRequest_<ContainerAllocator> > {
00365 static const char* value()
00366 {
00367 return "test_roslisp/Test";
00368 }
00369
00370 static const char* value(const test_roslisp::TestRequest_<ContainerAllocator> &) { return value(); }
00371 };
00372
00373 template<class ContainerAllocator>
00374 struct MD5Sum<test_roslisp::TestResponse_<ContainerAllocator> > {
00375 static const char* value()
00376 {
00377 return "2e11e73de6ca62ddbaed898362aba0ad";
00378 }
00379
00380 static const char* value(const test_roslisp::TestResponse_<ContainerAllocator> &) { return value(); }
00381 };
00382
00383 template<class ContainerAllocator>
00384 struct DataType<test_roslisp::TestResponse_<ContainerAllocator> > {
00385 static const char* value()
00386 {
00387 return "test_roslisp/Test";
00388 }
00389
00390 static const char* value(const test_roslisp::TestResponse_<ContainerAllocator> &) { return value(); }
00391 };
00392
00393 }
00394 }
00395
00396 #endif // TEST_ROSLISP_SERVICE_TEST_H
00397