00001
00002 #ifndef OBJECT_MANIPULATION_MSGS_MESSAGE_PLACELOCATIONRESULT_H
00003 #define OBJECT_MANIPULATION_MSGS_MESSAGE_PLACELOCATIONRESULT_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
00014 namespace object_manipulation_msgs
00015 {
00016 template <class ContainerAllocator>
00017 struct PlaceLocationResult_ : public ros::Message
00018 {
00019 typedef PlaceLocationResult_<ContainerAllocator> Type;
00020
00021 PlaceLocationResult_()
00022 : result_code(0)
00023 , continuation_possible(false)
00024 {
00025 }
00026
00027 PlaceLocationResult_(const ContainerAllocator& _alloc)
00028 : result_code(0)
00029 , continuation_possible(false)
00030 {
00031 }
00032
00033 typedef int32_t _result_code_type;
00034 int32_t result_code;
00035
00036 typedef uint8_t _continuation_possible_type;
00037 uint8_t continuation_possible;
00038
00039 enum { SUCCESS = 1 };
00040 enum { PLACE_OUT_OF_REACH = 2 };
00041 enum { PLACE_IN_COLLISION = 3 };
00042 enum { PLACE_UNFEASIBLE = 4 };
00043 enum { PREPLACE_OUT_OF_REACH = 5 };
00044 enum { PREPLACE_IN_COLLISION = 6 };
00045 enum { PREPLACE_UNFEASIBLE = 7 };
00046 enum { RETREAT_OUT_OF_REACH = 8 };
00047 enum { RETREAT_IN_COLLISION = 9 };
00048 enum { RETREAT_UNFEASIBLE = 10 };
00049 enum { MOVE_ARM_FAILED = 11 };
00050 enum { PLACE_FAILED = 12 };
00051 enum { RETREAT_FAILED = 13 };
00052
00053 private:
00054 static const char* __s_getDataType_() { return "object_manipulation_msgs/PlaceLocationResult"; }
00055 public:
00056 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00057
00058 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00059
00060 private:
00061 static const char* __s_getMD5Sum_() { return "8dd9edc3a2a98cab298ca81031224cda"; }
00062 public:
00063 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00064
00065 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00066
00067 private:
00068 static const char* __s_getMessageDefinition_() { return "int32 SUCCESS = 1\n\
00069 int32 PLACE_OUT_OF_REACH = 2\n\
00070 int32 PLACE_IN_COLLISION = 3\n\
00071 int32 PLACE_UNFEASIBLE = 4\n\
00072 int32 PREPLACE_OUT_OF_REACH = 5\n\
00073 int32 PREPLACE_IN_COLLISION = 6\n\
00074 int32 PREPLACE_UNFEASIBLE = 7\n\
00075 int32 RETREAT_OUT_OF_REACH = 8\n\
00076 int32 RETREAT_IN_COLLISION = 9\n\
00077 int32 RETREAT_UNFEASIBLE = 10\n\
00078 int32 MOVE_ARM_FAILED = 11\n\
00079 int32 PLACE_FAILED = 12\n\
00080 int32 RETREAT_FAILED = 13\n\
00081 int32 result_code\n\
00082 \n\
00083 # whether the state of the world was disturbed by this attempt. generally, this flag\n\
00084 # shows if another task can be attempted, or a new sensed world model is recommeded\n\
00085 # before proceeding\n\
00086 bool continuation_possible\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, result_code);
00098 ros::serialization::serialize(stream, continuation_possible);
00099 return stream.getData();
00100 }
00101
00102 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00103 {
00104 ros::serialization::IStream stream(read_ptr, 1000000000);
00105 ros::serialization::deserialize(stream, result_code);
00106 ros::serialization::deserialize(stream, continuation_possible);
00107 return stream.getData();
00108 }
00109
00110 ROS_DEPRECATED virtual uint32_t serializationLength() const
00111 {
00112 uint32_t size = 0;
00113 size += ros::serialization::serializationLength(result_code);
00114 size += ros::serialization::serializationLength(continuation_possible);
00115 return size;
00116 }
00117
00118 typedef boost::shared_ptr< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> > Ptr;
00119 typedef boost::shared_ptr< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> const> ConstPtr;
00120 };
00121 typedef ::object_manipulation_msgs::PlaceLocationResult_<std::allocator<void> > PlaceLocationResult;
00122
00123 typedef boost::shared_ptr< ::object_manipulation_msgs::PlaceLocationResult> PlaceLocationResultPtr;
00124 typedef boost::shared_ptr< ::object_manipulation_msgs::PlaceLocationResult const> PlaceLocationResultConstPtr;
00125
00126
00127 template<typename ContainerAllocator>
00128 std::ostream& operator<<(std::ostream& s, const ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> & v)
00129 {
00130 ros::message_operations::Printer< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> >::stream(s, "", v);
00131 return s;}
00132
00133 }
00134
00135 namespace ros
00136 {
00137 namespace message_traits
00138 {
00139 template<class ContainerAllocator>
00140 struct MD5Sum< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> > {
00141 static const char* value()
00142 {
00143 return "8dd9edc3a2a98cab298ca81031224cda";
00144 }
00145
00146 static const char* value(const ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> &) { return value(); }
00147 static const uint64_t static_value1 = 0x8dd9edc3a2a98cabULL;
00148 static const uint64_t static_value2 = 0x298ca81031224cdaULL;
00149 };
00150
00151 template<class ContainerAllocator>
00152 struct DataType< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> > {
00153 static const char* value()
00154 {
00155 return "object_manipulation_msgs/PlaceLocationResult";
00156 }
00157
00158 static const char* value(const ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> &) { return value(); }
00159 };
00160
00161 template<class ContainerAllocator>
00162 struct Definition< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> > {
00163 static const char* value()
00164 {
00165 return "int32 SUCCESS = 1\n\
00166 int32 PLACE_OUT_OF_REACH = 2\n\
00167 int32 PLACE_IN_COLLISION = 3\n\
00168 int32 PLACE_UNFEASIBLE = 4\n\
00169 int32 PREPLACE_OUT_OF_REACH = 5\n\
00170 int32 PREPLACE_IN_COLLISION = 6\n\
00171 int32 PREPLACE_UNFEASIBLE = 7\n\
00172 int32 RETREAT_OUT_OF_REACH = 8\n\
00173 int32 RETREAT_IN_COLLISION = 9\n\
00174 int32 RETREAT_UNFEASIBLE = 10\n\
00175 int32 MOVE_ARM_FAILED = 11\n\
00176 int32 PLACE_FAILED = 12\n\
00177 int32 RETREAT_FAILED = 13\n\
00178 int32 result_code\n\
00179 \n\
00180 # whether the state of the world was disturbed by this attempt. generally, this flag\n\
00181 # shows if another task can be attempted, or a new sensed world model is recommeded\n\
00182 # before proceeding\n\
00183 bool continuation_possible\n\
00184 \n\
00185 ";
00186 }
00187
00188 static const char* value(const ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> &) { return value(); }
00189 };
00190
00191 template<class ContainerAllocator> struct IsFixedSize< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> > : public TrueType {};
00192 }
00193 }
00194
00195 namespace ros
00196 {
00197 namespace serialization
00198 {
00199
00200 template<class ContainerAllocator> struct Serializer< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> >
00201 {
00202 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00203 {
00204 stream.next(m.result_code);
00205 stream.next(m.continuation_possible);
00206 }
00207
00208 ROS_DECLARE_ALLINONE_SERIALIZER;
00209 };
00210 }
00211 }
00212
00213 namespace ros
00214 {
00215 namespace message_operations
00216 {
00217
00218 template<class ContainerAllocator>
00219 struct Printer< ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> >
00220 {
00221 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::object_manipulation_msgs::PlaceLocationResult_<ContainerAllocator> & v)
00222 {
00223 s << indent << "result_code: ";
00224 Printer<int32_t>::stream(s, indent + " ", v.result_code);
00225 s << indent << "continuation_possible: ";
00226 Printer<uint8_t>::stream(s, indent + " ", v.continuation_possible);
00227 }
00228 };
00229
00230
00231 }
00232 }
00233
00234 #endif // OBJECT_MANIPULATION_MSGS_MESSAGE_PLACELOCATIONRESULT_H
00235