00001
00002 #ifndef GRASPIT_INTERFACE_MSGS_SERVICE_VERIFYGRASP_H
00003 #define GRASPIT_INTERFACE_MSGS_SERVICE_VERIFYGRASP_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 "geometry_msgs/Pose.h"
00016
00017
00018
00019 namespace graspit_interface_msgs
00020 {
00021 template <class ContainerAllocator>
00022 struct VerifyGraspRequest_ : public ros::Message
00023 {
00024 typedef VerifyGraspRequest_<ContainerAllocator> Type;
00025
00026 VerifyGraspRequest_()
00027 : scaled_model_id(0)
00028 , grasp_pose()
00029 , grasp_joint_angle(0.0)
00030 , table_file_name()
00031 {
00032 }
00033
00034 VerifyGraspRequest_(const ContainerAllocator& _alloc)
00035 : scaled_model_id(0)
00036 , grasp_pose(_alloc)
00037 , grasp_joint_angle(0.0)
00038 , table_file_name(_alloc)
00039 {
00040 }
00041
00042 typedef int32_t _scaled_model_id_type;
00043 int32_t scaled_model_id;
00044
00045 typedef ::geometry_msgs::Pose_<ContainerAllocator> _grasp_pose_type;
00046 ::geometry_msgs::Pose_<ContainerAllocator> grasp_pose;
00047
00048 typedef double _grasp_joint_angle_type;
00049 double grasp_joint_angle;
00050
00051 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _table_file_name_type;
00052 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > table_file_name;
00053
00054
00055 private:
00056 static const char* __s_getDataType_() { return "graspit_interface_msgs/VerifyGraspRequest"; }
00057 public:
00058 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00059
00060 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00061
00062 private:
00063 static const char* __s_getMD5Sum_() { return "3ea5e3d1b2abb601b42af9afe28d351f"; }
00064 public:
00065 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00066
00067 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00068
00069 private:
00070 static const char* __s_getServerMD5Sum_() { return "14498cf3d29129af22a365ada2629e17"; }
00071 public:
00072 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00073
00074 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00075
00076 private:
00077 static const char* __s_getMessageDefinition_() { return "\n\
00078 \n\
00079 \n\
00080 int32 scaled_model_id\n\
00081 \n\
00082 geometry_msgs/Pose grasp_pose\n\
00083 \n\
00084 float64 grasp_joint_angle\n\
00085 \n\
00086 string table_file_name\n\
00087 \n\
00088 \n\
00089 ================================================================================\n\
00090 MSG: geometry_msgs/Pose\n\
00091 # A representation of pose in free space, composed of postion and orientation. \n\
00092 Point position\n\
00093 Quaternion orientation\n\
00094 \n\
00095 ================================================================================\n\
00096 MSG: geometry_msgs/Point\n\
00097 # This contains the position of a point in free space\n\
00098 float64 x\n\
00099 float64 y\n\
00100 float64 z\n\
00101 \n\
00102 ================================================================================\n\
00103 MSG: geometry_msgs/Quaternion\n\
00104 # This represents an orientation in free space in quaternion form.\n\
00105 \n\
00106 float64 x\n\
00107 float64 y\n\
00108 float64 z\n\
00109 float64 w\n\
00110 \n\
00111 "; }
00112 public:
00113 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00114
00115 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00116
00117 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00118 {
00119 ros::serialization::OStream stream(write_ptr, 1000000000);
00120 ros::serialization::serialize(stream, scaled_model_id);
00121 ros::serialization::serialize(stream, grasp_pose);
00122 ros::serialization::serialize(stream, grasp_joint_angle);
00123 ros::serialization::serialize(stream, table_file_name);
00124 return stream.getData();
00125 }
00126
00127 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00128 {
00129 ros::serialization::IStream stream(read_ptr, 1000000000);
00130 ros::serialization::deserialize(stream, scaled_model_id);
00131 ros::serialization::deserialize(stream, grasp_pose);
00132 ros::serialization::deserialize(stream, grasp_joint_angle);
00133 ros::serialization::deserialize(stream, table_file_name);
00134 return stream.getData();
00135 }
00136
00137 ROS_DEPRECATED virtual uint32_t serializationLength() const
00138 {
00139 uint32_t size = 0;
00140 size += ros::serialization::serializationLength(scaled_model_id);
00141 size += ros::serialization::serializationLength(grasp_pose);
00142 size += ros::serialization::serializationLength(grasp_joint_angle);
00143 size += ros::serialization::serializationLength(table_file_name);
00144 return size;
00145 }
00146
00147 typedef boost::shared_ptr< ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> > Ptr;
00148 typedef boost::shared_ptr< ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> const> ConstPtr;
00149 };
00150 typedef ::graspit_interface_msgs::VerifyGraspRequest_<std::allocator<void> > VerifyGraspRequest;
00151
00152 typedef boost::shared_ptr< ::graspit_interface_msgs::VerifyGraspRequest> VerifyGraspRequestPtr;
00153 typedef boost::shared_ptr< ::graspit_interface_msgs::VerifyGraspRequest const> VerifyGraspRequestConstPtr;
00154
00155
00156 template <class ContainerAllocator>
00157 struct VerifyGraspResponse_ : public ros::Message
00158 {
00159 typedef VerifyGraspResponse_<ContainerAllocator> Type;
00160
00161 VerifyGraspResponse_()
00162 : hand_environment_collision(false)
00163 , hand_object_collision(false)
00164 , gripper_tabletop_clearance(0.0)
00165 , gripper_object_distance(0.0)
00166 , result(0)
00167 {
00168 }
00169
00170 VerifyGraspResponse_(const ContainerAllocator& _alloc)
00171 : hand_environment_collision(false)
00172 , hand_object_collision(false)
00173 , gripper_tabletop_clearance(0.0)
00174 , gripper_object_distance(0.0)
00175 , result(0)
00176 {
00177 }
00178
00179 typedef uint8_t _hand_environment_collision_type;
00180 uint8_t hand_environment_collision;
00181
00182 typedef uint8_t _hand_object_collision_type;
00183 uint8_t hand_object_collision;
00184
00185 typedef double _gripper_tabletop_clearance_type;
00186 double gripper_tabletop_clearance;
00187
00188 typedef double _gripper_object_distance_type;
00189 double gripper_object_distance;
00190
00191 typedef int32_t _result_type;
00192 int32_t result;
00193
00194 enum { LOAD_OBJECT_FAILURE = 0 };
00195 enum { LOAD_OBSTACLE_FAILURE = 1 };
00196 enum { LOAD_GRIPPER_FAILURE = 2 };
00197 enum { CHECK_SUCCESS = 3 };
00198
00199 private:
00200 static const char* __s_getDataType_() { return "graspit_interface_msgs/VerifyGraspResponse"; }
00201 public:
00202 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00203
00204 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00205
00206 private:
00207 static const char* __s_getMD5Sum_() { return "264475d04654958284f6216319e478e9"; }
00208 public:
00209 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00210
00211 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00212
00213 private:
00214 static const char* __s_getServerMD5Sum_() { return "14498cf3d29129af22a365ada2629e17"; }
00215 public:
00216 ROS_DEPRECATED static const std::string __s_getServerMD5Sum() { return __s_getServerMD5Sum_(); }
00217
00218 ROS_DEPRECATED const std::string __getServerMD5Sum() const { return __s_getServerMD5Sum_(); }
00219
00220 private:
00221 static const char* __s_getMessageDefinition_() { return "\n\
00222 bool hand_environment_collision\n\
00223 \n\
00224 bool hand_object_collision\n\
00225 \n\
00226 float64 gripper_tabletop_clearance\n\
00227 \n\
00228 float64 gripper_object_distance\n\
00229 \n\
00230 \n\
00231 int32 LOAD_OBJECT_FAILURE = 0\n\
00232 int32 LOAD_OBSTACLE_FAILURE = 1\n\
00233 int32 LOAD_GRIPPER_FAILURE = 2\n\
00234 int32 CHECK_SUCCESS = 3\n\
00235 int32 result\n\
00236 \n\
00237 \n\
00238 "; }
00239 public:
00240 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00241
00242 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00243
00244 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00245 {
00246 ros::serialization::OStream stream(write_ptr, 1000000000);
00247 ros::serialization::serialize(stream, hand_environment_collision);
00248 ros::serialization::serialize(stream, hand_object_collision);
00249 ros::serialization::serialize(stream, gripper_tabletop_clearance);
00250 ros::serialization::serialize(stream, gripper_object_distance);
00251 ros::serialization::serialize(stream, result);
00252 return stream.getData();
00253 }
00254
00255 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00256 {
00257 ros::serialization::IStream stream(read_ptr, 1000000000);
00258 ros::serialization::deserialize(stream, hand_environment_collision);
00259 ros::serialization::deserialize(stream, hand_object_collision);
00260 ros::serialization::deserialize(stream, gripper_tabletop_clearance);
00261 ros::serialization::deserialize(stream, gripper_object_distance);
00262 ros::serialization::deserialize(stream, result);
00263 return stream.getData();
00264 }
00265
00266 ROS_DEPRECATED virtual uint32_t serializationLength() const
00267 {
00268 uint32_t size = 0;
00269 size += ros::serialization::serializationLength(hand_environment_collision);
00270 size += ros::serialization::serializationLength(hand_object_collision);
00271 size += ros::serialization::serializationLength(gripper_tabletop_clearance);
00272 size += ros::serialization::serializationLength(gripper_object_distance);
00273 size += ros::serialization::serializationLength(result);
00274 return size;
00275 }
00276
00277 typedef boost::shared_ptr< ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> > Ptr;
00278 typedef boost::shared_ptr< ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> const> ConstPtr;
00279 };
00280 typedef ::graspit_interface_msgs::VerifyGraspResponse_<std::allocator<void> > VerifyGraspResponse;
00281
00282 typedef boost::shared_ptr< ::graspit_interface_msgs::VerifyGraspResponse> VerifyGraspResponsePtr;
00283 typedef boost::shared_ptr< ::graspit_interface_msgs::VerifyGraspResponse const> VerifyGraspResponseConstPtr;
00284
00285 struct VerifyGrasp
00286 {
00287
00288 typedef VerifyGraspRequest Request;
00289 typedef VerifyGraspResponse Response;
00290 Request request;
00291 Response response;
00292
00293 typedef Request RequestType;
00294 typedef Response ResponseType;
00295 };
00296 }
00297
00298 namespace ros
00299 {
00300 namespace message_traits
00301 {
00302 template<class ContainerAllocator>
00303 struct MD5Sum< ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> > {
00304 static const char* value()
00305 {
00306 return "3ea5e3d1b2abb601b42af9afe28d351f";
00307 }
00308
00309 static const char* value(const ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> &) { return value(); }
00310 static const uint64_t static_value1 = 0x3ea5e3d1b2abb601ULL;
00311 static const uint64_t static_value2 = 0xb42af9afe28d351fULL;
00312 };
00313
00314 template<class ContainerAllocator>
00315 struct DataType< ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> > {
00316 static const char* value()
00317 {
00318 return "graspit_interface_msgs/VerifyGraspRequest";
00319 }
00320
00321 static const char* value(const ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> &) { return value(); }
00322 };
00323
00324 template<class ContainerAllocator>
00325 struct Definition< ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> > {
00326 static const char* value()
00327 {
00328 return "\n\
00329 \n\
00330 \n\
00331 int32 scaled_model_id\n\
00332 \n\
00333 geometry_msgs/Pose grasp_pose\n\
00334 \n\
00335 float64 grasp_joint_angle\n\
00336 \n\
00337 string table_file_name\n\
00338 \n\
00339 \n\
00340 ================================================================================\n\
00341 MSG: geometry_msgs/Pose\n\
00342 # A representation of pose in free space, composed of postion and orientation. \n\
00343 Point position\n\
00344 Quaternion orientation\n\
00345 \n\
00346 ================================================================================\n\
00347 MSG: geometry_msgs/Point\n\
00348 # This contains the position of a point in free space\n\
00349 float64 x\n\
00350 float64 y\n\
00351 float64 z\n\
00352 \n\
00353 ================================================================================\n\
00354 MSG: geometry_msgs/Quaternion\n\
00355 # This represents an orientation in free space in quaternion form.\n\
00356 \n\
00357 float64 x\n\
00358 float64 y\n\
00359 float64 z\n\
00360 float64 w\n\
00361 \n\
00362 ";
00363 }
00364
00365 static const char* value(const ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> &) { return value(); }
00366 };
00367
00368 }
00369 }
00370
00371
00372 namespace ros
00373 {
00374 namespace message_traits
00375 {
00376 template<class ContainerAllocator>
00377 struct MD5Sum< ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> > {
00378 static const char* value()
00379 {
00380 return "264475d04654958284f6216319e478e9";
00381 }
00382
00383 static const char* value(const ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> &) { return value(); }
00384 static const uint64_t static_value1 = 0x264475d046549582ULL;
00385 static const uint64_t static_value2 = 0x84f6216319e478e9ULL;
00386 };
00387
00388 template<class ContainerAllocator>
00389 struct DataType< ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> > {
00390 static const char* value()
00391 {
00392 return "graspit_interface_msgs/VerifyGraspResponse";
00393 }
00394
00395 static const char* value(const ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> &) { return value(); }
00396 };
00397
00398 template<class ContainerAllocator>
00399 struct Definition< ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> > {
00400 static const char* value()
00401 {
00402 return "\n\
00403 bool hand_environment_collision\n\
00404 \n\
00405 bool hand_object_collision\n\
00406 \n\
00407 float64 gripper_tabletop_clearance\n\
00408 \n\
00409 float64 gripper_object_distance\n\
00410 \n\
00411 \n\
00412 int32 LOAD_OBJECT_FAILURE = 0\n\
00413 int32 LOAD_OBSTACLE_FAILURE = 1\n\
00414 int32 LOAD_GRIPPER_FAILURE = 2\n\
00415 int32 CHECK_SUCCESS = 3\n\
00416 int32 result\n\
00417 \n\
00418 \n\
00419 ";
00420 }
00421
00422 static const char* value(const ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> &) { return value(); }
00423 };
00424
00425 template<class ContainerAllocator> struct IsFixedSize< ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> > : public TrueType {};
00426 }
00427 }
00428
00429 namespace ros
00430 {
00431 namespace serialization
00432 {
00433
00434 template<class ContainerAllocator> struct Serializer< ::graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> >
00435 {
00436 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00437 {
00438 stream.next(m.scaled_model_id);
00439 stream.next(m.grasp_pose);
00440 stream.next(m.grasp_joint_angle);
00441 stream.next(m.table_file_name);
00442 }
00443
00444 ROS_DECLARE_ALLINONE_SERIALIZER;
00445 };
00446 }
00447 }
00448
00449
00450 namespace ros
00451 {
00452 namespace serialization
00453 {
00454
00455 template<class ContainerAllocator> struct Serializer< ::graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> >
00456 {
00457 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00458 {
00459 stream.next(m.hand_environment_collision);
00460 stream.next(m.hand_object_collision);
00461 stream.next(m.gripper_tabletop_clearance);
00462 stream.next(m.gripper_object_distance);
00463 stream.next(m.result);
00464 }
00465
00466 ROS_DECLARE_ALLINONE_SERIALIZER;
00467 };
00468 }
00469 }
00470
00471 namespace ros
00472 {
00473 namespace service_traits
00474 {
00475 template<>
00476 struct MD5Sum<graspit_interface_msgs::VerifyGrasp> {
00477 static const char* value()
00478 {
00479 return "14498cf3d29129af22a365ada2629e17";
00480 }
00481
00482 static const char* value(const graspit_interface_msgs::VerifyGrasp&) { return value(); }
00483 };
00484
00485 template<>
00486 struct DataType<graspit_interface_msgs::VerifyGrasp> {
00487 static const char* value()
00488 {
00489 return "graspit_interface_msgs/VerifyGrasp";
00490 }
00491
00492 static const char* value(const graspit_interface_msgs::VerifyGrasp&) { return value(); }
00493 };
00494
00495 template<class ContainerAllocator>
00496 struct MD5Sum<graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> > {
00497 static const char* value()
00498 {
00499 return "14498cf3d29129af22a365ada2629e17";
00500 }
00501
00502 static const char* value(const graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> &) { return value(); }
00503 };
00504
00505 template<class ContainerAllocator>
00506 struct DataType<graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> > {
00507 static const char* value()
00508 {
00509 return "graspit_interface_msgs/VerifyGrasp";
00510 }
00511
00512 static const char* value(const graspit_interface_msgs::VerifyGraspRequest_<ContainerAllocator> &) { return value(); }
00513 };
00514
00515 template<class ContainerAllocator>
00516 struct MD5Sum<graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> > {
00517 static const char* value()
00518 {
00519 return "14498cf3d29129af22a365ada2629e17";
00520 }
00521
00522 static const char* value(const graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> &) { return value(); }
00523 };
00524
00525 template<class ContainerAllocator>
00526 struct DataType<graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> > {
00527 static const char* value()
00528 {
00529 return "graspit_interface_msgs/VerifyGrasp";
00530 }
00531
00532 static const char* value(const graspit_interface_msgs::VerifyGraspResponse_<ContainerAllocator> &) { return value(); }
00533 };
00534
00535 }
00536 }
00537
00538 #endif // GRASPIT_INTERFACE_MSGS_SERVICE_VERIFYGRASP_H
00539