00001
00002 #ifndef LAUNCHMAN_SERVICE_STARTTASK_H
00003 #define LAUNCHMAN_SERVICE_STARTTASK_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 launchman
00019 {
00020 template <class ContainerAllocator>
00021 struct StartTaskRequest_ : public ros::Message
00022 {
00023 typedef StartTaskRequest_<ContainerAllocator> Type;
00024
00025 StartTaskRequest_()
00026 : taskid()
00027 , username()
00028 {
00029 }
00030
00031 StartTaskRequest_(const ContainerAllocator& _alloc)
00032 : taskid(_alloc)
00033 , username(_alloc)
00034 {
00035 }
00036
00037 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _taskid_type;
00038 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > taskid;
00039
00040 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _username_type;
00041 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > username;
00042
00043
00044 private:
00045 static const char* __s_getDataType_() { return "launchman/StartTaskRequest"; }
00046 public:
00047 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00048
00049 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00050
00051 private:
00052 static const char* __s_getMD5Sum_() { return "f90254a4a4912432fb92a8e890bdfbcd"; }
00053 public:
00054 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00055
00056 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00057
00058 private:
00059 static const char* __s_getServerMD5Sum_() { return "a7f7c2a0ff94dc94508b68c526bc0b69"; }
00060 public:
00061 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00062
00063 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00064
00065 private:
00066 static const char* __s_getMessageDefinition_() { return "string taskid\n\
00067 string username\n\
00068 \n\
00069 "; }
00070 public:
00071 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00072
00073 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00074
00075 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00076 {
00077 ros::serialization::OStream stream(write_ptr, 1000000000);
00078 ros::serialization::serialize(stream, taskid);
00079 ros::serialization::serialize(stream, username);
00080 return stream.getData();
00081 }
00082
00083 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00084 {
00085 ros::serialization::IStream stream(read_ptr, 1000000000);
00086 ros::serialization::deserialize(stream, taskid);
00087 ros::serialization::deserialize(stream, username);
00088 return stream.getData();
00089 }
00090
00091 ROS_DEPRECATED virtual uint32_t serializationLength() const
00092 {
00093 uint32_t size = 0;
00094 size += ros::serialization::serializationLength(taskid);
00095 size += ros::serialization::serializationLength(username);
00096 return size;
00097 }
00098
00099 typedef boost::shared_ptr< ::launchman::StartTaskRequest_<ContainerAllocator> > Ptr;
00100 typedef boost::shared_ptr< ::launchman::StartTaskRequest_<ContainerAllocator> const> ConstPtr;
00101 };
00102 typedef ::launchman::StartTaskRequest_<std::allocator<void> > StartTaskRequest;
00103
00104 typedef boost::shared_ptr< ::launchman::StartTaskRequest> StartTaskRequestPtr;
00105 typedef boost::shared_ptr< ::launchman::StartTaskRequest const> StartTaskRequestConstPtr;
00106
00107
00108 template <class ContainerAllocator>
00109 struct StartTaskResponse_ : public ros::Message
00110 {
00111 typedef StartTaskResponse_<ContainerAllocator> Type;
00112
00113 StartTaskResponse_()
00114 : status()
00115 {
00116 }
00117
00118 StartTaskResponse_(const ContainerAllocator& _alloc)
00119 : status(_alloc)
00120 {
00121 }
00122
00123 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _status_type;
00124 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > status;
00125
00126
00127 private:
00128 static const char* __s_getDataType_() { return "launchman/StartTaskResponse"; }
00129 public:
00130 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00131
00132 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00133
00134 private:
00135 static const char* __s_getMD5Sum_() { return "4fe5af303955c287688e7347e9b00278"; }
00136 public:
00137 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00138
00139 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00140
00141 private:
00142 static const char* __s_getServerMD5Sum_() { return "a7f7c2a0ff94dc94508b68c526bc0b69"; }
00143 public:
00144 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00145
00146 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00147
00148 private:
00149 static const char* __s_getMessageDefinition_() { return "string status\n\
00150 \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, status);
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, status);
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(status);
00176 return size;
00177 }
00178
00179 typedef boost::shared_ptr< ::launchman::StartTaskResponse_<ContainerAllocator> > Ptr;
00180 typedef boost::shared_ptr< ::launchman::StartTaskResponse_<ContainerAllocator> const> ConstPtr;
00181 };
00182 typedef ::launchman::StartTaskResponse_<std::allocator<void> > StartTaskResponse;
00183
00184 typedef boost::shared_ptr< ::launchman::StartTaskResponse> StartTaskResponsePtr;
00185 typedef boost::shared_ptr< ::launchman::StartTaskResponse const> StartTaskResponseConstPtr;
00186
00187 struct StartTask
00188 {
00189
00190 typedef StartTaskRequest Request;
00191 typedef StartTaskResponse 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< ::launchman::StartTaskRequest_<ContainerAllocator> > {
00206 static const char* value()
00207 {
00208 return "f90254a4a4912432fb92a8e890bdfbcd";
00209 }
00210
00211 static const char* value(const ::launchman::StartTaskRequest_<ContainerAllocator> &) { return value(); }
00212 static const uint64_t static_value1 = 0xf90254a4a4912432ULL;
00213 static const uint64_t static_value2 = 0xfb92a8e890bdfbcdULL;
00214 };
00215
00216 template<class ContainerAllocator>
00217 struct DataType< ::launchman::StartTaskRequest_<ContainerAllocator> > {
00218 static const char* value()
00219 {
00220 return "launchman/StartTaskRequest";
00221 }
00222
00223 static const char* value(const ::launchman::StartTaskRequest_<ContainerAllocator> &) { return value(); }
00224 };
00225
00226 template<class ContainerAllocator>
00227 struct Definition< ::launchman::StartTaskRequest_<ContainerAllocator> > {
00228 static const char* value()
00229 {
00230 return "string taskid\n\
00231 string username\n\
00232 \n\
00233 ";
00234 }
00235
00236 static const char* value(const ::launchman::StartTaskRequest_<ContainerAllocator> &) { return value(); }
00237 };
00238
00239 }
00240 }
00241
00242
00243 namespace ros
00244 {
00245 namespace message_traits
00246 {
00247 template<class ContainerAllocator>
00248 struct MD5Sum< ::launchman::StartTaskResponse_<ContainerAllocator> > {
00249 static const char* value()
00250 {
00251 return "4fe5af303955c287688e7347e9b00278";
00252 }
00253
00254 static const char* value(const ::launchman::StartTaskResponse_<ContainerAllocator> &) { return value(); }
00255 static const uint64_t static_value1 = 0x4fe5af303955c287ULL;
00256 static const uint64_t static_value2 = 0x688e7347e9b00278ULL;
00257 };
00258
00259 template<class ContainerAllocator>
00260 struct DataType< ::launchman::StartTaskResponse_<ContainerAllocator> > {
00261 static const char* value()
00262 {
00263 return "launchman/StartTaskResponse";
00264 }
00265
00266 static const char* value(const ::launchman::StartTaskResponse_<ContainerAllocator> &) { return value(); }
00267 };
00268
00269 template<class ContainerAllocator>
00270 struct Definition< ::launchman::StartTaskResponse_<ContainerAllocator> > {
00271 static const char* value()
00272 {
00273 return "string status\n\
00274 \n\
00275 \n\
00276 ";
00277 }
00278
00279 static const char* value(const ::launchman::StartTaskResponse_<ContainerAllocator> &) { return value(); }
00280 };
00281
00282 }
00283 }
00284
00285 namespace ros
00286 {
00287 namespace serialization
00288 {
00289
00290 template<class ContainerAllocator> struct Serializer< ::launchman::StartTaskRequest_<ContainerAllocator> >
00291 {
00292 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00293 {
00294 stream.next(m.taskid);
00295 stream.next(m.username);
00296 }
00297
00298 ROS_DECLARE_ALLINONE_SERIALIZER;
00299 };
00300 }
00301 }
00302
00303
00304 namespace ros
00305 {
00306 namespace serialization
00307 {
00308
00309 template<class ContainerAllocator> struct Serializer< ::launchman::StartTaskResponse_<ContainerAllocator> >
00310 {
00311 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00312 {
00313 stream.next(m.status);
00314 }
00315
00316 ROS_DECLARE_ALLINONE_SERIALIZER;
00317 };
00318 }
00319 }
00320
00321 namespace ros
00322 {
00323 namespace service_traits
00324 {
00325 template<>
00326 struct MD5Sum<launchman::StartTask> {
00327 static const char* value()
00328 {
00329 return "a7f7c2a0ff94dc94508b68c526bc0b69";
00330 }
00331
00332 static const char* value(const launchman::StartTask&) { return value(); }
00333 };
00334
00335 template<>
00336 struct DataType<launchman::StartTask> {
00337 static const char* value()
00338 {
00339 return "launchman/StartTask";
00340 }
00341
00342 static const char* value(const launchman::StartTask&) { return value(); }
00343 };
00344
00345 template<class ContainerAllocator>
00346 struct MD5Sum<launchman::StartTaskRequest_<ContainerAllocator> > {
00347 static const char* value()
00348 {
00349 return "a7f7c2a0ff94dc94508b68c526bc0b69";
00350 }
00351
00352 static const char* value(const launchman::StartTaskRequest_<ContainerAllocator> &) { return value(); }
00353 };
00354
00355 template<class ContainerAllocator>
00356 struct DataType<launchman::StartTaskRequest_<ContainerAllocator> > {
00357 static const char* value()
00358 {
00359 return "launchman/StartTask";
00360 }
00361
00362 static const char* value(const launchman::StartTaskRequest_<ContainerAllocator> &) { return value(); }
00363 };
00364
00365 template<class ContainerAllocator>
00366 struct MD5Sum<launchman::StartTaskResponse_<ContainerAllocator> > {
00367 static const char* value()
00368 {
00369 return "a7f7c2a0ff94dc94508b68c526bc0b69";
00370 }
00371
00372 static const char* value(const launchman::StartTaskResponse_<ContainerAllocator> &) { return value(); }
00373 };
00374
00375 template<class ContainerAllocator>
00376 struct DataType<launchman::StartTaskResponse_<ContainerAllocator> > {
00377 static const char* value()
00378 {
00379 return "launchman/StartTask";
00380 }
00381
00382 static const char* value(const launchman::StartTaskResponse_<ContainerAllocator> &) { return value(); }
00383 };
00384
00385 }
00386 }
00387
00388 #endif // LAUNCHMAN_SERVICE_STARTTASK_H
00389