Go to the documentation of this file.00001
00002 #ifndef SRS_KNOWLEDGE_MESSAGE_CUACTION_H
00003 #define SRS_KNOWLEDGE_MESSAGE_CUACTION_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 "srs_knowledge/GenericAction.h"
00018
00019 namespace srs_knowledge
00020 {
00021 template <class ContainerAllocator>
00022 struct CUAction_ {
00023 typedef CUAction_<ContainerAllocator> Type;
00024
00025 CUAction_()
00026 : status(0)
00027 , generic()
00028 , actionType()
00029 {
00030 }
00031
00032 CUAction_(const ContainerAllocator& _alloc)
00033 : status(0)
00034 , generic(_alloc)
00035 , actionType(_alloc)
00036 {
00037 }
00038
00039 typedef int32_t _status_type;
00040 int32_t status;
00041
00042 typedef ::srs_knowledge::GenericAction_<ContainerAllocator> _generic_type;
00043 ::srs_knowledge::GenericAction_<ContainerAllocator> generic;
00044
00045 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _actionType_type;
00046 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > actionType;
00047
00048
00049 typedef boost::shared_ptr< ::srs_knowledge::CUAction_<ContainerAllocator> > Ptr;
00050 typedef boost::shared_ptr< ::srs_knowledge::CUAction_<ContainerAllocator> const> ConstPtr;
00051 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00052 };
00053 typedef ::srs_knowledge::CUAction_<std::allocator<void> > CUAction;
00054
00055 typedef boost::shared_ptr< ::srs_knowledge::CUAction> CUActionPtr;
00056 typedef boost::shared_ptr< ::srs_knowledge::CUAction const> CUActionConstPtr;
00057
00058
00059 template<typename ContainerAllocator>
00060 std::ostream& operator<<(std::ostream& s, const ::srs_knowledge::CUAction_<ContainerAllocator> & v)
00061 {
00062 ros::message_operations::Printer< ::srs_knowledge::CUAction_<ContainerAllocator> >::stream(s, "", v);
00063 return s;}
00064
00065 }
00066
00067 namespace ros
00068 {
00069 namespace message_traits
00070 {
00071 template<class ContainerAllocator> struct IsMessage< ::srs_knowledge::CUAction_<ContainerAllocator> > : public TrueType {};
00072 template<class ContainerAllocator> struct IsMessage< ::srs_knowledge::CUAction_<ContainerAllocator> const> : public TrueType {};
00073 template<class ContainerAllocator>
00074 struct MD5Sum< ::srs_knowledge::CUAction_<ContainerAllocator> > {
00075 static const char* value()
00076 {
00077 return "dd380bff1522657abc20274417168b83";
00078 }
00079
00080 static const char* value(const ::srs_knowledge::CUAction_<ContainerAllocator> &) { return value(); }
00081 static const uint64_t static_value1 = 0xdd380bff1522657aULL;
00082 static const uint64_t static_value2 = 0xbc20274417168b83ULL;
00083 };
00084
00085 template<class ContainerAllocator>
00086 struct DataType< ::srs_knowledge::CUAction_<ContainerAllocator> > {
00087 static const char* value()
00088 {
00089 return "srs_knowledge/CUAction";
00090 }
00091
00092 static const char* value(const ::srs_knowledge::CUAction_<ContainerAllocator> &) { return value(); }
00093 };
00094
00095 template<class ContainerAllocator>
00096 struct Definition< ::srs_knowledge::CUAction_<ContainerAllocator> > {
00097 static const char* value()
00098 {
00099 return "# still at alpha stage. not finalised yet. \n\
00100 \n\
00101 # indicate if task finished successfully (1); no feasible solution (-1); continue executing the given actions in this message (0)\n\
00102 int32 status\n\
00103 \n\
00104 # [ifNavigate, ifDetect, ifGrasp]. 0: yes, 1: no, 2: others (undefined)\n\
00105 #int32[] actionFlags\n\
00106 \n\
00107 #MoveAction ma\n\
00108 #PerceptionAction pa\n\
00109 #GraspAction ga\n\
00110 GenericAction generic\n\
00111 \n\
00112 # move, perception, grasp, or generic\n\
00113 string actionType\n\
00114 ================================================================================\n\
00115 MSG: srs_knowledge/GenericAction\n\
00116 # use a list as the information container of an action\n\
00117 # BE CAREFUL WHEN USING IT. FOR FLEXIBILITY REASON OR TESTING NEW ADDED ACTION TYPE \n\
00118 # string[] actionInfo # to deprecate\n\
00119 string jsonActionInfo\n\
00120 \n\
00121 ";
00122 }
00123
00124 static const char* value(const ::srs_knowledge::CUAction_<ContainerAllocator> &) { return value(); }
00125 };
00126
00127 }
00128 }
00129
00130 namespace ros
00131 {
00132 namespace serialization
00133 {
00134
00135 template<class ContainerAllocator> struct Serializer< ::srs_knowledge::CUAction_<ContainerAllocator> >
00136 {
00137 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00138 {
00139 stream.next(m.status);
00140 stream.next(m.generic);
00141 stream.next(m.actionType);
00142 }
00143
00144 ROS_DECLARE_ALLINONE_SERIALIZER;
00145 };
00146 }
00147 }
00148
00149 namespace ros
00150 {
00151 namespace message_operations
00152 {
00153
00154 template<class ContainerAllocator>
00155 struct Printer< ::srs_knowledge::CUAction_<ContainerAllocator> >
00156 {
00157 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::srs_knowledge::CUAction_<ContainerAllocator> & v)
00158 {
00159 s << indent << "status: ";
00160 Printer<int32_t>::stream(s, indent + " ", v.status);
00161 s << indent << "generic: ";
00162 s << std::endl;
00163 Printer< ::srs_knowledge::GenericAction_<ContainerAllocator> >::stream(s, indent + " ", v.generic);
00164 s << indent << "actionType: ";
00165 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.actionType);
00166 }
00167 };
00168
00169
00170 }
00171 }
00172
00173 #endif // SRS_KNOWLEDGE_MESSAGE_CUACTION_H
00174