header_deprecated_def.h
Go to the documentation of this file.
00001 /*
00002  * Copyright (C) 2009, Willow Garage, Inc.
00003  *
00004  * Redistribution and use in source and binary forms, with or without
00005  * modification, are permitted provided that the following conditions are met:
00006  *   * Redistributions of source code must retain the above copyright notice,
00007  *     this list of conditions and the following disclaimer.
00008  *   * Redistributions in binary form must reproduce the above copyright
00009  *     notice, this list of conditions and the following disclaimer in the
00010  *     documentation and/or other materials provided with the distribution.
00011  *   * Neither the names of Willow Garage, Inc. nor the names of its
00012  *     contributors may be used to endorse or promote products derived from
00013  *     this software without specific prior written permission.
00014  *
00015  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00016  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00017  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00018  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
00019  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00020  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00021  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00022  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00023  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00024  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00025  * POSSIBILITY OF SUCH DAMAGE.
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 }; // struct Header
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 } // namespace roslib
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 } // namespace message_traits
00206 } // namespace ros
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 }; // struct Header_
00224 } // namespace serialization
00225 } // namespace ros
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 } // namespace message_operations
00248 } // namespace ros
00249 


std_msgs
Author(s): Morgan Quigley , Ken Conley , Jeremy Leibs
autogenerated on Wed Aug 26 2015 16:27:59