00001
00002 #ifndef WAREHOUSE_SERVICE_METADATA_H
00003 #define WAREHOUSE_SERVICE_METADATA_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 warehouse
00019 {
00020 template <class ContainerAllocator>
00021 struct MetadataRequest_ : public ros::Message
00022 {
00023 typedef MetadataRequest_<ContainerAllocator> Type;
00024
00025 MetadataRequest_()
00026 : db_name()
00027 , collection_name()
00028 , id()
00029 , metadata()
00030 {
00031 }
00032
00033 MetadataRequest_(const ContainerAllocator& _alloc)
00034 : db_name(_alloc)
00035 , collection_name(_alloc)
00036 , id(_alloc)
00037 , metadata(_alloc)
00038 {
00039 }
00040
00041 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _db_name_type;
00042 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > db_name;
00043
00044 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _collection_name_type;
00045 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > collection_name;
00046
00047 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _id_type;
00048 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > id;
00049
00050 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _metadata_type;
00051 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > metadata;
00052
00053
00054 private:
00055 static const char* __s_getDataType_() { return "warehouse/MetadataRequest"; }
00056 public:
00057 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00058
00059 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00060
00061 private:
00062 static const char* __s_getMD5Sum_() { return "9d21935b297a26a8af2a5050b00f588d"; }
00063 public:
00064 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00065
00066 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00067
00068 private:
00069 static const char* __s_getServerMD5Sum_() { return "68b120fe147d50d8c4ae15956f0ae2b6"; }
00070 public:
00071 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00072
00073 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00074
00075 private:
00076 static const char* __s_getMessageDefinition_() { return "\n\
00077 \n\
00078 string db_name\n\
00079 \n\
00080 string collection_name\n\
00081 \n\
00082 \n\
00083 string id\n\
00084 \n\
00085 \n\
00086 string metadata\n\
00087 \n\
00088 "; }
00089 public:
00090 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00091
00092 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00093
00094 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00095 {
00096 ros::serialization::OStream stream(write_ptr, 1000000000);
00097 ros::serialization::serialize(stream, db_name);
00098 ros::serialization::serialize(stream, collection_name);
00099 ros::serialization::serialize(stream, id);
00100 ros::serialization::serialize(stream, metadata);
00101 return stream.getData();
00102 }
00103
00104 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00105 {
00106 ros::serialization::IStream stream(read_ptr, 1000000000);
00107 ros::serialization::deserialize(stream, db_name);
00108 ros::serialization::deserialize(stream, collection_name);
00109 ros::serialization::deserialize(stream, id);
00110 ros::serialization::deserialize(stream, metadata);
00111 return stream.getData();
00112 }
00113
00114 ROS_DEPRECATED virtual uint32_t serializationLength() const
00115 {
00116 uint32_t size = 0;
00117 size += ros::serialization::serializationLength(db_name);
00118 size += ros::serialization::serializationLength(collection_name);
00119 size += ros::serialization::serializationLength(id);
00120 size += ros::serialization::serializationLength(metadata);
00121 return size;
00122 }
00123
00124 typedef boost::shared_ptr< ::warehouse::MetadataRequest_<ContainerAllocator> > Ptr;
00125 typedef boost::shared_ptr< ::warehouse::MetadataRequest_<ContainerAllocator> const> ConstPtr;
00126 };
00127 typedef ::warehouse::MetadataRequest_<std::allocator<void> > MetadataRequest;
00128
00129 typedef boost::shared_ptr< ::warehouse::MetadataRequest> MetadataRequestPtr;
00130 typedef boost::shared_ptr< ::warehouse::MetadataRequest const> MetadataRequestConstPtr;
00131
00132
00133 template <class ContainerAllocator>
00134 struct MetadataResponse_ : public ros::Message
00135 {
00136 typedef MetadataResponse_<ContainerAllocator> Type;
00137
00138 MetadataResponse_()
00139 : error_code(0)
00140 , error_msg()
00141 {
00142 }
00143
00144 MetadataResponse_(const ContainerAllocator& _alloc)
00145 : error_code(0)
00146 , error_msg(_alloc)
00147 {
00148 }
00149
00150 typedef int8_t _error_code_type;
00151 int8_t error_code;
00152
00153 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _error_msg_type;
00154 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > error_msg;
00155
00156 enum { SUCCESS = 0 };
00157 enum { JSON_ERROR = 1 };
00158 enum { INVALID_ID = 2 };
00159 enum { INVALID_DB_NAME = 3 };
00160
00161 private:
00162 static const char* __s_getDataType_() { return "warehouse/MetadataResponse"; }
00163 public:
00164 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00165
00166 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00167
00168 private:
00169 static const char* __s_getMD5Sum_() { return "8402dddb6d79145b6fae485546387743"; }
00170 public:
00171 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00172
00173 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00174
00175 private:
00176 static const char* __s_getServerMD5Sum_() { return "68b120fe147d50d8c4ae15956f0ae2b6"; }
00177 public:
00178 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00179
00180 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00181
00182 private:
00183 static const char* __s_getMessageDefinition_() { return "int8 error_code\n\
00184 string error_msg\n\
00185 \n\
00186 int8 SUCCESS=0\n\
00187 int8 JSON_ERROR=1\n\
00188 int8 INVALID_ID=2\n\
00189 int8 INVALID_DB_NAME=3\n\
00190 \n\
00191 "; }
00192 public:
00193 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00194
00195 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00196
00197 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00198 {
00199 ros::serialization::OStream stream(write_ptr, 1000000000);
00200 ros::serialization::serialize(stream, error_code);
00201 ros::serialization::serialize(stream, error_msg);
00202 return stream.getData();
00203 }
00204
00205 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00206 {
00207 ros::serialization::IStream stream(read_ptr, 1000000000);
00208 ros::serialization::deserialize(stream, error_code);
00209 ros::serialization::deserialize(stream, error_msg);
00210 return stream.getData();
00211 }
00212
00213 ROS_DEPRECATED virtual uint32_t serializationLength() const
00214 {
00215 uint32_t size = 0;
00216 size += ros::serialization::serializationLength(error_code);
00217 size += ros::serialization::serializationLength(error_msg);
00218 return size;
00219 }
00220
00221 typedef boost::shared_ptr< ::warehouse::MetadataResponse_<ContainerAllocator> > Ptr;
00222 typedef boost::shared_ptr< ::warehouse::MetadataResponse_<ContainerAllocator> const> ConstPtr;
00223 };
00224 typedef ::warehouse::MetadataResponse_<std::allocator<void> > MetadataResponse;
00225
00226 typedef boost::shared_ptr< ::warehouse::MetadataResponse> MetadataResponsePtr;
00227 typedef boost::shared_ptr< ::warehouse::MetadataResponse const> MetadataResponseConstPtr;
00228
00229 struct Metadata
00230 {
00231
00232 typedef MetadataRequest Request;
00233 typedef MetadataResponse Response;
00234 Request request;
00235 Response response;
00236
00237 typedef Request RequestType;
00238 typedef Response ResponseType;
00239 };
00240 }
00241
00242 namespace ros
00243 {
00244 namespace message_traits
00245 {
00246 template<class ContainerAllocator>
00247 struct MD5Sum< ::warehouse::MetadataRequest_<ContainerAllocator> > {
00248 static const char* value()
00249 {
00250 return "9d21935b297a26a8af2a5050b00f588d";
00251 }
00252
00253 static const char* value(const ::warehouse::MetadataRequest_<ContainerAllocator> &) { return value(); }
00254 static const uint64_t static_value1 = 0x9d21935b297a26a8ULL;
00255 static const uint64_t static_value2 = 0xaf2a5050b00f588dULL;
00256 };
00257
00258 template<class ContainerAllocator>
00259 struct DataType< ::warehouse::MetadataRequest_<ContainerAllocator> > {
00260 static const char* value()
00261 {
00262 return "warehouse/MetadataRequest";
00263 }
00264
00265 static const char* value(const ::warehouse::MetadataRequest_<ContainerAllocator> &) { return value(); }
00266 };
00267
00268 template<class ContainerAllocator>
00269 struct Definition< ::warehouse::MetadataRequest_<ContainerAllocator> > {
00270 static const char* value()
00271 {
00272 return "\n\
00273 \n\
00274 string db_name\n\
00275 \n\
00276 string collection_name\n\
00277 \n\
00278 \n\
00279 string id\n\
00280 \n\
00281 \n\
00282 string metadata\n\
00283 \n\
00284 ";
00285 }
00286
00287 static const char* value(const ::warehouse::MetadataRequest_<ContainerAllocator> &) { return value(); }
00288 };
00289
00290 }
00291 }
00292
00293
00294 namespace ros
00295 {
00296 namespace message_traits
00297 {
00298 template<class ContainerAllocator>
00299 struct MD5Sum< ::warehouse::MetadataResponse_<ContainerAllocator> > {
00300 static const char* value()
00301 {
00302 return "8402dddb6d79145b6fae485546387743";
00303 }
00304
00305 static const char* value(const ::warehouse::MetadataResponse_<ContainerAllocator> &) { return value(); }
00306 static const uint64_t static_value1 = 0x8402dddb6d79145bULL;
00307 static const uint64_t static_value2 = 0x6fae485546387743ULL;
00308 };
00309
00310 template<class ContainerAllocator>
00311 struct DataType< ::warehouse::MetadataResponse_<ContainerAllocator> > {
00312 static const char* value()
00313 {
00314 return "warehouse/MetadataResponse";
00315 }
00316
00317 static const char* value(const ::warehouse::MetadataResponse_<ContainerAllocator> &) { return value(); }
00318 };
00319
00320 template<class ContainerAllocator>
00321 struct Definition< ::warehouse::MetadataResponse_<ContainerAllocator> > {
00322 static const char* value()
00323 {
00324 return "int8 error_code\n\
00325 string error_msg\n\
00326 \n\
00327 int8 SUCCESS=0\n\
00328 int8 JSON_ERROR=1\n\
00329 int8 INVALID_ID=2\n\
00330 int8 INVALID_DB_NAME=3\n\
00331 \n\
00332 ";
00333 }
00334
00335 static const char* value(const ::warehouse::MetadataResponse_<ContainerAllocator> &) { return value(); }
00336 };
00337
00338 }
00339 }
00340
00341 namespace ros
00342 {
00343 namespace serialization
00344 {
00345
00346 template<class ContainerAllocator> struct Serializer< ::warehouse::MetadataRequest_<ContainerAllocator> >
00347 {
00348 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00349 {
00350 stream.next(m.db_name);
00351 stream.next(m.collection_name);
00352 stream.next(m.id);
00353 stream.next(m.metadata);
00354 }
00355
00356 ROS_DECLARE_ALLINONE_SERIALIZER;
00357 };
00358 }
00359 }
00360
00361
00362 namespace ros
00363 {
00364 namespace serialization
00365 {
00366
00367 template<class ContainerAllocator> struct Serializer< ::warehouse::MetadataResponse_<ContainerAllocator> >
00368 {
00369 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00370 {
00371 stream.next(m.error_code);
00372 stream.next(m.error_msg);
00373 }
00374
00375 ROS_DECLARE_ALLINONE_SERIALIZER;
00376 };
00377 }
00378 }
00379
00380 namespace ros
00381 {
00382 namespace service_traits
00383 {
00384 template<>
00385 struct MD5Sum<warehouse::Metadata> {
00386 static const char* value()
00387 {
00388 return "68b120fe147d50d8c4ae15956f0ae2b6";
00389 }
00390
00391 static const char* value(const warehouse::Metadata&) { return value(); }
00392 };
00393
00394 template<>
00395 struct DataType<warehouse::Metadata> {
00396 static const char* value()
00397 {
00398 return "warehouse/Metadata";
00399 }
00400
00401 static const char* value(const warehouse::Metadata&) { return value(); }
00402 };
00403
00404 template<class ContainerAllocator>
00405 struct MD5Sum<warehouse::MetadataRequest_<ContainerAllocator> > {
00406 static const char* value()
00407 {
00408 return "68b120fe147d50d8c4ae15956f0ae2b6";
00409 }
00410
00411 static const char* value(const warehouse::MetadataRequest_<ContainerAllocator> &) { return value(); }
00412 };
00413
00414 template<class ContainerAllocator>
00415 struct DataType<warehouse::MetadataRequest_<ContainerAllocator> > {
00416 static const char* value()
00417 {
00418 return "warehouse/Metadata";
00419 }
00420
00421 static const char* value(const warehouse::MetadataRequest_<ContainerAllocator> &) { return value(); }
00422 };
00423
00424 template<class ContainerAllocator>
00425 struct MD5Sum<warehouse::MetadataResponse_<ContainerAllocator> > {
00426 static const char* value()
00427 {
00428 return "68b120fe147d50d8c4ae15956f0ae2b6";
00429 }
00430
00431 static const char* value(const warehouse::MetadataResponse_<ContainerAllocator> &) { return value(); }
00432 };
00433
00434 template<class ContainerAllocator>
00435 struct DataType<warehouse::MetadataResponse_<ContainerAllocator> > {
00436 static const char* value()
00437 {
00438 return "warehouse/Metadata";
00439 }
00440
00441 static const char* value(const warehouse::MetadataResponse_<ContainerAllocator> &) { return value(); }
00442 };
00443
00444 }
00445 }
00446
00447 #endif // WAREHOUSE_SERVICE_METADATA_H
00448