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