skin_driver: skin_serv.h Source File

00001 /* Auto-generated by genmsg_cpp for file /tmp/buildd/ros-diamondback-bosch-skin-0.3.0/debian/ros-diamondback-bosch-skin/opt/ros/diamondback/stacks/bosch_skin/skin_driver/srv/skin_serv.srv */
00002 #ifndef SKIN_DRIVER_SERVICE_SKIN_SERV_H
00003 #define SKIN_DRIVER_SERVICE_SKIN_SERV_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 "std_msgs/Header.h"
00016 
00017 
00018 
00019 namespace skin_driver
00020 {
00021 template <class ContainerAllocator>
00022 struct skin_servRequest_ : public ros::Message
00023 {
00024   typedef skin_servRequest_<ContainerAllocator> Type;
00025 
00026   skin_servRequest_()
00027   : header()
00028   , start_adr_srv()
00029   , steps_srv(0)
00030   , number_of_bytes_srv(0)
00031   , write_data_srv(0)
00032   , sens_num_change_srv(false)
00033   {
00034     start_adr_srv.assign(0);
00035   }
00036 
00037   skin_servRequest_(const ContainerAllocator& _alloc)
00038   : header(_alloc)
00039   , start_adr_srv()
00040   , steps_srv(0)
00041   , number_of_bytes_srv(0)
00042   , write_data_srv(0)
00043   , sens_num_change_srv(false)
00044   {
00045     start_adr_srv.assign(0);
00046   }
00047 
00048   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
00049    ::std_msgs::Header_<ContainerAllocator>  header;
00050 
00051   typedef boost::array<uint8_t, 2>  _start_adr_srv_type;
00052   boost::array<uint8_t, 2>  start_adr_srv;
00053 
00054   typedef uint8_t _steps_srv_type;
00055   uint8_t steps_srv;
00056 
00057   typedef uint8_t _number_of_bytes_srv_type;
00058   uint8_t number_of_bytes_srv;
00059 
00060   typedef uint8_t _write_data_srv_type;
00061   uint8_t write_data_srv;
00062 
00063   typedef uint8_t _sens_num_change_srv_type;
00064   uint8_t sens_num_change_srv;
00065 
00066 
00067   ROS_DEPRECATED uint32_t get_start_adr_srv_size() const { return (uint32_t)start_adr_srv.size(); }
00068 private:
00069   static const char* __s_getDataType_() { return "skin_driver/skin_servRequest"; }
00070 public:
00071   ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00072 
00073   ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00074 
00075 private:
00076   static const char* __s_getMD5Sum_() { return "ca8b49415ecb6bb0f200f0e59a391254"; }
00077 public:
00078   ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00079 
00080   ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00081 
00082 private:
00083   static const char* __s_getServerMD5Sum_() { return "cfb180e1a366406c8afa96b879bd7907"; }
00084 public:
00085   ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00086 
00087   ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00088 
00089 private:
00090   static const char* __s_getMessageDefinition_() { return "Header header\n\
00091 uint8[2] start_adr_srv\n\
00092 uint8 steps_srv\n\
00093 uint8 number_of_bytes_srv\n\
00094 uint8 write_data_srv\n\
00095 bool sens_num_change_srv\n\
00096 \n\
00097 ================================================================================\n\
00098 MSG: std_msgs/Header\n\
00099 # Standard metadata for higher-level stamped data types.\n\
00100 # This is generally used to communicate timestamped data \n\
00101 # in a particular coordinate frame.\n\
00102 # \n\
00103 # sequence ID: consecutively increasing ID \n\
00104 uint32 seq\n\
00105 #Two-integer timestamp that is expressed as:\n\
00106 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00107 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00108 # time-handling sugar is provided by the client library\n\
00109 time stamp\n\
00110 #Frame this data is associated with\n\
00111 # 0: no frame\n\
00112 # 1: global frame\n\
00113 string frame_id\n\
00114 \n\
00115 "; }
00116 public:
00117   ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00118 
00119   ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00120 
00121   ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00122   {
00123     ros::serialization::OStream stream(write_ptr, 1000000000);
00124     ros::serialization::serialize(stream, header);
00125     ros::serialization::serialize(stream, start_adr_srv);
00126     ros::serialization::serialize(stream, steps_srv);
00127     ros::serialization::serialize(stream, number_of_bytes_srv);
00128     ros::serialization::serialize(stream, write_data_srv);
00129     ros::serialization::serialize(stream, sens_num_change_srv);
00130     return stream.getData();
00131   }
00132 
00133   ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00134   {
00135     ros::serialization::IStream stream(read_ptr, 1000000000);
00136     ros::serialization::deserialize(stream, header);
00137     ros::serialization::deserialize(stream, start_adr_srv);
00138     ros::serialization::deserialize(stream, steps_srv);
00139     ros::serialization::deserialize(stream, number_of_bytes_srv);
00140     ros::serialization::deserialize(stream, write_data_srv);
00141     ros::serialization::deserialize(stream, sens_num_change_srv);
00142     return stream.getData();
00143   }
00144 
00145   ROS_DEPRECATED virtual uint32_t serializationLength() const
00146   {
00147     uint32_t size = 0;
00148     size += ros::serialization::serializationLength(header);
00149     size += ros::serialization::serializationLength(start_adr_srv);
00150     size += ros::serialization::serializationLength(steps_srv);
00151     size += ros::serialization::serializationLength(number_of_bytes_srv);
00152     size += ros::serialization::serializationLength(write_data_srv);
00153     size += ros::serialization::serializationLength(sens_num_change_srv);
00154     return size;
00155   }
00156 
00157   typedef boost::shared_ptr< ::skin_driver::skin_servRequest_<ContainerAllocator> > Ptr;
00158   typedef boost::shared_ptr< ::skin_driver::skin_servRequest_<ContainerAllocator>  const> ConstPtr;
00159 }; // struct skin_servRequest
00160 typedef  ::skin_driver::skin_servRequest_<std::allocator<void> > skin_servRequest;
00161 
00162 typedef boost::shared_ptr< ::skin_driver::skin_servRequest> skin_servRequestPtr;
00163 typedef boost::shared_ptr< ::skin_driver::skin_servRequest const> skin_servRequestConstPtr;
00164 
00165 
00166 template <class ContainerAllocator>
00167 struct skin_servResponse_ : public ros::Message
00168 {
00169   typedef skin_servResponse_<ContainerAllocator> Type;
00170 
00171   skin_servResponse_()
00172   : write_to_skin_successful_srv(false)
00173   {
00174   }
00175 
00176   skin_servResponse_(const ContainerAllocator& _alloc)
00177   : write_to_skin_successful_srv(false)
00178   {
00179   }
00180 
00181   typedef uint8_t _write_to_skin_successful_srv_type;
00182   uint8_t write_to_skin_successful_srv;
00183 
00184 
00185 private:
00186   static const char* __s_getDataType_() { return "skin_driver/skin_servResponse"; }
00187 public:
00188   ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00189 
00190   ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00191 
00192 private:
00193   static const char* __s_getMD5Sum_() { return "797c895957d36a7e6728dfad8a8ae3cb"; }
00194 public:
00195   ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00196 
00197   ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00198 
00199 private:
00200   static const char* __s_getServerMD5Sum_() { return "cfb180e1a366406c8afa96b879bd7907"; }
00201 public:
00202   ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00203 
00204   ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00205 
00206 private:
00207   static const char* __s_getMessageDefinition_() { return "bool write_to_skin_successful_srv\n\
00208 \n\
00209 \n\
00210 "; }
00211 public:
00212   ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00213 
00214   ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00215 
00216   ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00217   {
00218     ros::serialization::OStream stream(write_ptr, 1000000000);
00219     ros::serialization::serialize(stream, write_to_skin_successful_srv);
00220     return stream.getData();
00221   }
00222 
00223   ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00224   {
00225     ros::serialization::IStream stream(read_ptr, 1000000000);
00226     ros::serialization::deserialize(stream, write_to_skin_successful_srv);
00227     return stream.getData();
00228   }
00229 
00230   ROS_DEPRECATED virtual uint32_t serializationLength() const
00231   {
00232     uint32_t size = 0;
00233     size += ros::serialization::serializationLength(write_to_skin_successful_srv);
00234     return size;
00235   }
00236 
00237   typedef boost::shared_ptr< ::skin_driver::skin_servResponse_<ContainerAllocator> > Ptr;
00238   typedef boost::shared_ptr< ::skin_driver::skin_servResponse_<ContainerAllocator>  const> ConstPtr;
00239 }; // struct skin_servResponse
00240 typedef  ::skin_driver::skin_servResponse_<std::allocator<void> > skin_servResponse;
00241 
00242 typedef boost::shared_ptr< ::skin_driver::skin_servResponse> skin_servResponsePtr;
00243 typedef boost::shared_ptr< ::skin_driver::skin_servResponse const> skin_servResponseConstPtr;
00244 
00245 struct skin_serv
00246 {
00247 
00248 typedef skin_servRequest Request;
00249 typedef skin_servResponse Response;
00250 Request request;
00251 Response response;
00252 
00253 typedef Request RequestType;
00254 typedef Response ResponseType;
00255 }; // struct skin_serv
00256 } // namespace skin_driver
00257 
00258 namespace ros
00259 {
00260 namespace message_traits
00261 {
00262 template<class ContainerAllocator>
00263 struct MD5Sum< ::skin_driver::skin_servRequest_<ContainerAllocator> > {
00264   static const char* value() 
00265   {
00266     return "ca8b49415ecb6bb0f200f0e59a391254";
00267   }
00268 
00269   static const char* value(const  ::skin_driver::skin_servRequest_<ContainerAllocator> &) { return value(); } 
00270   static const uint64_t static_value1 = 0xca8b49415ecb6bb0ULL;
00271   static const uint64_t static_value2 = 0xf200f0e59a391254ULL;
00272 };
00273 
00274 template<class ContainerAllocator>
00275 struct DataType< ::skin_driver::skin_servRequest_<ContainerAllocator> > {
00276   static const char* value() 
00277   {
00278     return "skin_driver/skin_servRequest";
00279   }
00280 
00281   static const char* value(const  ::skin_driver::skin_servRequest_<ContainerAllocator> &) { return value(); } 
00282 };
00283 
00284 template<class ContainerAllocator>
00285 struct Definition< ::skin_driver::skin_servRequest_<ContainerAllocator> > {
00286   static const char* value() 
00287   {
00288     return "Header header\n\
00289 uint8[2] start_adr_srv\n\
00290 uint8 steps_srv\n\
00291 uint8 number_of_bytes_srv\n\
00292 uint8 write_data_srv\n\
00293 bool sens_num_change_srv\n\
00294 \n\
00295 ================================================================================\n\
00296 MSG: std_msgs/Header\n\
00297 # Standard metadata for higher-level stamped data types.\n\
00298 # This is generally used to communicate timestamped data \n\
00299 # in a particular coordinate frame.\n\
00300 # \n\
00301 # sequence ID: consecutively increasing ID \n\
00302 uint32 seq\n\
00303 #Two-integer timestamp that is expressed as:\n\
00304 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00305 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00306 # time-handling sugar is provided by the client library\n\
00307 time stamp\n\
00308 #Frame this data is associated with\n\
00309 # 0: no frame\n\
00310 # 1: global frame\n\
00311 string frame_id\n\
00312 \n\
00313 ";
00314   }
00315 
00316   static const char* value(const  ::skin_driver::skin_servRequest_<ContainerAllocator> &) { return value(); } 
00317 };
00318 
00319 template<class ContainerAllocator> struct HasHeader< ::skin_driver::skin_servRequest_<ContainerAllocator> > : public TrueType {};
00320 template<class ContainerAllocator> struct HasHeader< const ::skin_driver::skin_servRequest_<ContainerAllocator> > : public TrueType {};
00321 } // namespace message_traits
00322 } // namespace ros
00323 
00324 
00325 namespace ros
00326 {
00327 namespace message_traits
00328 {
00329 template<class ContainerAllocator>
00330 struct MD5Sum< ::skin_driver::skin_servResponse_<ContainerAllocator> > {
00331   static const char* value() 
00332   {
00333     return "797c895957d36a7e6728dfad8a8ae3cb";
00334   }
00335 
00336   static const char* value(const  ::skin_driver::skin_servResponse_<ContainerAllocator> &) { return value(); } 
00337   static const uint64_t static_value1 = 0x797c895957d36a7eULL;
00338   static const uint64_t static_value2 = 0x6728dfad8a8ae3cbULL;
00339 };
00340 
00341 template<class ContainerAllocator>
00342 struct DataType< ::skin_driver::skin_servResponse_<ContainerAllocator> > {
00343   static const char* value() 
00344   {
00345     return "skin_driver/skin_servResponse";
00346   }
00347 
00348   static const char* value(const  ::skin_driver::skin_servResponse_<ContainerAllocator> &) { return value(); } 
00349 };
00350 
00351 template<class ContainerAllocator>
00352 struct Definition< ::skin_driver::skin_servResponse_<ContainerAllocator> > {
00353   static const char* value() 
00354   {
00355     return "bool write_to_skin_successful_srv\n\
00356 \n\
00357 \n\
00358 ";
00359   }
00360 
00361   static const char* value(const  ::skin_driver::skin_servResponse_<ContainerAllocator> &) { return value(); } 
00362 };
00363 
00364 template<class ContainerAllocator> struct IsFixedSize< ::skin_driver::skin_servResponse_<ContainerAllocator> > : public TrueType {};
00365 } // namespace message_traits
00366 } // namespace ros
00367 
00368 namespace ros
00369 {
00370 namespace serialization
00371 {
00372 
00373 template<class ContainerAllocator> struct Serializer< ::skin_driver::skin_servRequest_<ContainerAllocator> >
00374 {
00375   template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00376   {
00377     stream.next(m.header);
00378     stream.next(m.start_adr_srv);
00379     stream.next(m.steps_srv);
00380     stream.next(m.number_of_bytes_srv);
00381     stream.next(m.write_data_srv);
00382     stream.next(m.sens_num_change_srv);
00383   }
00384 
00385   ROS_DECLARE_ALLINONE_SERIALIZER;
00386 }; // struct skin_servRequest_
00387 } // namespace serialization
00388 } // namespace ros
00389 
00390 
00391 namespace ros
00392 {
00393 namespace serialization
00394 {
00395 
00396 template<class ContainerAllocator> struct Serializer< ::skin_driver::skin_servResponse_<ContainerAllocator> >
00397 {
00398   template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00399   {
00400     stream.next(m.write_to_skin_successful_srv);
00401   }
00402 
00403   ROS_DECLARE_ALLINONE_SERIALIZER;
00404 }; // struct skin_servResponse_
00405 } // namespace serialization
00406 } // namespace ros
00407 
00408 namespace ros
00409 {
00410 namespace service_traits
00411 {
00412 template<>
00413 struct MD5Sum<skin_driver::skin_serv> {
00414   static const char* value() 
00415   {
00416     return "cfb180e1a366406c8afa96b879bd7907";
00417   }
00418 
00419   static const char* value(const skin_driver::skin_serv&) { return value(); } 
00420 };
00421 
00422 template<>
00423 struct DataType<skin_driver::skin_serv> {
00424   static const char* value() 
00425   {
00426     return "skin_driver/skin_serv";
00427   }
00428 
00429   static const char* value(const skin_driver::skin_serv&) { return value(); } 
00430 };
00431 
00432 template<class ContainerAllocator>
00433 struct MD5Sum<skin_driver::skin_servRequest_<ContainerAllocator> > {
00434   static const char* value() 
00435   {
00436     return "cfb180e1a366406c8afa96b879bd7907";
00437   }
00438 
00439   static const char* value(const skin_driver::skin_servRequest_<ContainerAllocator> &) { return value(); } 
00440 };
00441 
00442 template<class ContainerAllocator>
00443 struct DataType<skin_driver::skin_servRequest_<ContainerAllocator> > {
00444   static const char* value() 
00445   {
00446     return "skin_driver/skin_serv";
00447   }
00448 
00449   static const char* value(const skin_driver::skin_servRequest_<ContainerAllocator> &) { return value(); } 
00450 };
00451 
00452 template<class ContainerAllocator>
00453 struct MD5Sum<skin_driver::skin_servResponse_<ContainerAllocator> > {
00454   static const char* value() 
00455   {
00456     return "cfb180e1a366406c8afa96b879bd7907";
00457   }
00458 
00459   static const char* value(const skin_driver::skin_servResponse_<ContainerAllocator> &) { return value(); } 
00460 };
00461 
00462 template<class ContainerAllocator>
00463 struct DataType<skin_driver::skin_servResponse_<ContainerAllocator> > {
00464   static const char* value() 
00465   {
00466     return "skin_driver/skin_serv";
00467   }
00468 
00469   static const char* value(const skin_driver::skin_servResponse_<ContainerAllocator> &) { return value(); } 
00470 };
00471 
00472 } // namespace service_traits
00473 } // namespace ros
00474 
00475 #endif // SKIN_DRIVER_SERVICE_SKIN_SERV_H
00476