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