hector_uav_msgs: hector_uav_msgs: RC.h Source File

00001 /* Auto-generated by genmsg_cpp for file /home/rosbuild/hudson/workspace/doc-electric-tu-darmstadt-ros-pkg/doc_stacks/2013-03-05_12-22-58.304137/hector_quadrotor/hector_uav_msgs/msg/RC.msg */
00002 #ifndef HECTOR_UAV_MSGS_MESSAGE_RC_H
00003 #define HECTOR_UAV_MSGS_MESSAGE_RC_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 "std_msgs/Header.h"
00018 
00019 namespace hector_uav_msgs
00020 {
00021 template <class ContainerAllocator>
00022 struct RC_ {
00023   typedef RC_<ContainerAllocator> Type;
00024 
00025   RC_()
00026   : header()
00027   , status(0)
00028   , valid(false)
00029   , axis()
00030   , axis_function()
00031   , swit()
00032   , swit_function()
00033   {
00034   }
00035 
00036   RC_(const ContainerAllocator& _alloc)
00037   : header(_alloc)
00038   , status(0)
00039   , valid(false)
00040   , axis(_alloc)
00041   , axis_function(_alloc)
00042   , swit(_alloc)
00043   , swit_function(_alloc)
00044   {
00045   }
00046 
00047   typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
00048    ::std_msgs::Header_<ContainerAllocator>  header;
00049 
00050   typedef uint8_t _status_type;
00051   uint8_t status;
00052 
00053   typedef uint8_t _valid_type;
00054   uint8_t valid;
00055 
00056   typedef std::vector<float, typename ContainerAllocator::template rebind<float>::other >  _axis_type;
00057   std::vector<float, typename ContainerAllocator::template rebind<float>::other >  axis;
00058 
00059   typedef std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other >  _axis_function_type;
00060   std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other >  axis_function;
00061 
00062   typedef std::vector<int8_t, typename ContainerAllocator::template rebind<int8_t>::other >  _swit_type;
00063   std::vector<int8_t, typename ContainerAllocator::template rebind<int8_t>::other >  swit;
00064 
00065   typedef std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other >  _swit_function_type;
00066   std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other >  swit_function;
00067 
00068   enum { ROLL = 1 };
00069   enum { PITCH = 2 };
00070   enum { YAW = 3 };
00071   enum { STEER = 4 };
00072   enum { HEIGHT = 5 };
00073   enum { THRUST = 6 };
00074   enum { BRAKE = 7 };
00075 
00076   ROS_DEPRECATED uint32_t get_axis_size() const { return (uint32_t)axis.size(); }
00077   ROS_DEPRECATED void set_axis_size(uint32_t size) { axis.resize((size_t)size); }
00078   ROS_DEPRECATED void get_axis_vec(std::vector<float, typename ContainerAllocator::template rebind<float>::other > & vec) const { vec = this->axis; }
00079   ROS_DEPRECATED void set_axis_vec(const std::vector<float, typename ContainerAllocator::template rebind<float>::other > & vec) { this->axis = vec; }
00080   ROS_DEPRECATED uint32_t get_axis_function_size() const { return (uint32_t)axis_function.size(); }
00081   ROS_DEPRECATED void set_axis_function_size(uint32_t size) { axis_function.resize((size_t)size); }
00082   ROS_DEPRECATED void get_axis_function_vec(std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other > & vec) const { vec = this->axis_function; }
00083   ROS_DEPRECATED void set_axis_function_vec(const std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other > & vec) { this->axis_function = vec; }
00084   ROS_DEPRECATED uint32_t get_swit_size() const { return (uint32_t)swit.size(); }
00085   ROS_DEPRECATED void set_swit_size(uint32_t size) { swit.resize((size_t)size); }
00086   ROS_DEPRECATED void get_swit_vec(std::vector<int8_t, typename ContainerAllocator::template rebind<int8_t>::other > & vec) const { vec = this->swit; }
00087   ROS_DEPRECATED void set_swit_vec(const std::vector<int8_t, typename ContainerAllocator::template rebind<int8_t>::other > & vec) { this->swit = vec; }
00088   ROS_DEPRECATED uint32_t get_swit_function_size() const { return (uint32_t)swit_function.size(); }
00089   ROS_DEPRECATED void set_swit_function_size(uint32_t size) { swit_function.resize((size_t)size); }
00090   ROS_DEPRECATED void get_swit_function_vec(std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other > & vec) const { vec = this->swit_function; }
00091   ROS_DEPRECATED void set_swit_function_vec(const std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other > & vec) { this->swit_function = vec; }
00092 private:
00093   static const char* __s_getDataType_() { return "hector_uav_msgs/RC"; }
00094 public:
00095   ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00096 
00097   ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00098 
00099 private:
00100   static const char* __s_getMD5Sum_() { return "2691c2fe8c5ab2323146bdd8dd2e449e"; }
00101 public:
00102   ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00103 
00104   ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00105 
00106 private:
00107   static const char* __s_getMessageDefinition_() { return "Header header\n\
00108 \n\
00109 uint8 ROLL = 1\n\
00110 uint8 PITCH = 2\n\
00111 uint8 YAW = 3\n\
00112 uint8 STEER = 4\n\
00113 uint8 HEIGHT = 5\n\
00114 uint8 THRUST = 6\n\
00115 uint8 BRAKE = 7\n\
00116 \n\
00117 uint8 status\n\
00118 bool valid\n\
00119 \n\
00120 float32[] axis\n\
00121 uint8[] axis_function\n\
00122 \n\
00123 int8[] swit\n\
00124 uint8[] swit_function\n\
00125 \n\
00126 ================================================================================\n\
00127 MSG: std_msgs/Header\n\
00128 # Standard metadata for higher-level stamped data types.\n\
00129 # This is generally used to communicate timestamped data \n\
00130 # in a particular coordinate frame.\n\
00131 # \n\
00132 # sequence ID: consecutively increasing ID \n\
00133 uint32 seq\n\
00134 #Two-integer timestamp that is expressed as:\n\
00135 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00136 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00137 # time-handling sugar is provided by the client library\n\
00138 time stamp\n\
00139 #Frame this data is associated with\n\
00140 # 0: no frame\n\
00141 # 1: global frame\n\
00142 string frame_id\n\
00143 \n\
00144 "; }
00145 public:
00146   ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00147 
00148   ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00149 
00150   ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00151   {
00152     ros::serialization::OStream stream(write_ptr, 1000000000);
00153     ros::serialization::serialize(stream, header);
00154     ros::serialization::serialize(stream, status);
00155     ros::serialization::serialize(stream, valid);
00156     ros::serialization::serialize(stream, axis);
00157     ros::serialization::serialize(stream, axis_function);
00158     ros::serialization::serialize(stream, swit);
00159     ros::serialization::serialize(stream, swit_function);
00160     return stream.getData();
00161   }
00162 
00163   ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00164   {
00165     ros::serialization::IStream stream(read_ptr, 1000000000);
00166     ros::serialization::deserialize(stream, header);
00167     ros::serialization::deserialize(stream, status);
00168     ros::serialization::deserialize(stream, valid);
00169     ros::serialization::deserialize(stream, axis);
00170     ros::serialization::deserialize(stream, axis_function);
00171     ros::serialization::deserialize(stream, swit);
00172     ros::serialization::deserialize(stream, swit_function);
00173     return stream.getData();
00174   }
00175 
00176   ROS_DEPRECATED virtual uint32_t serializationLength() const
00177   {
00178     uint32_t size = 0;
00179     size += ros::serialization::serializationLength(header);
00180     size += ros::serialization::serializationLength(status);
00181     size += ros::serialization::serializationLength(valid);
00182     size += ros::serialization::serializationLength(axis);
00183     size += ros::serialization::serializationLength(axis_function);
00184     size += ros::serialization::serializationLength(swit);
00185     size += ros::serialization::serializationLength(swit_function);
00186     return size;
00187   }
00188 
00189   typedef boost::shared_ptr< ::hector_uav_msgs::RC_<ContainerAllocator> > Ptr;
00190   typedef boost::shared_ptr< ::hector_uav_msgs::RC_<ContainerAllocator>  const> ConstPtr;
00191   boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00192 }; // struct RC
00193 typedef  ::hector_uav_msgs::RC_<std::allocator<void> > RC;
00194 
00195 typedef boost::shared_ptr< ::hector_uav_msgs::RC> RCPtr;
00196 typedef boost::shared_ptr< ::hector_uav_msgs::RC const> RCConstPtr;
00197 
00198 
00199 template<typename ContainerAllocator>
00200 std::ostream& operator<<(std::ostream& s, const  ::hector_uav_msgs::RC_<ContainerAllocator> & v)
00201 {
00202   ros::message_operations::Printer< ::hector_uav_msgs::RC_<ContainerAllocator> >::stream(s, "", v);
00203   return s;}
00204 
00205 } // namespace hector_uav_msgs
00206 
00207 namespace ros
00208 {
00209 namespace message_traits
00210 {
00211 template<class ContainerAllocator> struct IsMessage< ::hector_uav_msgs::RC_<ContainerAllocator> > : public TrueType {};
00212 template<class ContainerAllocator> struct IsMessage< ::hector_uav_msgs::RC_<ContainerAllocator>  const> : public TrueType {};
00213 template<class ContainerAllocator>
00214 struct MD5Sum< ::hector_uav_msgs::RC_<ContainerAllocator> > {
00215   static const char* value() 
00216   {
00217     return "2691c2fe8c5ab2323146bdd8dd2e449e";
00218   }
00219 
00220   static const char* value(const  ::hector_uav_msgs::RC_<ContainerAllocator> &) { return value(); } 
00221   static const uint64_t static_value1 = 0x2691c2fe8c5ab232ULL;
00222   static const uint64_t static_value2 = 0x3146bdd8dd2e449eULL;
00223 };
00224 
00225 template<class ContainerAllocator>
00226 struct DataType< ::hector_uav_msgs::RC_<ContainerAllocator> > {
00227   static const char* value() 
00228   {
00229     return "hector_uav_msgs/RC";
00230   }
00231 
00232   static const char* value(const  ::hector_uav_msgs::RC_<ContainerAllocator> &) { return value(); } 
00233 };
00234 
00235 template<class ContainerAllocator>
00236 struct Definition< ::hector_uav_msgs::RC_<ContainerAllocator> > {
00237   static const char* value() 
00238   {
00239     return "Header header\n\
00240 \n\
00241 uint8 ROLL = 1\n\
00242 uint8 PITCH = 2\n\
00243 uint8 YAW = 3\n\
00244 uint8 STEER = 4\n\
00245 uint8 HEIGHT = 5\n\
00246 uint8 THRUST = 6\n\
00247 uint8 BRAKE = 7\n\
00248 \n\
00249 uint8 status\n\
00250 bool valid\n\
00251 \n\
00252 float32[] axis\n\
00253 uint8[] axis_function\n\
00254 \n\
00255 int8[] swit\n\
00256 uint8[] swit_function\n\
00257 \n\
00258 ================================================================================\n\
00259 MSG: std_msgs/Header\n\
00260 # Standard metadata for higher-level stamped data types.\n\
00261 # This is generally used to communicate timestamped data \n\
00262 # in a particular coordinate frame.\n\
00263 # \n\
00264 # sequence ID: consecutively increasing ID \n\
00265 uint32 seq\n\
00266 #Two-integer timestamp that is expressed as:\n\
00267 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00268 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00269 # time-handling sugar is provided by the client library\n\
00270 time stamp\n\
00271 #Frame this data is associated with\n\
00272 # 0: no frame\n\
00273 # 1: global frame\n\
00274 string frame_id\n\
00275 \n\
00276 ";
00277   }
00278 
00279   static const char* value(const  ::hector_uav_msgs::RC_<ContainerAllocator> &) { return value(); } 
00280 };
00281 
00282 template<class ContainerAllocator> struct HasHeader< ::hector_uav_msgs::RC_<ContainerAllocator> > : public TrueType {};
00283 template<class ContainerAllocator> struct HasHeader< const ::hector_uav_msgs::RC_<ContainerAllocator> > : public TrueType {};
00284 } // namespace message_traits
00285 } // namespace ros
00286 
00287 namespace ros
00288 {
00289 namespace serialization
00290 {
00291 
00292 template<class ContainerAllocator> struct Serializer< ::hector_uav_msgs::RC_<ContainerAllocator> >
00293 {
00294   template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00295   {
00296     stream.next(m.header);
00297     stream.next(m.status);
00298     stream.next(m.valid);
00299     stream.next(m.axis);
00300     stream.next(m.axis_function);
00301     stream.next(m.swit);
00302     stream.next(m.swit_function);
00303   }
00304 
00305   ROS_DECLARE_ALLINONE_SERIALIZER;
00306 }; // struct RC_
00307 } // namespace serialization
00308 } // namespace ros
00309 
00310 namespace ros
00311 {
00312 namespace message_operations
00313 {
00314 
00315 template<class ContainerAllocator>
00316 struct Printer< ::hector_uav_msgs::RC_<ContainerAllocator> >
00317 {
00318   template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::hector_uav_msgs::RC_<ContainerAllocator> & v) 
00319   {
00320     s << indent << "header: ";
00321 s << std::endl;
00322     Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
00323     s << indent << "status: ";
00324     Printer<uint8_t>::stream(s, indent + "  ", v.status);
00325     s << indent << "valid: ";
00326     Printer<uint8_t>::stream(s, indent + "  ", v.valid);
00327     s << indent << "axis[]" << std::endl;
00328     for (size_t i = 0; i < v.axis.size(); ++i)
00329     {
00330       s << indent << "  axis[" << i << "]: ";
00331       Printer<float>::stream(s, indent + "  ", v.axis[i]);
00332     }
00333     s << indent << "axis_function[]" << std::endl;
00334     for (size_t i = 0; i < v.axis_function.size(); ++i)
00335     {
00336       s << indent << "  axis_function[" << i << "]: ";
00337       Printer<uint8_t>::stream(s, indent + "  ", v.axis_function[i]);
00338     }
00339     s << indent << "swit[]" << std::endl;
00340     for (size_t i = 0; i < v.swit.size(); ++i)
00341     {
00342       s << indent << "  swit[" << i << "]: ";
00343       Printer<int8_t>::stream(s, indent + "  ", v.swit[i]);
00344     }
00345     s << indent << "swit_function[]" << std::endl;
00346     for (size_t i = 0; i < v.swit_function.size(); ++i)
00347     {
00348       s << indent << "  swit_function[" << i << "]: ";
00349       Printer<uint8_t>::stream(s, indent + "  ", v.swit_function[i]);
00350     }
00351   }
00352 };
00353 
00354 
00355 } // namespace message_operations
00356 } // namespace ros
00357 
00358 #endif // HECTOR_UAV_MSGS_MESSAGE_RC_H
00359