Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 #ifndef STD_MSGS_INCLUDING_HEADER_DEPRECATED_DEF
00029 #error("Do not include this file directly. Instead, include std_msgs/Header.h")
00030 #endif
00031
00032 namespace roslib
00033 {
00034 template <class ContainerAllocator>
00035 struct Header_ : public std_msgs::Header_<ContainerAllocator>
00036 {
00037 typedef Header_<ContainerAllocator> Type;
00038
00039 ROS_DEPRECATED Header_()
00040 {
00041 }
00042
00043 ROS_DEPRECATED Header_(const ContainerAllocator& _alloc)
00044 : std_msgs::Header_<ContainerAllocator>(_alloc)
00045 {
00046 }
00047
00048 ROS_DEPRECATED Header_(const std_msgs::Header_<ContainerAllocator>& rhs)
00049 {
00050 *this = rhs;
00051 }
00052
00053 ROS_DEPRECATED Type& operator=(const std_msgs::Header_<ContainerAllocator>& rhs)
00054 {
00055 if (this == &rhs)
00056 return *this;
00057 this->seq = rhs.seq;
00058 this->stamp = rhs.stamp;
00059 this->frame_id = rhs.frame_id;
00060 return *this;
00061 }
00062
00063 ROS_DEPRECATED operator std_msgs::Header_<ContainerAllocator>()
00064 {
00065 std_msgs::Header_<ContainerAllocator> h;
00066 h.seq = this->seq;
00067 h.stamp = this->stamp;
00068 h.frame_id = this->frame_id;
00069 return h;
00070 }
00071
00072 private:
00073 static const char* __s_getDataType_() { return "roslib/Header"; }
00074 public:
00075 static const std::string __s_getDataType() { return __s_getDataType_(); }
00076
00077 const std::string __getDataType() const { return __s_getDataType_(); }
00078
00079 private:
00080 static const char* __s_getMD5Sum_() { return "2176decaecbce78abc3b96ef049fabed"; }
00081 public:
00082 static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00083
00084 const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00085
00086 private:
00087 static const char* __s_getMessageDefinition_() { return "# Standard metadata for higher-level stamped data types.\n\
00088 # This is generally used to communicate timestamped data \n\
00089 # in a particular coordinate frame.\n\
00090 # \n\
00091 # sequence ID: consecutively increasing ID \n\
00092 uint32 seq\n\
00093 #Two-integer timestamp that is expressed as:\n\
00094 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00095 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00096 # time-handling sugar is provided by the client library\n\
00097 time stamp\n\
00098 #Frame this data is associated with\n\
00099 # 0: no frame\n\
00100 # 1: global frame\n\
00101 string frame_id\n\
00102 \n\
00103 "; }
00104 public:
00105 static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00106
00107 const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00108
00109 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, this->seq);
00113 ros::serialization::serialize(stream, this->stamp);
00114 ros::serialization::serialize(stream, this->frame_id);
00115 return stream.getData();
00116 }
00117
00118 virtual uint8_t *deserialize(uint8_t *read_ptr)
00119 {
00120 ros::serialization::IStream stream(read_ptr, 1000000000);
00121 ros::serialization::deserialize(stream, this->seq);
00122 ros::serialization::deserialize(stream, this->stamp);
00123 ros::serialization::deserialize(stream, this->frame_id);
00124 return stream.getData();
00125 }
00126
00127 virtual uint32_t serializationLength() const
00128 {
00129 uint32_t size = 0;
00130 size += ros::serialization::serializationLength(this->seq);
00131 size += ros::serialization::serializationLength(this->stamp);
00132 size += ros::serialization::serializationLength(this->frame_id);
00133 return size;
00134 }
00135
00136 typedef boost::shared_ptr< ::roslib::Header_<ContainerAllocator> > Ptr;
00137 typedef boost::shared_ptr< ::roslib::Header_<ContainerAllocator> const> ConstPtr;
00138 };
00139 typedef ::roslib::Header_<std::allocator<void> > Header;
00140
00141 typedef boost::shared_ptr< ::roslib::Header> HeaderPtr;
00142 typedef boost::shared_ptr< ::roslib::Header const> HeaderConstPtr;
00143
00144
00145 template<typename ContainerAllocator>
00146 std::ostream& operator<<(std::ostream& s, const ::roslib::Header_<ContainerAllocator> & v)
00147 {
00148 ros::message_operations::Printer< ::roslib::Header_<ContainerAllocator> >::stream(s, "", v);
00149 return s;}
00150
00151 }
00152
00153 namespace ros
00154 {
00155 namespace message_traits
00156 {
00157 template<class ContainerAllocator>
00158 struct MD5Sum< ::roslib::Header_<ContainerAllocator> > {
00159 static const char* value()
00160 {
00161 return "2176decaecbce78abc3b96ef049fabed";
00162 }
00163
00164 static const char* value(const ::roslib::Header_<ContainerAllocator> &) { return value(); }
00165 static const uint64_t static_value1 = 0x2176decaecbce78aULL;
00166 static const uint64_t static_value2 = 0xbc3b96ef049fabedULL;
00167 };
00168
00169 template<class ContainerAllocator>
00170 struct DataType< ::roslib::Header_<ContainerAllocator> > {
00171 static const char* value()
00172 {
00173 return "roslib/Header";
00174 }
00175
00176 static const char* value(const ::roslib::Header_<ContainerAllocator> &) { return value(); }
00177 };
00178
00179 template<class ContainerAllocator>
00180 struct Definition< ::roslib::Header_<ContainerAllocator> > {
00181 static const char* value()
00182 {
00183 return "# Standard metadata for higher-level stamped data types.\n\
00184 # This is generally used to communicate timestamped data \n\
00185 # in a particular coordinate frame.\n\
00186 # \n\
00187 # sequence ID: consecutively increasing ID \n\
00188 uint32 seq\n\
00189 #Two-integer timestamp that is expressed as:\n\
00190 # * stamp.secs: seconds (stamp_secs) since epoch\n\
00191 # * stamp.nsecs: nanoseconds since stamp_secs\n\
00192 # time-handling sugar is provided by the client library\n\
00193 time stamp\n\
00194 #Frame this data is associated with\n\
00195 # 0: no frame\n\
00196 # 1: global frame\n\
00197 string frame_id\n\
00198 \n\
00199 ";
00200 }
00201
00202 static const char* value(const ::roslib::Header_<ContainerAllocator> &) { return value(); }
00203 };
00204
00205 }
00206 }
00207
00208 namespace ros
00209 {
00210 namespace serialization
00211 {
00212
00213 template<class ContainerAllocator> struct Serializer< ::roslib::Header_<ContainerAllocator> >
00214 {
00215 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00216 {
00217 stream.next(m.seq);
00218 stream.next(m.stamp);
00219 stream.next(m.frame_id);
00220 }
00221
00222 ROS_DECLARE_ALLINONE_SERIALIZER;
00223 };
00224 }
00225 }
00226
00227 namespace ros
00228 {
00229 namespace message_operations
00230 {
00231
00232 template<class ContainerAllocator>
00233 struct Printer< ::roslib::Header_<ContainerAllocator> >
00234 {
00235 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::roslib::Header_<ContainerAllocator> & v)
00236 {
00237 s << indent << "seq: ";
00238 Printer<uint32_t>::stream(s, indent + " ", v.seq);
00239 s << indent << "stamp: ";
00240 Printer<ros::Time>::stream(s, indent + " ", v.stamp);
00241 s << indent << "frame_id: ";
00242 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.frame_id);
00243 }
00244 };
00245
00246
00247 }
00248 }
00249