Go to the documentation of this file.00001
00002 #ifndef ETHERCAT_HARDWARE_SERVICE_SOFTPROCESSORRESET_H
00003 #define ETHERCAT_HARDWARE_SERVICE_SOFTPROCESSORRESET_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
00020
00021
00022 namespace ethercat_hardware
00023 {
00024 template <class ContainerAllocator>
00025 struct SoftProcessorResetRequest_ {
00026 typedef SoftProcessorResetRequest_<ContainerAllocator> Type;
00027
00028 SoftProcessorResetRequest_()
00029 : actuator_name()
00030 , processor_name()
00031 {
00032 }
00033
00034 SoftProcessorResetRequest_(const ContainerAllocator& _alloc)
00035 : actuator_name(_alloc)
00036 , processor_name(_alloc)
00037 {
00038 }
00039
00040 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _actuator_name_type;
00041 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > actuator_name;
00042
00043 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _processor_name_type;
00044 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > processor_name;
00045
00046
00047 typedef boost::shared_ptr< ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> > Ptr;
00048 typedef boost::shared_ptr< ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> const> ConstPtr;
00049 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00050 };
00051 typedef ::ethercat_hardware::SoftProcessorResetRequest_<std::allocator<void> > SoftProcessorResetRequest;
00052
00053 typedef boost::shared_ptr< ::ethercat_hardware::SoftProcessorResetRequest> SoftProcessorResetRequestPtr;
00054 typedef boost::shared_ptr< ::ethercat_hardware::SoftProcessorResetRequest const> SoftProcessorResetRequestConstPtr;
00055
00056
00057
00058 template <class ContainerAllocator>
00059 struct SoftProcessorResetResponse_ {
00060 typedef SoftProcessorResetResponse_<ContainerAllocator> Type;
00061
00062 SoftProcessorResetResponse_()
00063 : success(false)
00064 , error_msg()
00065 {
00066 }
00067
00068 SoftProcessorResetResponse_(const ContainerAllocator& _alloc)
00069 : success(false)
00070 , error_msg(_alloc)
00071 {
00072 }
00073
00074 typedef uint8_t _success_type;
00075 uint8_t success;
00076
00077 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _error_msg_type;
00078 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > error_msg;
00079
00080
00081 typedef boost::shared_ptr< ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> > Ptr;
00082 typedef boost::shared_ptr< ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> const> ConstPtr;
00083 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00084 };
00085 typedef ::ethercat_hardware::SoftProcessorResetResponse_<std::allocator<void> > SoftProcessorResetResponse;
00086
00087 typedef boost::shared_ptr< ::ethercat_hardware::SoftProcessorResetResponse> SoftProcessorResetResponsePtr;
00088 typedef boost::shared_ptr< ::ethercat_hardware::SoftProcessorResetResponse const> SoftProcessorResetResponseConstPtr;
00089
00090
00091 struct SoftProcessorReset
00092 {
00093
00094 typedef SoftProcessorResetRequest Request;
00095 typedef SoftProcessorResetResponse Response;
00096 Request request;
00097 Response response;
00098
00099 typedef Request RequestType;
00100 typedef Response ResponseType;
00101 };
00102 }
00103
00104 namespace ros
00105 {
00106 namespace message_traits
00107 {
00108 template<class ContainerAllocator> struct IsMessage< ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> > : public TrueType {};
00109 template<class ContainerAllocator> struct IsMessage< ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> const> : public TrueType {};
00110 template<class ContainerAllocator>
00111 struct MD5Sum< ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> > {
00112 static const char* value()
00113 {
00114 return "777be25d71e9e85e62fa14223ffddb6b";
00115 }
00116
00117 static const char* value(const ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> &) { return value(); }
00118 static const uint64_t static_value1 = 0x777be25d71e9e85eULL;
00119 static const uint64_t static_value2 = 0x62fa14223ffddb6bULL;
00120 };
00121
00122 template<class ContainerAllocator>
00123 struct DataType< ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> > {
00124 static const char* value()
00125 {
00126 return "ethercat_hardware/SoftProcessorResetRequest";
00127 }
00128
00129 static const char* value(const ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> &) { return value(); }
00130 };
00131
00132 template<class ContainerAllocator>
00133 struct Definition< ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> > {
00134 static const char* value()
00135 {
00136 return "string actuator_name\n\
00137 string processor_name\n\
00138 \n\
00139 \n\
00140 ";
00141 }
00142
00143 static const char* value(const ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> &) { return value(); }
00144 };
00145
00146 }
00147 }
00148
00149
00150 namespace ros
00151 {
00152 namespace message_traits
00153 {
00154 template<class ContainerAllocator> struct IsMessage< ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> > : public TrueType {};
00155 template<class ContainerAllocator> struct IsMessage< ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> const> : public TrueType {};
00156 template<class ContainerAllocator>
00157 struct MD5Sum< ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> > {
00158 static const char* value()
00159 {
00160 return "d006c48be24db1173a071ca9af4c8179";
00161 }
00162
00163 static const char* value(const ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> &) { return value(); }
00164 static const uint64_t static_value1 = 0xd006c48be24db117ULL;
00165 static const uint64_t static_value2 = 0x3a071ca9af4c8179ULL;
00166 };
00167
00168 template<class ContainerAllocator>
00169 struct DataType< ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> > {
00170 static const char* value()
00171 {
00172 return "ethercat_hardware/SoftProcessorResetResponse";
00173 }
00174
00175 static const char* value(const ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> &) { return value(); }
00176 };
00177
00178 template<class ContainerAllocator>
00179 struct Definition< ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> > {
00180 static const char* value()
00181 {
00182 return "bool success\n\
00183 string error_msg\n\
00184 \n\
00185 \n\
00186 ";
00187 }
00188
00189 static const char* value(const ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> &) { return value(); }
00190 };
00191
00192 }
00193 }
00194
00195 namespace ros
00196 {
00197 namespace serialization
00198 {
00199
00200 template<class ContainerAllocator> struct Serializer< ::ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> >
00201 {
00202 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00203 {
00204 stream.next(m.actuator_name);
00205 stream.next(m.processor_name);
00206 }
00207
00208 ROS_DECLARE_ALLINONE_SERIALIZER;
00209 };
00210 }
00211 }
00212
00213
00214 namespace ros
00215 {
00216 namespace serialization
00217 {
00218
00219 template<class ContainerAllocator> struct Serializer< ::ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> >
00220 {
00221 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00222 {
00223 stream.next(m.success);
00224 stream.next(m.error_msg);
00225 }
00226
00227 ROS_DECLARE_ALLINONE_SERIALIZER;
00228 };
00229 }
00230 }
00231
00232 namespace ros
00233 {
00234 namespace service_traits
00235 {
00236 template<>
00237 struct MD5Sum<ethercat_hardware::SoftProcessorReset> {
00238 static const char* value()
00239 {
00240 return "338c1a9d2fcf7479cddb1ea63dbc8af9";
00241 }
00242
00243 static const char* value(const ethercat_hardware::SoftProcessorReset&) { return value(); }
00244 };
00245
00246 template<>
00247 struct DataType<ethercat_hardware::SoftProcessorReset> {
00248 static const char* value()
00249 {
00250 return "ethercat_hardware/SoftProcessorReset";
00251 }
00252
00253 static const char* value(const ethercat_hardware::SoftProcessorReset&) { return value(); }
00254 };
00255
00256 template<class ContainerAllocator>
00257 struct MD5Sum<ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> > {
00258 static const char* value()
00259 {
00260 return "338c1a9d2fcf7479cddb1ea63dbc8af9";
00261 }
00262
00263 static const char* value(const ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> &) { return value(); }
00264 };
00265
00266 template<class ContainerAllocator>
00267 struct DataType<ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> > {
00268 static const char* value()
00269 {
00270 return "ethercat_hardware/SoftProcessorReset";
00271 }
00272
00273 static const char* value(const ethercat_hardware::SoftProcessorResetRequest_<ContainerAllocator> &) { return value(); }
00274 };
00275
00276 template<class ContainerAllocator>
00277 struct MD5Sum<ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> > {
00278 static const char* value()
00279 {
00280 return "338c1a9d2fcf7479cddb1ea63dbc8af9";
00281 }
00282
00283 static const char* value(const ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> &) { return value(); }
00284 };
00285
00286 template<class ContainerAllocator>
00287 struct DataType<ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> > {
00288 static const char* value()
00289 {
00290 return "ethercat_hardware/SoftProcessorReset";
00291 }
00292
00293 static const char* value(const ethercat_hardware::SoftProcessorResetResponse_<ContainerAllocator> &) { return value(); }
00294 };
00295
00296 }
00297 }
00298
00299 #endif // ETHERCAT_HARDWARE_SERVICE_SOFTPROCESSORRESET_H
00300