From e941fec3f89bb4647ac3b8e2da347445713414af Mon Sep 17 00:00:00 2001 From: HiepLM Date: Fri, 5 Dec 2025 11:30:39 +0700 Subject: [PATCH] HiepLM --- geometry_msgs/include/geometry_msgs/Accel.h | 212 ++++++++++++++++-- .../include/geometry_msgs/AccelStamped.h | 73 ++++-- .../geometry_msgs/AccelWithCovariance.h | 90 +++++--- .../AccelWithCovarianceStamped.h | 76 +++++-- geometry_msgs/include/geometry_msgs/Inertia.h | 125 +++++++---- .../include/geometry_msgs/InertiaStamped.h | 74 ++++-- geometry_msgs/include/geometry_msgs/Point.h | 82 ++++--- geometry_msgs/include/geometry_msgs/Point32.h | 80 +++++-- .../include/geometry_msgs/PointStamped.h | 81 ++++--- geometry_msgs/include/geometry_msgs/Polygon.h | 73 ++++-- .../include/geometry_msgs/PolygonStamped.h | 75 +++++-- geometry_msgs/include/geometry_msgs/Pose.h | 77 ++++--- geometry_msgs/include/geometry_msgs/Pose2D.h | 92 ++++---- .../include/geometry_msgs/PoseArray.h | 81 ++++--- .../include/geometry_msgs/PoseStamped.h | 76 +++++-- .../geometry_msgs/PoseWithCovariance.h | 88 +++++--- .../geometry_msgs/PoseWithCovarianceStamped.h | 72 +++--- .../include/geometry_msgs/Quaternion.h | 87 ++++--- .../include/geometry_msgs/QuaternionStamped.h | 74 ++++-- .../include/geometry_msgs/Transform.h | 76 +++++-- .../include/geometry_msgs/TransformStamped.h | 80 +++++-- geometry_msgs/include/geometry_msgs/Twist.h | 77 ++++--- .../include/geometry_msgs/TwistStamped.h | 75 +++++-- .../geometry_msgs/TwistWithCovariance.h | 88 +++++--- .../TwistWithCovarianceStamped.h | 75 +++++-- geometry_msgs/include/geometry_msgs/Vector3.h | 78 ++++--- .../include/geometry_msgs/Vector3Stamped.h | 74 ++++-- geometry_msgs/include/geometry_msgs/Wrench.h | 79 ++++--- .../include/geometry_msgs/WrenchStamped.h | 75 +++++-- nav_msgs/include/nav_msgs/MapMetaData.h | 2 +- std_msgs/include/std_msgs/Header.h | 80 +++++-- 31 files changed, 1738 insertions(+), 809 deletions(-) diff --git a/geometry_msgs/include/geometry_msgs/Accel.h b/geometry_msgs/include/geometry_msgs/Accel.h index a2916d6..183b0d1 100644 --- a/geometry_msgs/include/geometry_msgs/Accel.h +++ b/geometry_msgs/include/geometry_msgs/Accel.h @@ -1,41 +1,209 @@ -// # This expresses acceleration in free space broken into its linear and angular parts. -// Vector3 linear -// Vector3 angular +// Generated by gencpp from file geometry_msgs/Accel.msg +// DO NOT EDIT! -#ifndef ACCEL_H -#define ACCEL_H +#ifndef GEOMETRY_MSGS_MESSAGE_ACCEL_H +#define GEOMETRY_MSGS_MESSAGE_ACCEL_H + + +#include +#include +#include +#include +#include #include namespace geometry_msgs { - -struct Accel +template +struct Accel_ { - Vector3 linear; - Vector3 angular; + typedef Accel_ Type; - // Constructor mặc định - Accel() : linear(), angular() {} + Accel_() + : linear() + , angular() { + } + Accel_(const ContainerAllocator& _alloc) + : linear(_alloc) + , angular(_alloc) { + (void)_alloc; + } - // Constructor khởi tạo nhanh - Accel(const Vector3& linear_, const Vector3& angular_) - : linear(linear_), angular(angular_) {} -}; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Accel &lhs, const geometry_msgs::Accel &rhs) + + typedef ::geometry_msgs::Vector3_ _linear_type; + _linear_type linear; + + typedef ::geometry_msgs::Vector3_ _angular_type; + _angular_type angular; + + + + + + typedef boost::shared_ptr< ::geometry_msgs::Accel_ > Ptr; + typedef boost::shared_ptr< ::geometry_msgs::Accel_ const> ConstPtr; + +}; // struct Accel_ + +typedef ::geometry_msgs::Accel_ > Accel; + +typedef boost::shared_ptr< ::geometry_msgs::Accel > AccelPtr; +typedef boost::shared_ptr< ::geometry_msgs::Accel const> AccelConstPtr; + + +template +bool operator==(const ::geometry_msgs::Accel_ & lhs, const ::geometry_msgs::Accel_ & rhs) { -return lhs.linear == rhs.linear && - lhs.angular == rhs.angular; + return lhs.linear == rhs.linear && + lhs.angular == rhs.angular; } -inline bool operator!=(const geometry_msgs::Accel &lhs, const geometry_msgs::Accel &rhs) +template +bool operator!=(const ::geometry_msgs::Accel_ & lhs, const ::geometry_msgs::Accel_ & rhs) { -return !(lhs == rhs); + return !(lhs == rhs); } } // namespace geometry_msgs -#endif // ACCEL_H +namespace ros +{ +namespace message_traits +{ + + + + + +template +struct IsMessage< ::geometry_msgs::Accel_ > + : TrueType + { }; + +template +struct IsMessage< ::geometry_msgs::Accel_ const> + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Accel_ > + : TrueType + { }; + +template +struct IsFixedSize< ::geometry_msgs::Accel_ const> + : TrueType + { }; + +template +struct HasHeader< ::geometry_msgs::Accel_ > + : FalseType + { }; + +template +struct HasHeader< ::geometry_msgs::Accel_ const> + : FalseType + { }; + + +template +struct MD5Sum< ::geometry_msgs::Accel_ > +{ + static const char* value() + { + return "9f195f881246fdfa2798d1d3eebca84a"; + } + + static const char* value(const ::geometry_msgs::Accel_&) { return value(); } + static const uint64_t static_value1 = 0x9f195f881246fdfaULL; + static const uint64_t static_value2 = 0x2798d1d3eebca84aULL; +}; + +template +struct DataType< ::geometry_msgs::Accel_ > +{ + static const char* value() + { + return "geometry_msgs/Accel"; + } + + static const char* value(const ::geometry_msgs::Accel_&) { return value(); } +}; + +template +struct Definition< ::geometry_msgs::Accel_ > +{ + static const char* value() + { + return "# This expresses acceleration in free space broken into its linear and angular parts.\n" +"Vector3 linear\n" +"Vector3 angular\n" +"\n" +"================================================================================\n" +"MSG: geometry_msgs/Vector3\n" +"# This represents a vector in free space. \n" +"# It is only meant to represent a direction. Therefore, it does not\n" +"# make sense to apply a translation to it (e.g., when applying a \n" +"# generic rigid transformation to a Vector3, tf2 will only apply the\n" +"# rotation). If you want your data to be translatable too, use the\n" +"# geometry_msgs/Point message instead.\n" +"\n" +"float64 x\n" +"float64 y\n" +"float64 z\n" +; + } + + static const char* value(const ::geometry_msgs::Accel_&) { return value(); } +}; + +} // namespace message_traits +} // namespace ros + +namespace ros +{ +namespace serialization +{ + + template struct Serializer< ::geometry_msgs::Accel_ > + { + template inline static void allInOne(Stream& stream, T m) + { + stream.next(m.linear); + stream.next(m.angular); + } + + ROS_DECLARE_ALLINONE_SERIALIZER + }; // struct Accel_ + +} // namespace serialization +} // namespace ros + +namespace ros +{ +namespace message_operations +{ + +template +struct Printer< ::geometry_msgs::Accel_ > +{ + template static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Accel_& v) + { + if (false || !indent.empty()) + s << std::endl; + s << indent << "linear: "; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.linear); + if (true || !indent.empty()) + s << std::endl; + s << indent << "angular: "; + Printer< ::geometry_msgs::Vector3_ >::stream(s, indent + " ", v.angular); + } +}; + +} // namespace message_operations +} // namespace ros + +#endif // GEOMETRY_MSGS_MESSAGE_ACCEL_H \ No newline at end of file diff --git a/geometry_msgs/include/geometry_msgs/AccelStamped.h b/geometry_msgs/include/geometry_msgs/AccelStamped.h index 4425ccb..24387f1 100644 --- a/geometry_msgs/include/geometry_msgs/AccelStamped.h +++ b/geometry_msgs/include/geometry_msgs/AccelStamped.h @@ -1,36 +1,61 @@ -// # An accel with reference coordinate frame and timestamp -// Header header -// Accel accel +// Generated by gencpp from file geometry_msgs/AccelStamped.msg +// DO NOT EDIT! -#ifndef ACCEL_STAMPED_H -#define ACCEL_STAMPED_H +#ifndef GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H +#include +#include +#include +#include #include #include namespace geometry_msgs { + template + struct AccelStamped_ + { + typedef AccelStamped_ Type; -struct AccelStamped -{ - std_msgs::Header header; - Accel accel; - // Constructor mặc định - AccelStamped() = default; -}; + AccelStamped_() + : header(), accel() + { + } + AccelStamped_(const ContainerAllocator &_alloc) + : header(_alloc), accel(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::AccelStamped &lhs, const geometry_msgs::AccelStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.accel == rhs.accel; -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; -inline bool operator!=(const geometry_msgs::AccelStamped &lhs, const geometry_msgs::AccelStamped &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Accel_ _accel_type; + _accel_type accel; + + typedef boost::shared_ptr<::geometry_msgs::AccelStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::AccelStamped_ const> ConstPtr; + + }; // struct AccelStamped_ + + typedef ::geometry_msgs::AccelStamped_> AccelStamped; + + typedef boost::shared_ptr<::geometry_msgs::AccelStamped> AccelStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::AccelStamped const> AccelStampedConstPtr; + + template + bool operator==(const ::geometry_msgs::AccelStamped_ &lhs, const ::geometry_msgs::AccelStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.accel == rhs.accel; + } + + template + bool operator!=(const ::geometry_msgs::AccelStamped_ &lhs, const ::geometry_msgs::AccelStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // ACCEL_STAMPED_H +#endif // GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/AccelWithCovariance.h b/geometry_msgs/include/geometry_msgs/AccelWithCovariance.h index b6e1dfd..68d28b5 100644 --- a/geometry_msgs/include/geometry_msgs/AccelWithCovariance.h +++ b/geometry_msgs/include/geometry_msgs/AccelWithCovariance.h @@ -1,49 +1,65 @@ -// # This expresses acceleration in free space with uncertainty. +// Generated by gencpp from file geometry_msgs/AccelWithCovariance.msg +// DO NOT EDIT! -// Accel accel +#ifndef GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H +#define GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H -// # Row-major representation of the 6x6 covariance matrix -// # The orientation parameters use a fixed-axis representation. -// # In order, the parameters are: -// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis) -// float64[36] covariance - -#ifndef ACCEL_WITH_COVARIANCE_H -#define ACCEL_WITH_COVARIANCE_H - -#include +#include +#include +#include +#include +#include #include namespace geometry_msgs { + template + struct AccelWithCovariance_ + { + typedef AccelWithCovariance_ Type; -struct AccelWithCovariance -{ - Accel accel; - std::array covariance; - // Constructor mặc định - AccelWithCovariance() : accel(), covariance{{0.0}} {}; -}; - -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::AccelWithCovariance &lhs, const geometry_msgs::AccelWithCovariance &rhs) -{ - for(size_t i = 0; i < 36; ++i) + AccelWithCovariance_() + : accel(), covariance() { - if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false) - { - return false; - } + covariance.assign(0.0); + } + AccelWithCovariance_(const ContainerAllocator &_alloc) + : accel(_alloc), covariance() + { + (void)_alloc; + covariance.assign(0.0); } -return lhs.accel == rhs.accel; -} -inline bool operator!=(const geometry_msgs::AccelWithCovariance &lhs, const geometry_msgs::AccelWithCovariance &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Accel_ _accel_type; + _accel_type accel; + + typedef boost::array _covariance_type; + _covariance_type covariance; + + typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance_ const> ConstPtr; + + }; // struct AccelWithCovariance_ + + typedef ::geometry_msgs::AccelWithCovariance_> AccelWithCovariance; + + typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance> AccelWithCovariancePtr; + typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance const> AccelWithCovarianceConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::AccelWithCovariance_ &lhs, const ::geometry_msgs::AccelWithCovariance_ &rhs) + { + return lhs.accel == rhs.accel && + lhs.covariance == rhs.covariance; + } + + template + bool operator!=(const ::geometry_msgs::AccelWithCovariance_ &lhs, const ::geometry_msgs::AccelWithCovariance_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // ACCEL_WITH_COVARIANCE_H - +#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H diff --git a/geometry_msgs/include/geometry_msgs/AccelWithCovarianceStamped.h b/geometry_msgs/include/geometry_msgs/AccelWithCovarianceStamped.h index 7c11335..71d4879 100644 --- a/geometry_msgs/include/geometry_msgs/AccelWithCovarianceStamped.h +++ b/geometry_msgs/include/geometry_msgs/AccelWithCovarianceStamped.h @@ -1,36 +1,64 @@ -// # This represents an estimated accel with reference coordinate frame and timestamp. -// Header header -// AccelWithCovariance accel +// Generated by gencpp from file geometry_msgs/AccelWithCovarianceStamped.msg +// DO NOT EDIT! -#ifndef ACCEL_WITH_COVARIANCE_STAMPED_H -#define ACCEL_WITH_COVARIANCE_STAMPED_H +#ifndef GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H + +#include +#include +#include +#include #include #include namespace geometry_msgs { + template + struct AccelWithCovarianceStamped_ + { + typedef AccelWithCovarianceStamped_ Type; -struct AccelWithCovarianceStamped -{ - std_msgs::Header header; - AccelWithCovariance accel; - // Constructor mặc định - AccelWithCovarianceStamped() = default; -}; + AccelWithCovarianceStamped_() + : header(), accel() + { + } + AccelWithCovarianceStamped_(const ContainerAllocator &_alloc) + : header(_alloc), accel(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::AccelWithCovarianceStamped &lhs, const geometry_msgs::AccelWithCovarianceStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.accel == rhs.accel; -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; -inline bool operator!=(const geometry_msgs::AccelWithCovarianceStamped &lhs, const geometry_msgs::AccelWithCovarianceStamped &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::AccelWithCovariance_ _accel_type; + _accel_type accel; + + typedef boost::shared_ptr<::geometry_msgs::AccelWithCovarianceStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::AccelWithCovarianceStamped_ const> ConstPtr; + + }; // struct AccelWithCovarianceStamped_ + + typedef ::geometry_msgs::AccelWithCovarianceStamped_> AccelWithCovarianceStamped; + + typedef boost::shared_ptr<::geometry_msgs::AccelWithCovarianceStamped> AccelWithCovarianceStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::AccelWithCovarianceStamped const> AccelWithCovarianceStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::AccelWithCovarianceStamped_ &lhs, const ::geometry_msgs::AccelWithCovarianceStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.accel == rhs.accel; + } + + template + bool operator!=(const ::geometry_msgs::AccelWithCovarianceStamped_ &lhs, const ::geometry_msgs::AccelWithCovarianceStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // ACCEL_WITH_COVARIANCE_STAMPED_H +#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/Inertia.h b/geometry_msgs/include/geometry_msgs/Inertia.h index 1080834..1f88f43 100644 --- a/geometry_msgs/include/geometry_msgs/Inertia.h +++ b/geometry_msgs/include/geometry_msgs/Inertia.h @@ -1,61 +1,88 @@ -#ifndef INERTIA_H -#define INERTIA_H +// Generated by gencpp from file geometry_msgs/Inertia.msg +// DO NOT EDIT! + +#ifndef GEOMETRY_MSGS_MESSAGE_INERTIA_H +#define GEOMETRY_MSGS_MESSAGE_INERTIA_H + +#include +#include +#include +#include #include namespace geometry_msgs { + template + struct Inertia_ + { + typedef Inertia_ Type; -struct Inertia -{ - double m; - Vector3 com; - double ixx; - double ixy; - double ixz; - double iyy; - double iyz; - double izz; + Inertia_() + : m(0.0), com(), ixx(0.0), ixy(0.0), ixz(0.0), iyy(0.0), iyz(0.0), izz(0.0) + { + } + Inertia_(const ContainerAllocator &_alloc) + : m(0.0), com(_alloc), ixx(0.0), ixy(0.0), ixz(0.0), iyy(0.0), iyz(0.0), izz(0.0) + { + (void)_alloc; + } - Inertia() : - m(0.0), - com(), - ixx(0.0), - ixy(0.0), - ixz(0.0), - iyy(0.0), - iyz(0.0), - izz(0.0) {}; - Inertia(double m_, Vector3 com_, double ixx_, double ixy_, double ixz_, - double iyy_, double iyz_, double izz_) : - m(m_), - com(com_), - ixx(ixx_), - ixy(ixy_), - ixz(ixz_), - iyy(iyy_), - iyz(iyz_), - izz(izz_) {}; -}; + typedef double _m_type; + _m_type m; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Inertia &lhs, const geometry_msgs::Inertia &rhs) -{ -return isEqual(lhs.m, rhs.m) && - lhs.com == rhs.com && - isEqual(lhs.ixx, rhs.ixx) && - isEqual(lhs.ixy, rhs.ixy) && - isEqual(lhs.ixz, rhs.ixz) && - isEqual(lhs.iyy, rhs.iyy) && - isEqual(lhs.iyz, rhs.iyz) && - isEqual(lhs.izz, rhs.izz); -} + typedef ::geometry_msgs::Vector3_ _com_type; + _com_type com; -inline bool operator!=(const geometry_msgs::Inertia &lhs, const geometry_msgs::Inertia &rhs) -{ -return !(lhs == rhs); -} + typedef double _ixx_type; + _ixx_type ixx; + + typedef double _ixy_type; + _ixy_type ixy; + + typedef double _ixz_type; + _ixz_type ixz; + + typedef double _iyy_type; + _iyy_type iyy; + + typedef double _iyz_type; + _iyz_type iyz; + + typedef double _izz_type; + _izz_type izz; + + typedef boost::shared_ptr<::geometry_msgs::Inertia_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Inertia_ const> ConstPtr; + + }; // struct Inertia_ + + typedef ::geometry_msgs::Inertia_> Inertia; + + typedef boost::shared_ptr<::geometry_msgs::Inertia> InertiaPtr; + typedef boost::shared_ptr<::geometry_msgs::Inertia const> InertiaConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Inertia_ &lhs, const ::geometry_msgs::Inertia_ &rhs) + { + return lhs.m == rhs.m && + lhs.com == rhs.com && + lhs.ixx == rhs.ixx && + lhs.ixy == rhs.ixy && + lhs.ixz == rhs.ixz && + lhs.iyy == rhs.iyy && + lhs.iyz == rhs.iyz && + lhs.izz == rhs.izz; + } + + template + bool operator!=(const ::geometry_msgs::Inertia_ &lhs, const ::geometry_msgs::Inertia_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // INERTIA_H +#endif // GEOMETRY_MSGS_MESSAGE_INERTIA_H diff --git a/geometry_msgs/include/geometry_msgs/InertiaStamped.h b/geometry_msgs/include/geometry_msgs/InertiaStamped.h index ccf55ab..73866a5 100644 --- a/geometry_msgs/include/geometry_msgs/InertiaStamped.h +++ b/geometry_msgs/include/geometry_msgs/InertiaStamped.h @@ -1,35 +1,65 @@ -// Header header -// Inertia inertia +// Generated by gencpp from file geometry_msgs/InertiaStamped.msg +// DO NOT EDIT! -#ifndef INERTIA_STAMPED_H -#define INERTIA_STAMPED_H +#ifndef GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H + +#include +#include +#include +#include #include #include namespace geometry_msgs { + template + struct InertiaStamped_ + { + typedef InertiaStamped_ Type; -struct InertiaStamped -{ - std_msgs::Header header; - Inertia inertia; - // Constructor mặc định - InertiaStamped() = default; -}; + InertiaStamped_() + : header(), inertia() + { + } + InertiaStamped_(const ContainerAllocator &_alloc) + : header(_alloc), inertia(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::InertiaStamped &lhs, const geometry_msgs::InertiaStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.inertia == rhs.inertia; -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; -inline bool operator!=(const geometry_msgs::InertiaStamped &lhs, const geometry_msgs::InertiaStamped &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Inertia_ _inertia_type; + _inertia_type inertia; + + typedef boost::shared_ptr<::geometry_msgs::InertiaStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::InertiaStamped_ const> ConstPtr; + + }; // struct InertiaStamped_ + + typedef ::geometry_msgs::InertiaStamped_> InertiaStamped; + + typedef boost::shared_ptr<::geometry_msgs::InertiaStamped> InertiaStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::InertiaStamped const> InertiaStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::InertiaStamped_ &lhs, const ::geometry_msgs::InertiaStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.inertia == rhs.inertia; + } + + template + bool operator!=(const ::geometry_msgs::InertiaStamped_ &lhs, const ::geometry_msgs::InertiaStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // INERTIA_STAMPED_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/Point.h b/geometry_msgs/include/geometry_msgs/Point.h index 926a609..9434ecd 100644 --- a/geometry_msgs/include/geometry_msgs/Point.h +++ b/geometry_msgs/include/geometry_msgs/Point.h @@ -1,41 +1,65 @@ -#ifndef POINT_H -#define POINT_H +// Generated by gencpp from file geometry_msgs/Point.msg +// DO NOT EDIT! -#include -#include -#include "utils.h" +#ifndef GEOMETRY_MSGS_MESSAGE_POINT_H +#define GEOMETRY_MSGS_MESSAGE_POINT_H + +#include +#include +#include +#include namespace geometry_msgs { + template + struct Point_ + { + typedef Point_ Type; -struct Point -{ - double x; - double y; - double z; + Point_() + : x(0.0), y(0.0), z(0.0) + { + } + Point_(const ContainerAllocator &_alloc) + : x(0.0), y(0.0), z(0.0) + { + (void)_alloc; + } - // Constructor mặc định - Point() : x(0.0), y(0.0), z(0.0) {} + typedef double _x_type; + _x_type x; - // Constructor khởi tạo nhanh - Point(double x_, double y_, double z_ = 0.0) - : x(x_), y(y_), z(z_) {} -}; + typedef double _y_type; + _y_type y; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Point &lhs, const geometry_msgs::Point &rhs) -{ -return isEqual(lhs.x, rhs.x) && - isEqual(lhs.y, rhs.y) && - isEqual(lhs.z, rhs.z); -} + typedef double _z_type; + _z_type z; -inline bool operator!=(const geometry_msgs::Point &lhs, const geometry_msgs::Point &rhs) -{ -return !(lhs == rhs); -} + typedef boost::shared_ptr<::geometry_msgs::Point_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Point_ const> ConstPtr; + }; // struct Point_ + + typedef ::geometry_msgs::Point_> Point; + + typedef boost::shared_ptr<::geometry_msgs::Point> PointPtr; + typedef boost::shared_ptr<::geometry_msgs::Point const> PointConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Point_ &lhs, const ::geometry_msgs::Point_ &rhs) + { + return lhs.x == rhs.x && + lhs.y == rhs.y && + lhs.z == rhs.z; + } + + template + bool operator!=(const ::geometry_msgs::Point_ &lhs, const ::geometry_msgs::Point_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // POINT_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_POINT_H diff --git a/geometry_msgs/include/geometry_msgs/Point32.h b/geometry_msgs/include/geometry_msgs/Point32.h index 2a9d0a9..fc15ff8 100644 --- a/geometry_msgs/include/geometry_msgs/Point32.h +++ b/geometry_msgs/include/geometry_msgs/Point32.h @@ -1,34 +1,66 @@ -#ifndef POINT_32_H -#define POINT_32_H +// Generated by gencpp from file geometry_msgs/Point32.msg +// DO NOT EDIT! -#include "utils.h" +#ifndef GEOMETRY_MSGS_MESSAGE_POINT32_H +#define GEOMETRY_MSGS_MESSAGE_POINT32_H + +#include +#include +#include +#include namespace geometry_msgs { -struct Point32 -{ - float x; - float y; - float z; + template + struct Point32_ + { + typedef Point32_ Type; - Point32() : x(0.0f), y(0.0f), z(0.0f) {} - Point32(float x_, float y_, float z_) - : x(x_), y(y_), z(z_) {} -}; + Point32_() + : x(0.0), y(0.0), z(0.0) + { + } + Point32_(const ContainerAllocator &_alloc) + : x(0.0), y(0.0), z(0.0) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Point32 &lhs, const geometry_msgs::Point32 &rhs) -{ -return isEqual(lhs.x, rhs.x) && - isEqual(lhs.y, rhs.y) && - isEqual(lhs.z, rhs.z); -} + typedef float _x_type; + _x_type x; -inline bool operator!=(const geometry_msgs::Point32 &lhs, const geometry_msgs::Point32 &rhs) -{ -return !(lhs == rhs); -} + typedef float _y_type; + _y_type y; + + typedef float _z_type; + _z_type z; + + typedef boost::shared_ptr<::geometry_msgs::Point32_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Point32_ const> ConstPtr; + + }; // struct Point32_ + + typedef ::geometry_msgs::Point32_> Point32; + + typedef boost::shared_ptr<::geometry_msgs::Point32> Point32Ptr; + typedef boost::shared_ptr<::geometry_msgs::Point32 const> Point32ConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Point32_ &lhs, const ::geometry_msgs::Point32_ &rhs) + { + return lhs.x == rhs.x && + lhs.y == rhs.y && + lhs.z == rhs.z; + } + + template + bool operator!=(const ::geometry_msgs::Point32_ &lhs, const ::geometry_msgs::Point32_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif //POINT_32_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_POINT32_H diff --git a/geometry_msgs/include/geometry_msgs/PointStamped.h b/geometry_msgs/include/geometry_msgs/PointStamped.h index a7585e2..920573b 100644 --- a/geometry_msgs/include/geometry_msgs/PointStamped.h +++ b/geometry_msgs/include/geometry_msgs/PointStamped.h @@ -1,34 +1,65 @@ -// # This represents a Point with reference coordinate frame and timestamp -// Header header -// Point point -#ifndef POINT_STAMPED_H -#define POINT_STAMPED_H -#include "std_msgs/Header.h" -#include "geometry_msgs/Point.h" +// Generated by gencpp from file geometry_msgs/PointStamped.msg +// DO NOT EDIT! + +#ifndef GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H + +#include +#include +#include +#include + +#include +#include namespace geometry_msgs { - -struct PointStamped -{ - std_msgs::Header header; - geometry_msgs::Point point; - PointStamped() = default; -}; + template + struct PointStamped_ + { + typedef PointStamped_ Type; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::PointStamped &lhs, const geometry_msgs::PointStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.point == rhs.point; -} + PointStamped_() + : header(), point() + { + } + PointStamped_(const ContainerAllocator &_alloc) + : header(_alloc), point(_alloc) + { + (void)_alloc; + } -inline bool operator!=(const geometry_msgs::PointStamped &lhs, const geometry_msgs::PointStamped &rhs) -{ -return !(lhs == rhs); -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; + typedef ::geometry_msgs::Point_ _point_type; + _point_type point; + + typedef boost::shared_ptr<::geometry_msgs::PointStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::PointStamped_ const> ConstPtr; + + }; // struct PointStamped_ + + typedef ::geometry_msgs::PointStamped_> PointStamped; + + typedef boost::shared_ptr<::geometry_msgs::PointStamped> PointStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::PointStamped const> PointStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::PointStamped_ &lhs, const ::geometry_msgs::PointStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.point == rhs.point; + } + + template + bool operator!=(const ::geometry_msgs::PointStamped_ &lhs, const ::geometry_msgs::PointStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif //POINT_STAMPED_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/Polygon.h b/geometry_msgs/include/geometry_msgs/Polygon.h index 2dbebe6..b6aec7a 100644 --- a/geometry_msgs/include/geometry_msgs/Polygon.h +++ b/geometry_msgs/include/geometry_msgs/Polygon.h @@ -1,33 +1,60 @@ -#ifndef POLYGON_H -#define POLYGON_H -#include -#include +// Generated by gencpp from file geometry_msgs/Polygon.msg +// DO NOT EDIT! + +#ifndef GEOMETRY_MSGS_MESSAGE_POLYGON_H +#define GEOMETRY_MSGS_MESSAGE_POLYGON_H + +#include +#include +#include +#include + +#include namespace geometry_msgs { + template + struct Polygon_ + { + typedef Polygon_ Type; -struct Polygon -{ - std::vector points; -}; - -inline bool operator==(const geometry_msgs::Polygon &lhs, const geometry_msgs::Polygon &rhs) -{ - if(lhs.points.size() != rhs.points.size()) - return false; - for(int i = 0; i < lhs.points.size(); i++) + Polygon_() + : points() { - if(!(lhs.points[i] == rhs.points[i])) - return false; } - return true; -} + Polygon_(const ContainerAllocator &_alloc) + : points(_alloc) + { + (void)_alloc; + } -inline bool operator!=(const geometry_msgs::Polygon &lhs, const geometry_msgs::Polygon &rhs) -{ -return !(lhs == rhs); -} + typedef std::vector<::geometry_msgs::Point32_, typename std::allocator_traits::template rebind_alloc<::geometry_msgs::Point32_>> _points_type; + _points_type points; + + typedef boost::shared_ptr<::geometry_msgs::Polygon_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Polygon_ const> ConstPtr; + + }; // struct Polygon_ + + typedef ::geometry_msgs::Polygon_> Polygon; + + typedef boost::shared_ptr<::geometry_msgs::Polygon> PolygonPtr; + typedef boost::shared_ptr<::geometry_msgs::Polygon const> PolygonConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Polygon_ &lhs, const ::geometry_msgs::Polygon_ &rhs) + { + return lhs.points == rhs.points; + } + + template + bool operator!=(const ::geometry_msgs::Polygon_ &lhs, const ::geometry_msgs::Polygon_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif //POLYGON_H +#endif // GEOMETRY_MSGS_MESSAGE_POLYGON_H diff --git a/geometry_msgs/include/geometry_msgs/PolygonStamped.h b/geometry_msgs/include/geometry_msgs/PolygonStamped.h index 3c409d2..619ae3a 100644 --- a/geometry_msgs/include/geometry_msgs/PolygonStamped.h +++ b/geometry_msgs/include/geometry_msgs/PolygonStamped.h @@ -1,32 +1,65 @@ -// # This represents a Polygon with reference coordinate frame and timestamp -// Header header -// Polygon polygon -#ifndef POLYGON_STAMPED_H -#define POLYGON_STAMPED_H +// Generated by gencpp from file geometry_msgs/PolygonStamped.msg +// DO NOT EDIT! -#include -#include +#ifndef GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H + +#include +#include +#include +#include + +#include +#include namespace geometry_msgs { + template + struct PolygonStamped_ + { + typedef PolygonStamped_ Type; -struct PolygonStamped -{ - std_msgs::Header header; - Polygon polygon; -}; + PolygonStamped_() + : header(), polygon() + { + } + PolygonStamped_(const ContainerAllocator &_alloc) + : header(_alloc), polygon(_alloc) + { + (void)_alloc; + } -inline bool operator==(const geometry_msgs::PolygonStamped &lhs, const geometry_msgs::PolygonStamped &rhs) -{ + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef ::geometry_msgs::Polygon_ _polygon_type; + _polygon_type polygon; + + typedef boost::shared_ptr<::geometry_msgs::PolygonStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::PolygonStamped_ const> ConstPtr; + + }; // struct PolygonStamped_ + + typedef ::geometry_msgs::PolygonStamped_> PolygonStamped; + + typedef boost::shared_ptr<::geometry_msgs::PolygonStamped> PolygonStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::PolygonStamped const> PolygonStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::PolygonStamped_ &lhs, const ::geometry_msgs::PolygonStamped_ &rhs) + { return lhs.header == rhs.header && - lhs.polygon == rhs.polygon; -} + lhs.polygon == rhs.polygon; + } -inline bool operator!=(const geometry_msgs::PolygonStamped &lhs, const geometry_msgs::PolygonStamped &rhs) -{ -return !(lhs == rhs); -} + template + bool operator!=(const ::geometry_msgs::PolygonStamped_ &lhs, const ::geometry_msgs::PolygonStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif //POLYGON_STAMPED_H +#endif // GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/Pose.h b/geometry_msgs/include/geometry_msgs/Pose.h index 7ae7366..47ab3e6 100644 --- a/geometry_msgs/include/geometry_msgs/Pose.h +++ b/geometry_msgs/include/geometry_msgs/Pose.h @@ -1,37 +1,64 @@ -#ifndef POSE_H -#define POSE_H +// Generated by gencpp from file geometry_msgs/Pose.msg +// DO NOT EDIT! + +#ifndef GEOMETRY_MSGS_MESSAGE_POSE_H +#define GEOMETRY_MSGS_MESSAGE_POSE_H + +#include +#include +#include +#include -#include -#include #include #include namespace geometry_msgs { + template + struct Pose_ + { + typedef Pose_ Type; -struct Pose -{ - Point position; - Quaternion orientation; + Pose_() + : position(), orientation() + { + } + Pose_(const ContainerAllocator &_alloc) + : position(_alloc), orientation(_alloc) + { + (void)_alloc; + } - Pose() = default; - - Pose(Point position_, Quaternion orientation_) - : position(position_), orientation(orientation_) {}; -}; + typedef ::geometry_msgs::Point_ _position_type; + _position_type position; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Pose &lhs, const geometry_msgs::Pose &rhs) -{ -return lhs.position == rhs.position && - lhs.orientation == rhs.orientation; -} + typedef ::geometry_msgs::Quaternion_ _orientation_type; + _orientation_type orientation; -inline bool operator!=(const geometry_msgs::Pose &lhs, const geometry_msgs::Pose &rhs) -{ -return !(lhs == rhs); -} + typedef boost::shared_ptr<::geometry_msgs::Pose_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Pose_ const> ConstPtr; + + }; // struct Pose_ + + typedef ::geometry_msgs::Pose_> Pose; + + typedef boost::shared_ptr<::geometry_msgs::Pose> PosePtr; + typedef boost::shared_ptr<::geometry_msgs::Pose const> PoseConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Pose_ &lhs, const ::geometry_msgs::Pose_ &rhs) + { + return lhs.position == rhs.position && + lhs.orientation == rhs.orientation; + } + + template + bool operator!=(const ::geometry_msgs::Pose_ &lhs, const ::geometry_msgs::Pose_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // POSE_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_POSE_H diff --git a/geometry_msgs/include/geometry_msgs/Pose2D.h b/geometry_msgs/include/geometry_msgs/Pose2D.h index 86fc11c..c18877f 100644 --- a/geometry_msgs/include/geometry_msgs/Pose2D.h +++ b/geometry_msgs/include/geometry_msgs/Pose2D.h @@ -1,50 +1,66 @@ -// # Deprecated -// # Please use the full 3D pose. +// Generated by gencpp from file geometry_msgs/Pose2D.msg +// DO NOT EDIT! -// # In general our recommendation is to use a full 3D representation of everything and for 2D specific applications make the appropriate projections into the plane for their calculations but optimally will preserve the 3D information during processing. +#ifndef GEOMETRY_MSGS_MESSAGE_POSE2D_H +#define GEOMETRY_MSGS_MESSAGE_POSE2D_H -// # If we have parallel copies of 2D datatypes every UI and other pipeline will end up needing to have dual interfaces to plot everything. And you will end up with not being able to use 3D tools for 2D use cases even if they're completely valid, as you'd have to reimplement it with different inputs and outputs. It's not particularly hard to plot the 2D pose or compute the yaw error for the Pose message and there are already tools and libraries that can do this for you. - - -// # This expresses a position and orientation on a 2D manifold. - -// float64 x -// float64 y -// float64 theta - -#ifndef POSE2D_H -#define POSE2D_H - -#include "utils.h" +#include +#include +#include +#include namespace geometry_msgs { + template + struct Pose2D_ + { + typedef Pose2D_ Type; -struct Pose2D -{ - double x; - double y; - double theta; + Pose2D_() + : x(0.0), y(0.0), theta(0.0) + { + } + Pose2D_(const ContainerAllocator &_alloc) + : x(0.0), y(0.0), theta(0.0) + { + (void)_alloc; + } - Pose2D() : x(0.0), y(0.0), theta(0.0) {} - Pose2D(double x_, double y_, double theta_) - : x(x_), y(y_), theta(theta_) {} -}; + typedef double _x_type; + _x_type x; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Pose2D &lhs, const geometry_msgs::Pose2D &rhs) -{ -return isEqual(lhs.x, rhs.x) && - isEqual(lhs.y, rhs.y) && - isEqual(lhs.theta, rhs.theta); -} + typedef double _y_type; + _y_type y; -inline bool operator!=(const geometry_msgs::Pose2D &lhs, const geometry_msgs::Pose2D &rhs) -{ -return !(lhs == rhs); -} + typedef double _theta_type; + _theta_type theta; + + typedef boost::shared_ptr<::geometry_msgs::Pose2D_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Pose2D_ const> ConstPtr; + + }; // struct Pose2D_ + + typedef ::geometry_msgs::Pose2D_> Pose2D; + + typedef boost::shared_ptr<::geometry_msgs::Pose2D> Pose2DPtr; + typedef boost::shared_ptr<::geometry_msgs::Pose2D const> Pose2DConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Pose2D_ &lhs, const ::geometry_msgs::Pose2D_ &rhs) + { + return lhs.x == rhs.x && + lhs.y == rhs.y && + lhs.theta == rhs.theta; + } + + template + bool operator!=(const ::geometry_msgs::Pose2D_ &lhs, const ::geometry_msgs::Pose2D_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // POSE2D_H - +#endif // GEOMETRY_MSGS_MESSAGE_POSE2D_H diff --git a/geometry_msgs/include/geometry_msgs/PoseArray.h b/geometry_msgs/include/geometry_msgs/PoseArray.h index 0eea5fd..c072245 100644 --- a/geometry_msgs/include/geometry_msgs/PoseArray.h +++ b/geometry_msgs/include/geometry_msgs/PoseArray.h @@ -1,46 +1,65 @@ -// # An array of poses with a header for global reference. +// Generated by gencpp from file geometry_msgs/PoseArray.msg +// DO NOT EDIT! -// Header header - -// Pose[] poses -#ifndef POSE_ARRAY_H -#define POSE_ARRAY_H +#ifndef GEOMETRY_MSGS_MESSAGE_POSEARRAY_H +#define GEOMETRY_MSGS_MESSAGE_POSEARRAY_H +#include #include +#include +#include + #include #include - - namespace geometry_msgs { + template + struct PoseArray_ + { + typedef PoseArray_ Type; -struct PoseArray -{ - std_msgs::Header header; - std::vector poses; - - PoseArray() = default; -}; - -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::PoseArray &lhs, const geometry_msgs::PoseArray &rhs) -{ - if(lhs.poses.size() != rhs.poses.size()) - return false; - for(int i = 0; i < lhs.poses.size(); i++) + PoseArray_() + : header(), poses() { - if(!(lhs.poses[i] == rhs.poses[i])) - return false; } -return lhs.header == rhs.header; -} + PoseArray_(const ContainerAllocator &_alloc) + : header(_alloc), poses(_alloc) + { + (void)_alloc; + } -inline bool operator!=(const geometry_msgs::PoseArray &lhs, const geometry_msgs::PoseArray &rhs) -{ -return !(lhs == rhs); -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; + + typedef std::vector<::geometry_msgs::Pose_, typename std::allocator_traits::template rebind_alloc<::geometry_msgs::Pose_>> _poses_type; + _poses_type poses; + + typedef boost::shared_ptr<::geometry_msgs::PoseArray_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::PoseArray_ const> ConstPtr; + + }; // struct PoseArray_ + + typedef ::geometry_msgs::PoseArray_> PoseArray; + + typedef boost::shared_ptr<::geometry_msgs::PoseArray> PoseArrayPtr; + typedef boost::shared_ptr<::geometry_msgs::PoseArray const> PoseArrayConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::PoseArray_ &lhs, const ::geometry_msgs::PoseArray_ &rhs) + { + return lhs.header == rhs.header && + lhs.poses == rhs.poses; + } + + template + bool operator!=(const ::geometry_msgs::PoseArray_ &lhs, const ::geometry_msgs::PoseArray_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // POSE_ARRAY_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_POSEARRAY_H diff --git a/geometry_msgs/include/geometry_msgs/PoseStamped.h b/geometry_msgs/include/geometry_msgs/PoseStamped.h index a7923b0..48cc418 100644 --- a/geometry_msgs/include/geometry_msgs/PoseStamped.h +++ b/geometry_msgs/include/geometry_msgs/PoseStamped.h @@ -1,37 +1,65 @@ -// # A Pose with reference coordinate frame and timestamp -// Header header -// Pose pose -#ifndef POSE_STAMPED_H -#define POSE_STAMPED_H +// Generated by gencpp from file geometry_msgs/PoseStamped.msg +// DO NOT EDIT! + +#ifndef GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H + +#include +#include +#include +#include #include #include - - namespace geometry_msgs { + template + struct PoseStamped_ + { + typedef PoseStamped_ Type; -struct PoseStamped -{ - std_msgs::Header header; - Pose pose; + PoseStamped_() + : header(), pose() + { + } + PoseStamped_(const ContainerAllocator &_alloc) + : header(_alloc), pose(_alloc) + { + (void)_alloc; + } - PoseStamped() = default; -}; + typedef ::std_msgs::Header_ _header_type; + _header_type header; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::PoseStamped &lhs, const geometry_msgs::PoseStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.pose == rhs.pose; -} + typedef ::geometry_msgs::Pose_ _pose_type; + _pose_type pose; -inline bool operator!=(const geometry_msgs::PoseStamped &lhs, const geometry_msgs::PoseStamped &rhs) -{ -return !(lhs == rhs); -} + typedef boost::shared_ptr<::geometry_msgs::PoseStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::PoseStamped_ const> ConstPtr; + + }; // struct PoseStamped_ + + typedef ::geometry_msgs::PoseStamped_> PoseStamped; + + typedef boost::shared_ptr<::geometry_msgs::PoseStamped> PoseStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::PoseStamped const> PoseStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::PoseStamped_ &lhs, const ::geometry_msgs::PoseStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.pose == rhs.pose; + } + + template + bool operator!=(const ::geometry_msgs::PoseStamped_ &lhs, const ::geometry_msgs::PoseStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // POSE_STAMPED_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/PoseWithCovariance.h b/geometry_msgs/include/geometry_msgs/PoseWithCovariance.h index 709aa16..c5a563b 100644 --- a/geometry_msgs/include/geometry_msgs/PoseWithCovariance.h +++ b/geometry_msgs/include/geometry_msgs/PoseWithCovariance.h @@ -1,49 +1,63 @@ -// # This represents a pose in free space with uncertainty. +// Generated by gencpp from file geometry_msgs/PoseWithCovariance.msg +// DO NOT EDIT! -// Pose pose +#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H +#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H -// # Row-major representation of the 6x6 covariance matrix -// # The orientation parameters use a fixed-axis representation. -// # In order, the parameters are: -// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis) -// float64[36] covariance - -#ifndef POSE_WITH_COVARIANCE_H -#define POSE_WITH_COVARIANCE_H - -#include +#include +#include +#include +#include +#include #include - namespace geometry_msgs { + template + struct PoseWithCovariance_ + { + typedef PoseWithCovariance_ Type; -struct PoseWithCovariance -{ - Pose pose; - std::array covariance; - - PoseWithCovariance() : pose(), covariance{{0.0}} {}; -}; - -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::PoseWithCovariance &lhs, const geometry_msgs::PoseWithCovariance &rhs) -{ - for(size_t i = 0; i < 36; ++i) + PoseWithCovariance_() + : pose(), covariance() { - if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false) - { - return false; - } + covariance.assign(0.0); + } + PoseWithCovariance_(const ContainerAllocator &_alloc) + : pose(_alloc), covariance() + { + (void)_alloc; + covariance.assign(0.0); } -return lhs.pose == rhs.pose; -} -inline bool operator!=(const geometry_msgs::PoseWithCovariance &lhs, const geometry_msgs::PoseWithCovariance &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Pose_ _pose_type; + _pose_type pose; + + typedef boost::array _covariance_type; + _covariance_type covariance; + + typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance_ const> ConstPtr; + + }; // struct PoseWithCovariance_ + + typedef ::geometry_msgs::PoseWithCovariance_> PoseWithCovariance; + + typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance> PoseWithCovariancePtr; + typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance const> PoseWithCovarianceConstPtr; + + template + bool operator==(const ::geometry_msgs::PoseWithCovariance_ &lhs, const ::geometry_msgs::PoseWithCovariance_ &rhs) + { + return lhs.pose == rhs.pose && + lhs.covariance == rhs.covariance; + } + + template + bool operator!=(const ::geometry_msgs::PoseWithCovariance_ &lhs, const ::geometry_msgs::PoseWithCovariance_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // POSE_WITH_COVARIANCE_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H \ No newline at end of file diff --git a/geometry_msgs/include/geometry_msgs/PoseWithCovarianceStamped.h b/geometry_msgs/include/geometry_msgs/PoseWithCovarianceStamped.h index 29476fc..2dde668 100644 --- a/geometry_msgs/include/geometry_msgs/PoseWithCovarianceStamped.h +++ b/geometry_msgs/include/geometry_msgs/PoseWithCovarianceStamped.h @@ -1,40 +1,62 @@ -// # This expresses an estimated pose with a reference coordinate frame and timestamp +// Generated by gencpp from file geometry_msgs/PoseWithCovarianceStamped.msg +// DO NOT EDIT! -// Header header -// PoseWithCovariance pose +#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H -#ifndef POSE_WITH_COVARIANCE_STAMPED_H -#define POSE_WITH_COVARIANCE_STAMPED_H +#include +#include +#include +#include #include #include - - namespace geometry_msgs { + template + struct PoseWithCovarianceStamped_ + { + typedef PoseWithCovarianceStamped_ Type; -struct PoseWithCovarianceStamped -{ - std_msgs::Header header; - PoseWithCovariance pose; + PoseWithCovarianceStamped_() + : header(), pose() + { + } + PoseWithCovarianceStamped_(const ContainerAllocator &_alloc) + : header(_alloc), pose(_alloc) + { + (void)_alloc; + } - PoseWithCovarianceStamped() = default; -}; + typedef ::std_msgs::Header_ _header_type; + _header_type header; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.pose == rhs.pose; -} + typedef ::geometry_msgs::PoseWithCovariance_ _pose_type; + _pose_type pose; -inline bool operator!=(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs) -{ -return !(lhs == rhs); -} + typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped_ const> ConstPtr; + }; // struct PoseWithCovarianceStamped_ + + typedef ::geometry_msgs::PoseWithCovarianceStamped_> PoseWithCovarianceStamped; + + typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped> PoseWithCovarianceStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped const> PoseWithCovarianceStampedConstPtr; + + template + bool operator==(const ::geometry_msgs::PoseWithCovarianceStamped_ &lhs, const ::geometry_msgs::PoseWithCovarianceStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.pose == rhs.pose; + } + + template + bool operator!=(const ::geometry_msgs::PoseWithCovarianceStamped_ &lhs, const ::geometry_msgs::PoseWithCovarianceStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // POSE_WITH_COVARIANCE_STAMPED_H +#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H \ No newline at end of file diff --git a/geometry_msgs/include/geometry_msgs/Quaternion.h b/geometry_msgs/include/geometry_msgs/Quaternion.h index 2a24b96..137baf7 100644 --- a/geometry_msgs/include/geometry_msgs/Quaternion.h +++ b/geometry_msgs/include/geometry_msgs/Quaternion.h @@ -1,40 +1,69 @@ -#ifndef QUATERNION_H -#define QUATERNION_H +// Generated by gencpp from file geometry_msgs/Quaternion.msg +// DO NOT EDIT! -#include "utils.h" +#ifndef GEOMETRY_MSGS_MESSAGE_QUATERNION_H +#define GEOMETRY_MSGS_MESSAGE_QUATERNION_H + +#include +#include +#include +#include namespace geometry_msgs { + template + struct Quaternion_ + { + typedef Quaternion_ Type; -struct Quaternion -{ - double x; - double y; - double z; - double w; + Quaternion_() + : x(0.0), y(0.0), z(0.0), w(0.0) + { + } + Quaternion_(const ContainerAllocator &_alloc) + : x(0.0), y(0.0), z(0.0), w(0.0) + { + (void)_alloc; + } - // Constructor mặc định - Quaternion() : x(0.0), y(0.0), z(0.0), w(1.0) {} + typedef double _x_type; + _x_type x; - // Constructor khởi tạo nhanh - Quaternion(double x_, double y_, double z_, double w_) - : x(x_), y(y_), z(z_), w(w_) {} -}; + typedef double _y_type; + _y_type y; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Quaternion &lhs, const geometry_msgs::Quaternion &rhs) -{ -return isEqual(lhs.x, rhs.x) && - isEqual(lhs.y, rhs.y) && - isEqual(lhs.z, rhs.z) && - isEqual(lhs.w, rhs.w); -} + typedef double _z_type; + _z_type z; -inline bool operator!=(const geometry_msgs::Quaternion &lhs, const geometry_msgs::Quaternion &rhs) -{ -return !(lhs == rhs); -} + typedef double _w_type; + _w_type w; + + typedef boost::shared_ptr<::geometry_msgs::Quaternion_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Quaternion_ const> ConstPtr; + + }; // struct Quaternion_ + + typedef ::geometry_msgs::Quaternion_> Quaternion; + + typedef boost::shared_ptr<::geometry_msgs::Quaternion> QuaternionPtr; + typedef boost::shared_ptr<::geometry_msgs::Quaternion const> QuaternionConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Quaternion_ &lhs, const ::geometry_msgs::Quaternion_ &rhs) + { + return lhs.x == rhs.x && + lhs.y == rhs.y && + lhs.z == rhs.z && + lhs.w == rhs.w; + } + + template + bool operator!=(const ::geometry_msgs::Quaternion_ &lhs, const ::geometry_msgs::Quaternion_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // QUATERNION_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_QUATERNION_H diff --git a/geometry_msgs/include/geometry_msgs/QuaternionStamped.h b/geometry_msgs/include/geometry_msgs/QuaternionStamped.h index 78c1eb7..c6d3fdb 100644 --- a/geometry_msgs/include/geometry_msgs/QuaternionStamped.h +++ b/geometry_msgs/include/geometry_msgs/QuaternionStamped.h @@ -1,37 +1,65 @@ -// # This represents an orientation with reference coordinate frame and timestamp. +// Generated by gencpp from file geometry_msgs/QuaternionStamped.msg +// DO NOT EDIT! -// Header header -// Quaternion quaternion +#ifndef GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H -#ifndef QUATERNION_STAMPED_H -#define QUATERNION_STAMPED_H +#include +#include +#include +#include #include #include namespace geometry_msgs { + template + struct QuaternionStamped_ + { + typedef QuaternionStamped_ Type; -struct QuaternionStamped -{ - std_msgs::Header header; - Quaternion quaternion; - // Constructor mặc định - QuaternionStamped() = default; -}; + QuaternionStamped_() + : header(), quaternion() + { + } + QuaternionStamped_(const ContainerAllocator &_alloc) + : header(_alloc), quaternion(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::QuaternionStamped &lhs, const geometry_msgs::QuaternionStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.quaternion == rhs.quaternion; -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; -inline bool operator!=(const geometry_msgs::QuaternionStamped &lhs, const geometry_msgs::QuaternionStamped &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Quaternion_ _quaternion_type; + _quaternion_type quaternion; + + typedef boost::shared_ptr<::geometry_msgs::QuaternionStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::QuaternionStamped_ const> ConstPtr; + + }; // struct QuaternionStamped_ + + typedef ::geometry_msgs::QuaternionStamped_> QuaternionStamped; + + typedef boost::shared_ptr<::geometry_msgs::QuaternionStamped> QuaternionStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::QuaternionStamped const> QuaternionStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::QuaternionStamped_ &lhs, const ::geometry_msgs::QuaternionStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.quaternion == rhs.quaternion; + } + + template + bool operator!=(const ::geometry_msgs::QuaternionStamped_ &lhs, const ::geometry_msgs::QuaternionStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // QUATERNION_STAMPED_H +#endif // GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/Transform.h b/geometry_msgs/include/geometry_msgs/Transform.h index 7776c17..ec91765 100644 --- a/geometry_msgs/include/geometry_msgs/Transform.h +++ b/geometry_msgs/include/geometry_msgs/Transform.h @@ -1,35 +1,65 @@ -#ifndef TRANSFORM_H -#define TRANSFORM_H +// Generated by gencpp from file geometry_msgs/Transform.msg +// DO NOT EDIT! -#include "geometry_msgs/Vector3.h" -#include "geometry_msgs/Quaternion.h" +#ifndef GEOMETRY_MSGS_MESSAGE_TRANSFORM_H +#define GEOMETRY_MSGS_MESSAGE_TRANSFORM_H + +#include +#include +#include +#include + +#include +#include namespace geometry_msgs { + template + struct Transform_ + { + typedef Transform_ Type; -struct Transform -{ - Vector3 translation; - Quaternion rotation; + Transform_() + : translation(), rotation() + { + } + Transform_(const ContainerAllocator &_alloc) + : translation(_alloc), rotation(_alloc) + { + (void)_alloc; + } - Transform() = default; - Transform(Vector3 translation_, Quaternion rotation_) - : translation(translation_), rotation(rotation_) {} -}; + typedef ::geometry_msgs::Vector3_ _translation_type; + _translation_type translation; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Transform &lhs, const geometry_msgs::Transform &rhs) -{ -return lhs.translation == rhs.translation && - lhs.rotation == rhs.rotation; -} + typedef ::geometry_msgs::Quaternion_ _rotation_type; + _rotation_type rotation; -inline bool operator!=(const geometry_msgs::Transform &lhs, const geometry_msgs::Transform &rhs) -{ -return !(lhs == rhs); -} + typedef boost::shared_ptr<::geometry_msgs::Transform_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Transform_ const> ConstPtr; + }; // struct Transform_ + + typedef ::geometry_msgs::Transform_> Transform; + + typedef boost::shared_ptr<::geometry_msgs::Transform> TransformPtr; + typedef boost::shared_ptr<::geometry_msgs::Transform const> TransformConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Transform_ &lhs, const ::geometry_msgs::Transform_ &rhs) + { + return lhs.translation == rhs.translation && + lhs.rotation == rhs.rotation; + } + + template + bool operator!=(const ::geometry_msgs::Transform_ &lhs, const ::geometry_msgs::Transform_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // TRANSFORM_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORM_H diff --git a/geometry_msgs/include/geometry_msgs/TransformStamped.h b/geometry_msgs/include/geometry_msgs/TransformStamped.h index f91fadf..9f2c908 100644 --- a/geometry_msgs/include/geometry_msgs/TransformStamped.h +++ b/geometry_msgs/include/geometry_msgs/TransformStamped.h @@ -1,33 +1,69 @@ -#ifndef TRANSFORM_STAMPED_H -#define TRANSFORM_STAMPED_H +// Generated by gencpp from file geometry_msgs/TransformStamped.msg +// DO NOT EDIT! + +#ifndef GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H -#include "std_msgs/Header.h" -#include "geometry_msgs/Transform.h" #include +#include +#include +#include + +#include +#include namespace geometry_msgs { + template + struct TransformStamped_ + { + typedef TransformStamped_ Type; -struct TransformStamped -{ - std_msgs::Header header; - std::string child_frame_id; - Transform transform; -}; + TransformStamped_() + : header(), child_frame_id(), transform() + { + } + TransformStamped_(const ContainerAllocator &_alloc) + : header(_alloc), child_frame_id(_alloc), transform(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::TransformStamped &lhs, const geometry_msgs::TransformStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.child_frame_id == rhs.child_frame_id && - lhs.transform == rhs.transform; -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; -inline bool operator!=(const geometry_msgs::TransformStamped &lhs, const geometry_msgs::TransformStamped &rhs) -{ -return !(lhs == rhs); -} + typedef std::basic_string, typename std::allocator_traits::template rebind_alloc> _child_frame_id_type; + _child_frame_id_type child_frame_id; + + typedef ::geometry_msgs::Transform_ _transform_type; + _transform_type transform; + + typedef boost::shared_ptr<::geometry_msgs::TransformStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::TransformStamped_ const> ConstPtr; + + }; // struct TransformStamped_ + + typedef ::geometry_msgs::TransformStamped_> TransformStamped; + + typedef boost::shared_ptr<::geometry_msgs::TransformStamped> TransformStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::TransformStamped const> TransformStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::TransformStamped_ &lhs, const ::geometry_msgs::TransformStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.child_frame_id == rhs.child_frame_id && + lhs.transform == rhs.transform; + } + + template + bool operator!=(const ::geometry_msgs::TransformStamped_ &lhs, const ::geometry_msgs::TransformStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // TRANSFORM_STAMPED_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/Twist.h b/geometry_msgs/include/geometry_msgs/Twist.h index b3af9ff..23e30a2 100644 --- a/geometry_msgs/include/geometry_msgs/Twist.h +++ b/geometry_msgs/include/geometry_msgs/Twist.h @@ -1,40 +1,65 @@ -// # This expresses velocity in free space broken into its linear and angular parts. -// Vector3 linear -// Vector3 angular +// Generated by gencpp from file geometry_msgs/Twist.msg +// DO NOT EDIT! -#ifndef TWIST_H -#define TWIST_H +#ifndef GEOMETRY_MSGS_MESSAGE_TWIST_H +#define GEOMETRY_MSGS_MESSAGE_TWIST_H +#include +#include +#include +#include + +#include #include namespace geometry_msgs { + template + struct Twist_ + { + typedef Twist_ Type; -struct Twist -{ - Vector3 linear; - Vector3 angular; + Twist_() + : linear(), angular() + { + } + Twist_(const ContainerAllocator &_alloc) + : linear(_alloc), angular(_alloc) + { + (void)_alloc; + } - // Constructor mặc định - Twist() : linear(), angular() {} + typedef ::geometry_msgs::Vector3_ _linear_type; + _linear_type linear; - // Constructor khởi tạo nhanh - Twist(const Vector3& linear_, const Vector3& angular_) - : linear(linear_), angular(angular_) {} -}; + typedef ::geometry_msgs::Vector3_ _angular_type; + _angular_type angular; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs) -{ -return lhs.linear == rhs.linear && - lhs.angular == rhs.angular; -} + typedef boost::shared_ptr<::geometry_msgs::Twist_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Twist_ const> ConstPtr; -inline bool operator!=(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs) -{ -return !(lhs == rhs); -} + }; // struct Twist_ + + typedef ::geometry_msgs::Twist_> Twist; + + typedef boost::shared_ptr<::geometry_msgs::Twist> TwistPtr; + typedef boost::shared_ptr<::geometry_msgs::Twist const> TwistConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Twist_ &lhs, const ::geometry_msgs::Twist_ &rhs) + { + return lhs.linear == rhs.linear && + lhs.angular == rhs.angular; + } + + template + bool operator!=(const ::geometry_msgs::Twist_ &lhs, const ::geometry_msgs::Twist_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // ACCEL_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_TWIST_H diff --git a/geometry_msgs/include/geometry_msgs/TwistStamped.h b/geometry_msgs/include/geometry_msgs/TwistStamped.h index 8584c68..21bb278 100644 --- a/geometry_msgs/include/geometry_msgs/TwistStamped.h +++ b/geometry_msgs/include/geometry_msgs/TwistStamped.h @@ -1,36 +1,65 @@ -// # A twist with reference coordinate frame and timestamp -// Header header -// Twist twist +// Generated by gencpp from file geometry_msgs/TwistStamped.msg +// DO NOT EDIT! -#ifndef TWIST_STAMPED_H -#define TWIST_STAMPED_H +#ifndef GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H + +#include +#include +#include +#include #include #include namespace geometry_msgs { + template + struct TwistStamped_ + { + typedef TwistStamped_ Type; -struct TwistStamped -{ - std_msgs::Header header; - Twist twist; - // Constructor mặc định - TwistStamped() = default; -}; + TwistStamped_() + : header(), twist() + { + } + TwistStamped_(const ContainerAllocator &_alloc) + : header(_alloc), twist(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::TwistStamped &lhs, const geometry_msgs::TwistStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.twist == rhs.twist; -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; -inline bool operator!=(const geometry_msgs::TwistStamped &lhs, const geometry_msgs::TwistStamped &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Twist_ _twist_type; + _twist_type twist; + + typedef boost::shared_ptr<::geometry_msgs::TwistStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::TwistStamped_ const> ConstPtr; + + }; // struct TwistStamped_ + + typedef ::geometry_msgs::TwistStamped_> TwistStamped; + + typedef boost::shared_ptr<::geometry_msgs::TwistStamped> TwistStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::TwistStamped const> TwistStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::TwistStamped_ &lhs, const ::geometry_msgs::TwistStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.twist == rhs.twist; + } + + template + bool operator!=(const ::geometry_msgs::TwistStamped_ &lhs, const ::geometry_msgs::TwistStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // TWIST_STAMPED_H +#endif // GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/TwistWithCovariance.h b/geometry_msgs/include/geometry_msgs/TwistWithCovariance.h index 621861d..823679b 100644 --- a/geometry_msgs/include/geometry_msgs/TwistWithCovariance.h +++ b/geometry_msgs/include/geometry_msgs/TwistWithCovariance.h @@ -1,50 +1,66 @@ -// # This expresses velocity in free space with uncertainty. +// Generated by gencpp from file geometry_msgs/TwistWithCovariance.msg +// DO NOT EDIT! -// Twist twist +#ifndef GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H +#define GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H -// # Row-major representation of the 6x6 covariance matrix -// # The orientation parameters use a fixed-axis representation. -// # In order, the parameters are: -// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis) -// float64[36] covariance - -#ifndef TWIST_WITH_COVARIANCE_H -#define TWIST_WITH_COVARIANCE_H - -#include +#include +#include +#include +#include +#include #include - namespace geometry_msgs { + template + struct TwistWithCovariance_ + { + typedef TwistWithCovariance_ Type; -struct TwistWithCovariance -{ - Twist twist; - std::array covariance; - - TwistWithCovariance() : twist(), covariance{{0.0}} {}; -}; - -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::TwistWithCovariance &lhs, const geometry_msgs::TwistWithCovariance &rhs) -{ - for(size_t i = 0; i < 36; ++i) + TwistWithCovariance_() + : twist(), covariance() { - if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false) - { - return false; - } + covariance.assign(0.0); + } + TwistWithCovariance_(const ContainerAllocator &_alloc) + : twist(_alloc), covariance() + { + (void)_alloc; + covariance.assign(0.0); } -return lhs.twist == rhs.twist; -} -inline bool operator!=(const geometry_msgs::TwistWithCovariance &lhs, const geometry_msgs::TwistWithCovariance &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Twist_ _twist_type; + _twist_type twist; + typedef boost::array _covariance_type; + _covariance_type covariance; + + typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance_ const> ConstPtr; + + }; // struct TwistWithCovariance_ + + typedef ::geometry_msgs::TwistWithCovariance_> TwistWithCovariance; + + typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance> TwistWithCovariancePtr; + typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance const> TwistWithCovarianceConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::TwistWithCovariance_ &lhs, const ::geometry_msgs::TwistWithCovariance_ &rhs) + { + return lhs.twist == rhs.twist && + lhs.covariance == rhs.covariance; + } + + template + bool operator!=(const ::geometry_msgs::TwistWithCovariance_ &lhs, const ::geometry_msgs::TwistWithCovariance_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // TWIST_WITH_COVARIANCE_H +#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H diff --git a/geometry_msgs/include/geometry_msgs/TwistWithCovarianceStamped.h b/geometry_msgs/include/geometry_msgs/TwistWithCovarianceStamped.h index 3704631..ad82fc6 100644 --- a/geometry_msgs/include/geometry_msgs/TwistWithCovarianceStamped.h +++ b/geometry_msgs/include/geometry_msgs/TwistWithCovarianceStamped.h @@ -1,38 +1,65 @@ -// # This represents an estimated twist with reference coordinate frame and timestamp. -// Header header -// TwistWithCovariance twist +// Generated by gencpp from file geometry_msgs/TwistWithCovarianceStamped.msg +// DO NOT EDIT! -#ifndef TWIST_WITH_COVARIANCE_STAMPED_H -#define TWIST_WITH_COVARIANCE_STAMPED_H +#ifndef GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H + +#include +#include +#include +#include #include #include - - namespace geometry_msgs { + template + struct TwistWithCovarianceStamped_ + { + typedef TwistWithCovarianceStamped_ Type; -struct TwistWithCovarianceStamped -{ - std_msgs::Header header; - TwistWithCovariance twist; + TwistWithCovarianceStamped_() + : header(), twist() + { + } + TwistWithCovarianceStamped_(const ContainerAllocator &_alloc) + : header(_alloc), twist(_alloc) + { + (void)_alloc; + } - TwistWithCovarianceStamped() = default; -}; + typedef ::std_msgs::Header_ _header_type; + _header_type header; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::TwistWithCovarianceStamped &lhs, const geometry_msgs::TwistWithCovarianceStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.twist == rhs.twist; -} + typedef ::geometry_msgs::TwistWithCovariance_ _twist_type; + _twist_type twist; -inline bool operator!=(const geometry_msgs::TwistWithCovarianceStamped &lhs, const geometry_msgs::TwistWithCovarianceStamped &rhs) -{ -return !(lhs == rhs); -} + typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped_ const> ConstPtr; + + }; // struct TwistWithCovarianceStamped_ + + typedef ::geometry_msgs::TwistWithCovarianceStamped_> TwistWithCovarianceStamped; + + typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped> TwistWithCovarianceStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped const> TwistWithCovarianceStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::TwistWithCovarianceStamped_ &lhs, const ::geometry_msgs::TwistWithCovarianceStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.twist == rhs.twist; + } + + template + bool operator!=(const ::geometry_msgs::TwistWithCovarianceStamped_ &lhs, const ::geometry_msgs::TwistWithCovarianceStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // TWIST_WITH_COVARIANCE_STAMPED_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/Vector3.h b/geometry_msgs/include/geometry_msgs/Vector3.h index e9d2897..7e46b3d 100644 --- a/geometry_msgs/include/geometry_msgs/Vector3.h +++ b/geometry_msgs/include/geometry_msgs/Vector3.h @@ -1,39 +1,63 @@ -#ifndef VECTOR_3_H -#define VECTOR_3_H +// Generated by gencpp from file geometry_msgs/Vector3.msg +// DO NOT EDIT! -#include "utils.h" +#ifndef GEOMETRY_MSGS_MESSAGE_VECTOR3_H +#define GEOMETRY_MSGS_MESSAGE_VECTOR3_H + +#include +#include +#include +#include namespace geometry_msgs { + template + struct Vector3_ + { + typedef Vector3_ Type; -struct Vector3 -{ - double x; - double y; - double z; + Vector3_() + : x(0.0), y(0.0), z(0.0) + { + } + Vector3_(const ContainerAllocator &_alloc) + : x(0.0), y(0.0), z(0.0) + { + (void)_alloc; + } - // Constructor mặc định - Vector3() : x(0.0), y(0.0), z(0.0) {} + typedef double _x_type; + _x_type x; - // Constructor khởi tạo nhanh - Vector3(double x_, double y_, double z_) - : x(x_), y(y_), z(z_) {} -}; + typedef double _y_type; + _y_type y; -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Vector3 &lhs, const geometry_msgs::Vector3 &rhs) -{ -return isEqual(lhs.x, rhs.x) && - isEqual(lhs.y, rhs.y) && - isEqual(lhs.z, rhs.z); -} + typedef double _z_type; + _z_type z; -inline bool operator!=(const geometry_msgs::Vector3 &lhs, const geometry_msgs::Vector3 &rhs) -{ -return !(lhs == rhs); -} + typedef boost::shared_ptr<::geometry_msgs::Vector3_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Vector3_ const> ConstPtr; + }; // struct Vector3_ + + typedef ::geometry_msgs::Vector3_> Vector3; + + typedef boost::shared_ptr<::geometry_msgs::Vector3> Vector3Ptr; + typedef boost::shared_ptr<::geometry_msgs::Vector3 const> Vector3ConstPtr; + + template + bool operator==(const ::geometry_msgs::Vector3_ &lhs, const ::geometry_msgs::Vector3_ &rhs) + { + return lhs.x == rhs.x && + lhs.y == rhs.y && + lhs.z == rhs.z; + } + + template + bool operator!=(const ::geometry_msgs::Vector3_ &lhs, const ::geometry_msgs::Vector3_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs - -#endif // VECTOR_3_H \ No newline at end of file +#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3_H diff --git a/geometry_msgs/include/geometry_msgs/Vector3Stamped.h b/geometry_msgs/include/geometry_msgs/Vector3Stamped.h index dc3024e..8bc3130 100644 --- a/geometry_msgs/include/geometry_msgs/Vector3Stamped.h +++ b/geometry_msgs/include/geometry_msgs/Vector3Stamped.h @@ -1,37 +1,65 @@ -// # This represents a Vector3 with reference coordinate frame and timestamp -// Header header -// Vector3 vector +// Generated by gencpp from file geometry_msgs/Vector3Stamped.msg +// DO NOT EDIT! -#ifndef VECTOR_3_STAMPED_H -#define VECTOR_3_STAMPED_H +#ifndef GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H +#define GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H + +#include +#include +#include +#include #include #include namespace geometry_msgs { + template + struct Vector3Stamped_ + { + typedef Vector3Stamped_ Type; -struct Vector3Stamped -{ - std_msgs::Header header; - Vector3 vector; - // Constructor mặc định - Vector3Stamped() = default; -}; + Vector3Stamped_() + : header(), vector() + { + } + Vector3Stamped_(const ContainerAllocator &_alloc) + : header(_alloc), vector(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Vector3Stamped &lhs, const geometry_msgs::Vector3Stamped &rhs) -{ -return lhs.header == rhs.header && - lhs.vector == rhs.vector; -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; -inline bool operator!=(const geometry_msgs::Vector3Stamped &lhs, const geometry_msgs::Vector3Stamped &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Vector3_ _vector_type; + _vector_type vector; + typedef boost::shared_ptr<::geometry_msgs::Vector3Stamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Vector3Stamped_ const> ConstPtr; + + }; // struct Vector3Stamped_ + + typedef ::geometry_msgs::Vector3Stamped_> Vector3Stamped; + + typedef boost::shared_ptr<::geometry_msgs::Vector3Stamped> Vector3StampedPtr; + typedef boost::shared_ptr<::geometry_msgs::Vector3Stamped const> Vector3StampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Vector3Stamped_ &lhs, const ::geometry_msgs::Vector3Stamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.vector == rhs.vector; + } + + template + bool operator!=(const ::geometry_msgs::Vector3Stamped_ &lhs, const ::geometry_msgs::Vector3Stamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // VECTOR_3_STAMPED_H +#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H diff --git a/geometry_msgs/include/geometry_msgs/Wrench.h b/geometry_msgs/include/geometry_msgs/Wrench.h index c0f9d75..681cec1 100644 --- a/geometry_msgs/include/geometry_msgs/Wrench.h +++ b/geometry_msgs/include/geometry_msgs/Wrench.h @@ -1,38 +1,65 @@ -// # This represents force in free space, separated into -// # its linear and angular parts. -// Vector3 force -// Vector3 torque +// Generated by gencpp from file geometry_msgs/Wrench.msg +// DO NOT EDIT! -#ifndef WRENCH_H -#define WRENCH_H +#ifndef GEOMETRY_MSGS_MESSAGE_WRENCH_H +#define GEOMETRY_MSGS_MESSAGE_WRENCH_H +#include +#include +#include +#include + +#include #include namespace geometry_msgs { + template + struct Wrench_ + { + typedef Wrench_ Type; -struct Wrench -{ - Vector3 force; - Vector3 torque; - // Constructor mặc định - Wrench() = default; - - Wrench(Vector3 force_, Vector3 torque_) : force(force_), torque(torque_) {}; -}; + Wrench_() + : force(), torque() + { + } + Wrench_(const ContainerAllocator &_alloc) + : force(_alloc), torque(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::Wrench &lhs, const geometry_msgs::Wrench &rhs) -{ -return lhs.force == rhs.force && - lhs.torque == rhs.torque; -} + typedef ::geometry_msgs::Vector3_ _force_type; + _force_type force; -inline bool operator!=(const geometry_msgs::Wrench &lhs, const geometry_msgs::Wrench &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Vector3_ _torque_type; + _torque_type torque; + + typedef boost::shared_ptr<::geometry_msgs::Wrench_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::Wrench_ const> ConstPtr; + + }; // struct Wrench_ + + typedef ::geometry_msgs::Wrench_> Wrench; + + typedef boost::shared_ptr<::geometry_msgs::Wrench> WrenchPtr; + typedef boost::shared_ptr<::geometry_msgs::Wrench const> WrenchConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::Wrench_ &lhs, const ::geometry_msgs::Wrench_ &rhs) + { + return lhs.force == rhs.force && + lhs.torque == rhs.torque; + } + + template + bool operator!=(const ::geometry_msgs::Wrench_ &lhs, const ::geometry_msgs::Wrench_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // WRENCH_H +#endif // GEOMETRY_MSGS_MESSAGE_WRENCH_H diff --git a/geometry_msgs/include/geometry_msgs/WrenchStamped.h b/geometry_msgs/include/geometry_msgs/WrenchStamped.h index 09a7796..b4718c0 100644 --- a/geometry_msgs/include/geometry_msgs/WrenchStamped.h +++ b/geometry_msgs/include/geometry_msgs/WrenchStamped.h @@ -1,36 +1,65 @@ -// # A wrench with reference coordinate frame and timestamp -// Header header -// Wrench wrench +// Generated by gencpp from file geometry_msgs/WrenchStamped.msg +// DO NOT EDIT! -#ifndef WRENCH_STAMPED_H -#define WRENCH_STAMPED_H +#ifndef GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H +#define GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H + +#include +#include +#include +#include #include #include namespace geometry_msgs { + template + struct WrenchStamped_ + { + typedef WrenchStamped_ Type; -struct WrenchStamped -{ - std_msgs::Header header; - Wrench wrench; - // Constructor mặc định - WrenchStamped() = default; -}; + WrenchStamped_() + : header(), wrench() + { + } + WrenchStamped_(const ContainerAllocator &_alloc) + : header(_alloc), wrench(_alloc) + { + (void)_alloc; + } -// constants requiring out of line definition -inline bool operator==(const geometry_msgs::WrenchStamped &lhs, const geometry_msgs::WrenchStamped &rhs) -{ -return lhs.header == rhs.header && - lhs.wrench == rhs.wrench; -} + typedef ::std_msgs::Header_ _header_type; + _header_type header; -inline bool operator!=(const geometry_msgs::WrenchStamped &lhs, const geometry_msgs::WrenchStamped &rhs) -{ -return !(lhs == rhs); -} + typedef ::geometry_msgs::Wrench_ _wrench_type; + _wrench_type wrench; + + typedef boost::shared_ptr<::geometry_msgs::WrenchStamped_> Ptr; + typedef boost::shared_ptr<::geometry_msgs::WrenchStamped_ const> ConstPtr; + + }; // struct WrenchStamped_ + + typedef ::geometry_msgs::WrenchStamped_> WrenchStamped; + + typedef boost::shared_ptr<::geometry_msgs::WrenchStamped> WrenchStampedPtr; + typedef boost::shared_ptr<::geometry_msgs::WrenchStamped const> WrenchStampedConstPtr; + + // constants requiring out of line definition + + template + bool operator==(const ::geometry_msgs::WrenchStamped_ &lhs, const ::geometry_msgs::WrenchStamped_ &rhs) + { + return lhs.header == rhs.header && + lhs.wrench == rhs.wrench; + } + + template + bool operator!=(const ::geometry_msgs::WrenchStamped_ &lhs, const ::geometry_msgs::WrenchStamped_ &rhs) + { + return !(lhs == rhs); + } } // namespace geometry_msgs -#endif // WRENCH_STAMPED_H +#endif // GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H diff --git a/nav_msgs/include/nav_msgs/MapMetaData.h b/nav_msgs/include/nav_msgs/MapMetaData.h index ed3e4f6..dfabfcd 100644 --- a/nav_msgs/include/nav_msgs/MapMetaData.h +++ b/nav_msgs/include/nav_msgs/MapMetaData.h @@ -5,7 +5,7 @@ #include #include #include "geometry_msgs/Pose.h" -// #include "utils.h" +#include "utils.h" namespace nav_msgs { diff --git a/std_msgs/include/std_msgs/Header.h b/std_msgs/include/std_msgs/Header.h index f34312c..98642f1 100644 --- a/std_msgs/include/std_msgs/Header.h +++ b/std_msgs/include/std_msgs/Header.h @@ -1,32 +1,66 @@ -#ifndef STD_MSGS_HEADER_H -#define STD_MSGS_HEADER_H +// Generated by gencpp from file std_msgs/Header.msg +// DO NOT EDIT! + +#ifndef STD_MSGS_MESSAGE_HEADER_H +#define STD_MSGS_MESSAGE_HEADER_H #include -#include +#include +#include + #include -namespace std_msgs { - -struct Header +namespace std_msgs { - uint32_t seq; // số thứ tự message - robot::Time stamp; // thời gian timestamp - std::string frame_id; + template + struct Header_ + { + typedef Header_ Type; - Header() : seq(0), stamp(robot::Time::now()), frame_id("") {} -}; + Header_() + : seq(0), stamp(), frame_id() + { + } + Header_(const ContainerAllocator &_alloc) + : seq(0), stamp(), frame_id(_alloc) + { + (void)_alloc; + } -inline bool operator==(const std_msgs::Header& lhs, const std_msgs::Header &rhs) -{ - return lhs.seq == rhs.seq && - lhs.stamp == rhs.stamp && - lhs.frame_id == rhs.frame_id; -} + typedef uint32_t _seq_type; + _seq_type seq; -inline bool operator!=(const std_msgs::Header &lhs, const std_msgs::Header &rhs) -{ - return !(lhs == rhs); -} + typedef robot::Time _stamp_type; + _stamp_type stamp; -} // namespace std_msgs -#endif + typedef std::basic_string, typename std::allocator_traits::template rebind_alloc> _frame_id_type; + _frame_id_type frame_id; + + typedef std::shared_ptr<::std_msgs::Header_> Ptr; + typedef std::shared_ptr<::std_msgs::Header_ const> ConstPtr; + + }; // struct Header_ + + typedef ::std_msgs::Header_> Header; + + typedef std::shared_ptr<::std_msgs::Header> HeaderPtr; + typedef std::shared_ptr<::std_msgs::Header const> HeaderConstPtr; + + // constants requiring out of line definition + template + bool operator==(const ::std_msgs::Header_ &lhs, const ::std_msgs::Header_ &rhs) + { + return lhs.seq == rhs.seq && + lhs.stamp == rhs.stamp && + lhs.frame_id == rhs.frame_id; + } + + template + bool operator!=(const ::std_msgs::Header_ &lhs, const ::std_msgs::Header_ &rhs) + { + return !(lhs == rhs); + } + +} // namespace std_msgs + +#endif // STD_MSGS_MESSAGE_HEADER_H