00001
00002 #ifndef NODEMON_MSGS_MESSAGE_NODESTATE_H
00003 #define NODEMON_MSGS_MESSAGE_NODESTATE_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
00018 namespace nodemon_msgs
00019 {
00020 template <class ContainerAllocator>
00021 struct NodeState_ {
00022 typedef NodeState_<ContainerAllocator> Type;
00023
00024 NodeState_()
00025 : nodename()
00026 , package()
00027 , nodetype()
00028 , time()
00029 , state(0)
00030 , machine_message()
00031 , human_message()
00032 {
00033 }
00034
00035 NodeState_(const ContainerAllocator& _alloc)
00036 : nodename(_alloc)
00037 , package(_alloc)
00038 , nodetype(_alloc)
00039 , time()
00040 , state(0)
00041 , machine_message(_alloc)
00042 , human_message(_alloc)
00043 {
00044 }
00045
00046 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _nodename_type;
00047 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > nodename;
00048
00049 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _package_type;
00050 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > package;
00051
00052 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _nodetype_type;
00053 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > nodetype;
00054
00055 typedef ros::Time _time_type;
00056 ros::Time time;
00057
00058 typedef uint8_t _state_type;
00059 uint8_t state;
00060
00061 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _machine_message_type;
00062 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > machine_message;
00063
00064 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _human_message_type;
00065 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > human_message;
00066
00067 enum { STARTING = 0 };
00068 enum { RUNNING = 1 };
00069 enum { RECOVERING = 2 };
00070 enum { ERROR = 3 };
00071 enum { FATAL = 4 };
00072 enum { STOPPING = 5 };
00073 enum { WARNING = 6 };
00074
00075 private:
00076 static const char* __s_getDataType_() { return "nodemon_msgs/NodeState"; }
00077 public:
00078 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00079
00080 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00081
00082 private:
00083 static const char* __s_getMD5Sum_() { return "e804800bd2445ee0aec90cce0edc3d66"; }
00084 public:
00085 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00086
00087 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00088
00089 private:
00090 static const char* __s_getMessageDefinition_() { return "uint8 STARTING = 0 # node is currently started and not yet functional\n\
00091 uint8 RUNNING = 1 # node is fully operational\n\
00092 uint8 RECOVERING = 2 # node is recovering and currently not functional\n\
00093 uint8 ERROR = 3 # node had an error and will try to recover\n\
00094 uint8 FATAL = 4 # node had a fatal error and is disfunctional, restart req\n\
00095 uint8 STOPPING = 5 # node is no longer functional and will soon exit\n\
00096 uint8 WARNING = 6 # node encountered a problematic situation but continued\n\
00097 \n\
00098 string nodename\n\
00099 string package\n\
00100 string nodetype\n\
00101 time time\n\
00102 uint8 state\n\
00103 # A machine parseable error string\n\
00104 string machine_message\n\
00105 # A human readable error explanation\n\
00106 string human_message\n\
00107 \n\
00108 "; }
00109 public:
00110 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00111
00112 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00113
00114 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00115 {
00116 ros::serialization::OStream stream(write_ptr, 1000000000);
00117 ros::serialization::serialize(stream, nodename);
00118 ros::serialization::serialize(stream, package);
00119 ros::serialization::serialize(stream, nodetype);
00120 ros::serialization::serialize(stream, time);
00121 ros::serialization::serialize(stream, state);
00122 ros::serialization::serialize(stream, machine_message);
00123 ros::serialization::serialize(stream, human_message);
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, nodename);
00131 ros::serialization::deserialize(stream, package);
00132 ros::serialization::deserialize(stream, nodetype);
00133 ros::serialization::deserialize(stream, time);
00134 ros::serialization::deserialize(stream, state);
00135 ros::serialization::deserialize(stream, machine_message);
00136 ros::serialization::deserialize(stream, human_message);
00137 return stream.getData();
00138 }
00139
00140 ROS_DEPRECATED virtual uint32_t serializationLength() const
00141 {
00142 uint32_t size = 0;
00143 size += ros::serialization::serializationLength(nodename);
00144 size += ros::serialization::serializationLength(package);
00145 size += ros::serialization::serializationLength(nodetype);
00146 size += ros::serialization::serializationLength(time);
00147 size += ros::serialization::serializationLength(state);
00148 size += ros::serialization::serializationLength(machine_message);
00149 size += ros::serialization::serializationLength(human_message);
00150 return size;
00151 }
00152
00153 typedef boost::shared_ptr< ::nodemon_msgs::NodeState_<ContainerAllocator> > Ptr;
00154 typedef boost::shared_ptr< ::nodemon_msgs::NodeState_<ContainerAllocator> const> ConstPtr;
00155 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00156 };
00157 typedef ::nodemon_msgs::NodeState_<std::allocator<void> > NodeState;
00158
00159 typedef boost::shared_ptr< ::nodemon_msgs::NodeState> NodeStatePtr;
00160 typedef boost::shared_ptr< ::nodemon_msgs::NodeState const> NodeStateConstPtr;
00161
00162
00163 template<typename ContainerAllocator>
00164 std::ostream& operator<<(std::ostream& s, const ::nodemon_msgs::NodeState_<ContainerAllocator> & v)
00165 {
00166 ros::message_operations::Printer< ::nodemon_msgs::NodeState_<ContainerAllocator> >::stream(s, "", v);
00167 return s;}
00168
00169 }
00170
00171 namespace ros
00172 {
00173 namespace message_traits
00174 {
00175 template<class ContainerAllocator> struct IsMessage< ::nodemon_msgs::NodeState_<ContainerAllocator> > : public TrueType {};
00176 template<class ContainerAllocator> struct IsMessage< ::nodemon_msgs::NodeState_<ContainerAllocator> const> : public TrueType {};
00177 template<class ContainerAllocator>
00178 struct MD5Sum< ::nodemon_msgs::NodeState_<ContainerAllocator> > {
00179 static const char* value()
00180 {
00181 return "e804800bd2445ee0aec90cce0edc3d66";
00182 }
00183
00184 static const char* value(const ::nodemon_msgs::NodeState_<ContainerAllocator> &) { return value(); }
00185 static const uint64_t static_value1 = 0xe804800bd2445ee0ULL;
00186 static const uint64_t static_value2 = 0xaec90cce0edc3d66ULL;
00187 };
00188
00189 template<class ContainerAllocator>
00190 struct DataType< ::nodemon_msgs::NodeState_<ContainerAllocator> > {
00191 static const char* value()
00192 {
00193 return "nodemon_msgs/NodeState";
00194 }
00195
00196 static const char* value(const ::nodemon_msgs::NodeState_<ContainerAllocator> &) { return value(); }
00197 };
00198
00199 template<class ContainerAllocator>
00200 struct Definition< ::nodemon_msgs::NodeState_<ContainerAllocator> > {
00201 static const char* value()
00202 {
00203 return "uint8 STARTING = 0 # node is currently started and not yet functional\n\
00204 uint8 RUNNING = 1 # node is fully operational\n\
00205 uint8 RECOVERING = 2 # node is recovering and currently not functional\n\
00206 uint8 ERROR = 3 # node had an error and will try to recover\n\
00207 uint8 FATAL = 4 # node had a fatal error and is disfunctional, restart req\n\
00208 uint8 STOPPING = 5 # node is no longer functional and will soon exit\n\
00209 uint8 WARNING = 6 # node encountered a problematic situation but continued\n\
00210 \n\
00211 string nodename\n\
00212 string package\n\
00213 string nodetype\n\
00214 time time\n\
00215 uint8 state\n\
00216 # A machine parseable error string\n\
00217 string machine_message\n\
00218 # A human readable error explanation\n\
00219 string human_message\n\
00220 \n\
00221 ";
00222 }
00223
00224 static const char* value(const ::nodemon_msgs::NodeState_<ContainerAllocator> &) { return value(); }
00225 };
00226
00227 }
00228 }
00229
00230 namespace ros
00231 {
00232 namespace serialization
00233 {
00234
00235 template<class ContainerAllocator> struct Serializer< ::nodemon_msgs::NodeState_<ContainerAllocator> >
00236 {
00237 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00238 {
00239 stream.next(m.nodename);
00240 stream.next(m.package);
00241 stream.next(m.nodetype);
00242 stream.next(m.time);
00243 stream.next(m.state);
00244 stream.next(m.machine_message);
00245 stream.next(m.human_message);
00246 }
00247
00248 ROS_DECLARE_ALLINONE_SERIALIZER;
00249 };
00250 }
00251 }
00252
00253 namespace ros
00254 {
00255 namespace message_operations
00256 {
00257
00258 template<class ContainerAllocator>
00259 struct Printer< ::nodemon_msgs::NodeState_<ContainerAllocator> >
00260 {
00261 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::nodemon_msgs::NodeState_<ContainerAllocator> & v)
00262 {
00263 s << indent << "nodename: ";
00264 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.nodename);
00265 s << indent << "package: ";
00266 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.package);
00267 s << indent << "nodetype: ";
00268 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.nodetype);
00269 s << indent << "time: ";
00270 Printer<ros::Time>::stream(s, indent + " ", v.time);
00271 s << indent << "state: ";
00272 Printer<uint8_t>::stream(s, indent + " ", v.state);
00273 s << indent << "machine_message: ";
00274 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.machine_message);
00275 s << indent << "human_message: ";
00276 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.human_message);
00277 }
00278 };
00279
00280
00281 }
00282 }
00283
00284 #endif // NODEMON_MSGS_MESSAGE_NODESTATE_H
00285
