clearpath_base: clearpath_base: ClearpathRobot.h Source File

00001 /* Auto-generated by genmsg_cpp for file /home/rosbuild/hudson/workspace/doc-electric-clearpath_common/doc_stacks/2013-03-01_14-27-57.340522/clearpath_common/clearpath_base/msg/ClearpathRobot.msg */
00002 #ifndef CLEARPATH_BASE_MESSAGE_CLEARPATHROBOT_H
00003 #define CLEARPATH_BASE_MESSAGE_CLEARPATHROBOT_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 clearpath_base
00019 {
00020 template <class ContainerAllocator>
00021 struct ClearpathRobot_ {
00022   typedef ClearpathRobot_<ContainerAllocator> Type;
00023 
00024   ClearpathRobot_()
00025   : name()
00026   , model()
00027   , platform_revision(0)
00028   , serial(0)
00029   , horizon_version()
00030   , firmware_version()
00031   , firmware_revision(0)
00032   , write_date()
00033   {
00034     horizon_version.assign(0);
00035     firmware_version.assign(0);
00036   }
00037 
00038   ClearpathRobot_(const ContainerAllocator& _alloc)
00039   : name(_alloc)
00040   , model(_alloc)
00041   , platform_revision(0)
00042   , serial(0)
00043   , horizon_version()
00044   , firmware_version()
00045   , firmware_revision(0)
00046   , write_date(_alloc)
00047   {
00048     horizon_version.assign(0);
00049     firmware_version.assign(0);
00050   }
00051 
00052   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _name_type;
00053   std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  name;
00054 
00055   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _model_type;
00056   std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  model;
00057 
00058   typedef int32_t _platform_revision_type;
00059   int32_t platform_revision;
00060 
00061   typedef uint32_t _serial_type;
00062   uint32_t serial;
00063 
00064   typedef boost::array<int32_t, 2>  _horizon_version_type;
00065   boost::array<int32_t, 2>  horizon_version;
00066 
00067   typedef boost::array<int32_t, 2>  _firmware_version_type;
00068   boost::array<int32_t, 2>  firmware_version;
00069 
00070   typedef int32_t _firmware_revision_type;
00071   int32_t firmware_revision;
00072 
00073   typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _write_date_type;
00074   std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  write_date;
00075 
00076 
00077   ROS_DEPRECATED uint32_t get_horizon_version_size() const { return (uint32_t)horizon_version.size(); }
00078   ROS_DEPRECATED uint32_t get_firmware_version_size() const { return (uint32_t)firmware_version.size(); }
00079 private:
00080   static const char* __s_getDataType_() { return "clearpath_base/ClearpathRobot"; }
00081 public:
00082   ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00083 
00084   ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00085 
00086 private:
00087   static const char* __s_getMD5Sum_() { return "1bdab2b789676c1b350ab6739da650c7"; }
00088 public:
00089   ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00090 
00091   ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00092 
00093 private:
00094   static const char* __s_getMessageDefinition_() { return "string name\n\
00095 string model\n\
00096 int32 platform_revision\n\
00097 uint32 serial\n\
00098 int32[2] horizon_version\n\
00099 int32[2] firmware_version\n\
00100 int32 firmware_revision\n\
00101 string write_date\n\
00102 \n\
00103 "; }
00104 public:
00105   ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00106 
00107   ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00108 
00109   ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00110   {
00111     ros::serialization::OStream stream(write_ptr, 1000000000);
00112     ros::serialization::serialize(stream, name);
00113     ros::serialization::serialize(stream, model);
00114     ros::serialization::serialize(stream, platform_revision);
00115     ros::serialization::serialize(stream, serial);
00116     ros::serialization::serialize(stream, horizon_version);
00117     ros::serialization::serialize(stream, firmware_version);
00118     ros::serialization::serialize(stream, firmware_revision);
00119     ros::serialization::serialize(stream, write_date);
00120     return stream.getData();
00121   }
00122 
00123   ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00124   {
00125     ros::serialization::IStream stream(read_ptr, 1000000000);
00126     ros::serialization::deserialize(stream, name);
00127     ros::serialization::deserialize(stream, model);
00128     ros::serialization::deserialize(stream, platform_revision);
00129     ros::serialization::deserialize(stream, serial);
00130     ros::serialization::deserialize(stream, horizon_version);
00131     ros::serialization::deserialize(stream, firmware_version);
00132     ros::serialization::deserialize(stream, firmware_revision);
00133     ros::serialization::deserialize(stream, write_date);
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(name);
00141     size += ros::serialization::serializationLength(model);
00142     size += ros::serialization::serializationLength(platform_revision);
00143     size += ros::serialization::serializationLength(serial);
00144     size += ros::serialization::serializationLength(horizon_version);
00145     size += ros::serialization::serializationLength(firmware_version);
00146     size += ros::serialization::serializationLength(firmware_revision);
00147     size += ros::serialization::serializationLength(write_date);
00148     return size;
00149   }
00150 
00151   typedef boost::shared_ptr< ::clearpath_base::ClearpathRobot_<ContainerAllocator> > Ptr;
00152   typedef boost::shared_ptr< ::clearpath_base::ClearpathRobot_<ContainerAllocator>  const> ConstPtr;
00153   boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00154 }; // struct ClearpathRobot
00155 typedef  ::clearpath_base::ClearpathRobot_<std::allocator<void> > ClearpathRobot;
00156 
00157 typedef boost::shared_ptr< ::clearpath_base::ClearpathRobot> ClearpathRobotPtr;
00158 typedef boost::shared_ptr< ::clearpath_base::ClearpathRobot const> ClearpathRobotConstPtr;
00159 
00160 
00161 template<typename ContainerAllocator>
00162 std::ostream& operator<<(std::ostream& s, const  ::clearpath_base::ClearpathRobot_<ContainerAllocator> & v)
00163 {
00164   ros::message_operations::Printer< ::clearpath_base::ClearpathRobot_<ContainerAllocator> >::stream(s, "", v);
00165   return s;}
00166 
00167 } // namespace clearpath_base
00168 
00169 namespace ros
00170 {
00171 namespace message_traits
00172 {
00173 template<class ContainerAllocator> struct IsMessage< ::clearpath_base::ClearpathRobot_<ContainerAllocator> > : public TrueType {};
00174 template<class ContainerAllocator> struct IsMessage< ::clearpath_base::ClearpathRobot_<ContainerAllocator>  const> : public TrueType {};
00175 template<class ContainerAllocator>
00176 struct MD5Sum< ::clearpath_base::ClearpathRobot_<ContainerAllocator> > {
00177   static const char* value() 
00178   {
00179     return "1bdab2b789676c1b350ab6739da650c7";
00180   }
00181 
00182   static const char* value(const  ::clearpath_base::ClearpathRobot_<ContainerAllocator> &) { return value(); } 
00183   static const uint64_t static_value1 = 0x1bdab2b789676c1bULL;
00184   static const uint64_t static_value2 = 0x350ab6739da650c7ULL;
00185 };
00186 
00187 template<class ContainerAllocator>
00188 struct DataType< ::clearpath_base::ClearpathRobot_<ContainerAllocator> > {
00189   static const char* value() 
00190   {
00191     return "clearpath_base/ClearpathRobot";
00192   }
00193 
00194   static const char* value(const  ::clearpath_base::ClearpathRobot_<ContainerAllocator> &) { return value(); } 
00195 };
00196 
00197 template<class ContainerAllocator>
00198 struct Definition< ::clearpath_base::ClearpathRobot_<ContainerAllocator> > {
00199   static const char* value() 
00200   {
00201     return "string name\n\
00202 string model\n\
00203 int32 platform_revision\n\
00204 uint32 serial\n\
00205 int32[2] horizon_version\n\
00206 int32[2] firmware_version\n\
00207 int32 firmware_revision\n\
00208 string write_date\n\
00209 \n\
00210 ";
00211   }
00212 
00213   static const char* value(const  ::clearpath_base::ClearpathRobot_<ContainerAllocator> &) { return value(); } 
00214 };
00215 
00216 } // namespace message_traits
00217 } // namespace ros
00218 
00219 namespace ros
00220 {
00221 namespace serialization
00222 {
00223 
00224 template<class ContainerAllocator> struct Serializer< ::clearpath_base::ClearpathRobot_<ContainerAllocator> >
00225 {
00226   template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00227   {
00228     stream.next(m.name);
00229     stream.next(m.model);
00230     stream.next(m.platform_revision);
00231     stream.next(m.serial);
00232     stream.next(m.horizon_version);
00233     stream.next(m.firmware_version);
00234     stream.next(m.firmware_revision);
00235     stream.next(m.write_date);
00236   }
00237 
00238   ROS_DECLARE_ALLINONE_SERIALIZER;
00239 }; // struct ClearpathRobot_
00240 } // namespace serialization
00241 } // namespace ros
00242 
00243 namespace ros
00244 {
00245 namespace message_operations
00246 {
00247 
00248 template<class ContainerAllocator>
00249 struct Printer< ::clearpath_base::ClearpathRobot_<ContainerAllocator> >
00250 {
00251   template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::clearpath_base::ClearpathRobot_<ContainerAllocator> & v) 
00252   {
00253     s << indent << "name: ";
00254     Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.name);
00255     s << indent << "model: ";
00256     Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.model);
00257     s << indent << "platform_revision: ";
00258     Printer<int32_t>::stream(s, indent + "  ", v.platform_revision);
00259     s << indent << "serial: ";
00260     Printer<uint32_t>::stream(s, indent + "  ", v.serial);
00261     s << indent << "horizon_version[]" << std::endl;
00262     for (size_t i = 0; i < v.horizon_version.size(); ++i)
00263     {
00264       s << indent << "  horizon_version[" << i << "]: ";
00265       Printer<int32_t>::stream(s, indent + "  ", v.horizon_version[i]);
00266     }
00267     s << indent << "firmware_version[]" << std::endl;
00268     for (size_t i = 0; i < v.firmware_version.size(); ++i)
00269     {
00270       s << indent << "  firmware_version[" << i << "]: ";
00271       Printer<int32_t>::stream(s, indent + "  ", v.firmware_version[i]);
00272     }
00273     s << indent << "firmware_revision: ";
00274     Printer<int32_t>::stream(s, indent + "  ", v.firmware_revision);
00275     s << indent << "write_date: ";
00276     Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.write_date);
00277   }
00278 };
00279 
00280 
00281 } // namespace message_operations
00282 } // namespace ros
00283 
00284 #endif // CLEARPATH_BASE_MESSAGE_CLEARPATHROBOT_H
00285