HiepLM

geometry_msgs/include/geometry_msgs/Accel.h

@@ -1,36 +1,67 @@
-// # This expresses acceleration in free space broken into its linear and angular parts.
+// Generated by gencpp from file geometry_msgs/Accel.msg
-// Vector3  linear
+// DO NOT EDIT!
-// Vector3  angular
 
-#ifndef ACCEL_H
-#define ACCEL_H
 
+#ifndef GEOMETRY_MSGS_MESSAGE_ACCEL_H
+#define GEOMETRY_MSGS_MESSAGE_ACCEL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+#include <geometry_msgs/Vector3.h>
 #include <geometry_msgs/Vector3.h>
 
 namespace geometry_msgs
 {
-
+template <class ContainerAllocator>
-struct Accel
+struct Accel_
 {
-    Vector3 linear;
+  typedef Accel_<ContainerAllocator> Type;
-    Vector3 angular;
 
-    // Constructor mặc định
+  Accel_()
-    Accel() : linear(), angular() {}
+    : 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_<ContainerAllocator>  _linear_type;
+  _linear_type linear;
+
+   typedef  ::geometry_msgs::Vector3_<ContainerAllocator>  _angular_type;
+  _angular_type angular;
+
+
+
+
+
+  typedef boost::shared_ptr< ::geometry_msgs::Accel_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::geometry_msgs::Accel_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Accel_
+
+typedef ::geometry_msgs::Accel_<std::allocator<void> > Accel;
+
+typedef boost::shared_ptr< ::geometry_msgs::Accel > AccelPtr;
+typedef boost::shared_ptr< ::geometry_msgs::Accel const> AccelConstPtr;
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::geometry_msgs::Accel_<ContainerAllocator2> & rhs)
 {
   return lhs.linear == rhs.linear &&
     lhs.angular == rhs.angular;
 }
 
-inline bool operator!=(const geometry_msgs::Accel &lhs, const geometry_msgs::Accel &rhs)
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::geometry_msgs::Accel_<ContainerAllocator2> & rhs)
 {
   return !(lhs == rhs);
 }
@@ -38,4 +69,141 @@ return !(lhs == rhs);
 
 } // namespace geometry_msgs
 
-#endif // ACCEL_H
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::geometry_msgs::Accel_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::geometry_msgs::Accel_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::geometry_msgs::Accel_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::geometry_msgs::Accel_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::geometry_msgs::Accel_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::geometry_msgs::Accel_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::geometry_msgs::Accel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "9f195f881246fdfa2798d1d3eebca84a";
+  }
+
+  static const char* value(const ::geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
+  static const uint64_t static_value1 = 0x9f195f881246fdfaULL;
+  static const uint64_t static_value2 = 0x2798d1d3eebca84aULL;
+};
+
+template<class ContainerAllocator>
+struct DataType< ::geometry_msgs::Accel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "geometry_msgs/Accel";
+  }
+
+  static const char* value(const ::geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::geometry_msgs::Accel_<ContainerAllocator> >
+{
+  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_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Accel_<ContainerAllocator> >
+  {
+    template<typename Stream, typename T> 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<class ContainerAllocator>
+struct Printer< ::geometry_msgs::Accel_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Accel_<ContainerAllocator>& v)
+  {
+    if (false || !indent.empty())
+      s << std::endl;
+    s << indent << "linear: ";
+    Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.linear);
+    if (true || !indent.empty())
+      s << std::endl;
+    s << indent << "angular: ";
+    Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.angular);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // GEOMETRY_MSGS_MESSAGE_ACCEL_H

geometry_msgs/include/geometry_msgs/AccelStamped.h

@@ -1,36 +1,61 @@
-// # An accel with reference coordinate frame and timestamp
+// Generated by gencpp from file geometry_msgs/AccelStamped.msg
-// Header header
+// DO NOT EDIT!
-// Accel accel
 
-#ifndef ACCEL_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H
-#define ACCEL_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H
 
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Accel.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct AccelStamped
+  struct AccelStamped_
   {
-    std_msgs::Header header;
+    typedef AccelStamped_<ContainerAllocator> Type;
-    Accel accel;
-    // Constructor mặc định
-    AccelStamped() = default;
-};
 
-// constants requiring out of line definition
+    AccelStamped_()
-inline bool operator==(const geometry_msgs::AccelStamped &lhs, const geometry_msgs::AccelStamped &rhs)
+        : header(), accel()
+    {
+    }
+    AccelStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), accel(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Accel_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::shared_ptr<::geometry_msgs::AccelStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::AccelStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelStamped_
+
+  typedef ::geometry_msgs::AccelStamped_<std::allocator<void>> AccelStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::AccelStamped> AccelStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::AccelStamped const> AccelStampedConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::AccelStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::AccelStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.accel == rhs.accel;
   }
 
-inline bool operator!=(const geometry_msgs::AccelStamped &lhs, const geometry_msgs::AccelStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::AccelStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::AccelStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H
-#endif // ACCEL_STAMPED_H

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
+#include <string>
-// # The orientation parameters use a fixed-axis representation.
+#include <vector>
-// # In order, the parameters are:
+#include <memory>
-// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
+#include <boost/shared_ptr.hpp>
-// float64[36] covariance
+#include <boost/array.hpp>
-
-#ifndef ACCEL_WITH_COVARIANCE_H
-#define ACCEL_WITH_COVARIANCE_H
-
-#include <array>
 #include <geometry_msgs/Accel.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct AccelWithCovariance
+  struct AccelWithCovariance_
   {
-    Accel accel;
+    typedef AccelWithCovariance_<ContainerAllocator> Type;
-    std::array<double, 36> covariance;
+
-    // Constructor mặc định
+    AccelWithCovariance_()
-    AccelWithCovariance() : accel(), covariance{{0.0}} {};
+        : accel(), covariance()
-};
+    {
+      covariance.assign(0.0);
+    }
+    AccelWithCovariance_(const ContainerAllocator &_alloc)
+        : accel(_alloc), covariance()
+    {
+      (void)_alloc;
+      covariance.assign(0.0);
+    }
+
+    typedef ::geometry_msgs::Accel_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelWithCovariance_
+
+  typedef ::geometry_msgs::AccelWithCovariance_<std::allocator<void>> AccelWithCovariance;
+
+  typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance> AccelWithCovariancePtr;
+  typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance const> AccelWithCovarianceConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::AccelWithCovariance &lhs, const geometry_msgs::AccelWithCovariance &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator2> &rhs)
   {
-    for(size_t i = 0; i < 36; ++i)
+    return lhs.accel == rhs.accel &&
-    {
+           lhs.covariance == rhs.covariance;
-        if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
-        {
-            return false;
-        }
-    }
-return lhs.accel == rhs.accel;
   }
 
-inline bool operator!=(const geometry_msgs::AccelWithCovariance &lhs, const geometry_msgs::AccelWithCovariance &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H
-#endif // ACCEL_WITH_COVARIANCE_H
-

geometry_msgs/include/geometry_msgs/AccelWithCovarianceStamped.h

@@ -1,36 +1,64 @@
-// # This represents an estimated accel with reference coordinate frame and timestamp.
+// Generated by gencpp from file geometry_msgs/AccelWithCovarianceStamped.msg
-// Header header
+// DO NOT EDIT!
-// AccelWithCovariance accel
 
-#ifndef ACCEL_WITH_COVARIANCE_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H
-#define ACCEL_WITH_COVARIANCE_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/AccelWithCovariance.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct AccelWithCovarianceStamped
+  struct AccelWithCovarianceStamped_
   {
-    std_msgs::Header header;
+    typedef AccelWithCovarianceStamped_<ContainerAllocator> Type;
-    AccelWithCovariance accel;
+
-    // Constructor mặc định
+    AccelWithCovarianceStamped_()
-    AccelWithCovarianceStamped() = default;
+        : header(), accel()
-};
+    {
+    }
+    AccelWithCovarianceStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), accel(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::shared_ptr<::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelWithCovarianceStamped_
+
+  typedef ::geometry_msgs::AccelWithCovarianceStamped_<std::allocator<void>> AccelWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::AccelWithCovarianceStamped> AccelWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::AccelWithCovarianceStamped const> AccelWithCovarianceStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::AccelWithCovarianceStamped &lhs, const geometry_msgs::AccelWithCovarianceStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.accel == rhs.accel;
   }
 
-inline bool operator!=(const geometry_msgs::AccelWithCovarianceStamped &lhs, const geometry_msgs::AccelWithCovarianceStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H
-#endif // ACCEL_WITH_COVARIANCE_STAMPED_H

geometry_msgs/include/geometry_msgs/Inertia.h

@@ -1,61 +1,88 @@
-#ifndef INERTIA_H
+// Generated by gencpp from file geometry_msgs/Inertia.msg
-#define INERTIA_H
+// DO NOT EDIT!
+
+#ifndef GEOMETRY_MSGS_MESSAGE_INERTIA_H
+#define GEOMETRY_MSGS_MESSAGE_INERTIA_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <geometry_msgs/Vector3.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Inertia
+  struct Inertia_
   {
-    double m;
+    typedef Inertia_<ContainerAllocator> Type;
-    Vector3 com;
-    double ixx;
-    double ixy;
-    double ixz;
-    double iyy;
-    double iyz;
-    double izz;
 
-    Inertia() :
+    Inertia_()
-        m(0.0),
+        : m(0.0), com(), ixx(0.0), ixy(0.0), ixz(0.0), iyy(0.0), iyz(0.0), izz(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_) {};
-};
-
-// 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 &&
+    Inertia_(const ContainerAllocator &_alloc)
-        isEqual(lhs.ixx, rhs.ixx) &&
+        : m(0.0), com(_alloc), ixx(0.0), ixy(0.0), ixz(0.0), iyy(0.0), iyz(0.0), izz(0.0)
-        isEqual(lhs.ixy, rhs.ixy) &&
+    {
-        isEqual(lhs.ixz, rhs.ixz) &&
+      (void)_alloc;
-        isEqual(lhs.iyy, rhs.iyy) &&
-        isEqual(lhs.iyz, rhs.iyz) &&
-        isEqual(lhs.izz, rhs.izz);
     }
 
-inline bool operator!=(const geometry_msgs::Inertia &lhs, const geometry_msgs::Inertia &rhs)
+    typedef double _m_type;
+    _m_type m;
+
+    typedef ::geometry_msgs::Vector3_<ContainerAllocator> _com_type;
+    _com_type com;
+
+    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_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Inertia_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Inertia_
+
+  typedef ::geometry_msgs::Inertia_<std::allocator<void>> 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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Inertia_<ContainerAllocator1> &lhs, const ::geometry_msgs::Inertia_<ContainerAllocator2> &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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Inertia_<ContainerAllocator1> &lhs, const ::geometry_msgs::Inertia_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // INERTIA_H
+#endif // GEOMETRY_MSGS_MESSAGE_INERTIA_H

geometry_msgs/include/geometry_msgs/InertiaStamped.h

@@ -1,35 +1,65 @@
-// Header header
+// Generated by gencpp from file geometry_msgs/InertiaStamped.msg
-// Inertia inertia
+// DO NOT EDIT!
 
-#ifndef INERTIA_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H
-#define INERTIA_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Inertia.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct InertiaStamped
+  struct InertiaStamped_
   {
-    std_msgs::Header header;
+    typedef InertiaStamped_<ContainerAllocator> Type;
-    Inertia inertia;
+
-    // Constructor mặc định
+    InertiaStamped_()
-    InertiaStamped() = default;
+        : header(), inertia()
-};
+    {
+    }
+    InertiaStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), inertia(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Inertia_<ContainerAllocator> _inertia_type;
+    _inertia_type inertia;
+
+    typedef boost::shared_ptr<::geometry_msgs::InertiaStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::InertiaStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct InertiaStamped_
+
+  typedef ::geometry_msgs::InertiaStamped_<std::allocator<void>> InertiaStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::InertiaStamped> InertiaStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::InertiaStamped const> InertiaStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::InertiaStamped &lhs, const geometry_msgs::InertiaStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::InertiaStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::InertiaStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.inertia == rhs.inertia;
   }
 
-inline bool operator!=(const geometry_msgs::InertiaStamped &lhs, const geometry_msgs::InertiaStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::InertiaStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::InertiaStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // INERTIA_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H

geometry_msgs/include/geometry_msgs/Point.h

@@ -1,41 +1,65 @@
-#ifndef POINT_H
+// Generated by gencpp from file geometry_msgs/Point.msg
-#define POINT_H
+// DO NOT EDIT!
 
-#include <cmath>
+#ifndef GEOMETRY_MSGS_MESSAGE_POINT_H
-#include <iostream>
+#define GEOMETRY_MSGS_MESSAGE_POINT_H
-#include "utils.h"
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Point
+  struct Point_
   {
-    double x;
+    typedef Point_<ContainerAllocator> Type;
-    double y;
-    double z;
 
-    // Constructor mặc định
+    Point_()
-    Point() : x(0.0), y(0.0), z(0.0) {}
+        : x(0.0), y(0.0), z(0.0)
-
-    // Constructor khởi tạo nhanh
-    Point(double x_, double y_, double z_ = 0.0)
-        : x(x_), y(y_), z(z_) {}
-};
-
-// 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) &&
+    Point_(const ContainerAllocator &_alloc)
-        isEqual(lhs.z, rhs.z);
+        : x(0.0), y(0.0), z(0.0)
+    {
+      (void)_alloc;
     }
 
-inline bool operator!=(const geometry_msgs::Point &lhs, const geometry_msgs::Point &rhs)
+    typedef double _x_type;
+    _x_type x;
+
+    typedef double _y_type;
+    _y_type y;
+
+    typedef double _z_type;
+    _z_type z;
+
+    typedef boost::shared_ptr<::geometry_msgs::Point_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Point_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Point_
+
+  typedef ::geometry_msgs::Point_<std::allocator<void>> 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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Point_<ContainerAllocator1> &lhs, const ::geometry_msgs::Point_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.z == rhs.z;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Point_<ContainerAllocator1> &lhs, const ::geometry_msgs::Point_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
-
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_POINT_H
-#endif // POINT_H

geometry_msgs/include/geometry_msgs/Point32.h

@@ -1,34 +1,66 @@
-#ifndef POINT_32_H
+// Generated by gencpp from file geometry_msgs/Point32.msg
-#define POINT_32_H
+// DO NOT EDIT!
 
-#include "utils.h"
+#ifndef GEOMETRY_MSGS_MESSAGE_POINT32_H
+#define GEOMETRY_MSGS_MESSAGE_POINT32_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 namespace geometry_msgs
 {
-struct Point32
+  template <class ContainerAllocator>
+  struct Point32_
   {
-    float x;
+    typedef Point32_<ContainerAllocator> Type;
-    float y;
-    float z;
 
-    Point32() : x(0.0f), y(0.0f), z(0.0f) {}
+    Point32_()
-    Point32(float x_, float y_, float z_)
+        : x(0.0), y(0.0), z(0.0)
-        : x(x_), y(y_), z(z_) {}
-};
-
-// 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) &&
+    Point32_(const ContainerAllocator &_alloc)
-        isEqual(lhs.z, rhs.z);
+        : x(0.0), y(0.0), z(0.0)
+    {
+      (void)_alloc;
     }
 
-inline bool operator!=(const geometry_msgs::Point32 &lhs, const geometry_msgs::Point32 &rhs)
+    typedef float _x_type;
+    _x_type x;
+
+    typedef float _y_type;
+    _y_type y;
+
+    typedef float _z_type;
+    _z_type z;
+
+    typedef boost::shared_ptr<::geometry_msgs::Point32_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Point32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Point32_
+
+  typedef ::geometry_msgs::Point32_<std::allocator<void>> 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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Point32_<ContainerAllocator1> &lhs, const ::geometry_msgs::Point32_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.z == rhs.z;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Point32_<ContainerAllocator1> &lhs, const ::geometry_msgs::Point32_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif //POINT_32_H
+#endif // GEOMETRY_MSGS_MESSAGE_POINT32_H

geometry_msgs/include/geometry_msgs/PointStamped.h

@@ -1,34 +1,65 @@
-// # This represents a Point with reference coordinate frame and timestamp
+// Generated by gencpp from file geometry_msgs/PointStamped.msg
-// Header header
+// DO NOT EDIT!
-// Point point
+
-#ifndef POINT_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H
-#define POINT_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H
-#include "std_msgs/Header.h"
+
-#include "geometry_msgs/Point.h"
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <geometry_msgs/Point.h>
 
 namespace geometry_msgs
 {
-    
+  template <class ContainerAllocator>
-struct PointStamped
+  struct PointStamped_
   {
-    std_msgs::Header header;
+    typedef PointStamped_<ContainerAllocator> Type;
-    geometry_msgs::Point point;
+
-    PointStamped() = default;
+    PointStamped_()
-};
+        : header(), point()
+    {
+    }
+    PointStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), point(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Point_<ContainerAllocator> _point_type;
+    _point_type point;
+
+    typedef boost::shared_ptr<::geometry_msgs::PointStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::PointStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PointStamped_
+
+  typedef ::geometry_msgs::PointStamped_<std::allocator<void>> PointStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::PointStamped> PointStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::PointStamped const> PointStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::PointStamped &lhs, const geometry_msgs::PointStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::PointStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PointStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.point == rhs.point;
   }
 
-inline bool operator!=(const geometry_msgs::PointStamped &lhs, const geometry_msgs::PointStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::PointStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PointStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
-
 } // namespace geometry_msgs
 
-#endif //POINT_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H

geometry_msgs/include/geometry_msgs/Polygon.h

@@ -1,33 +1,60 @@
-#ifndef POLYGON_H
+// Generated by gencpp from file geometry_msgs/Polygon.msg
-#define POLYGON_H
+// DO NOT EDIT!
+
+#ifndef GEOMETRY_MSGS_MESSAGE_POLYGON_H
+#define GEOMETRY_MSGS_MESSAGE_POLYGON_H
+
+#include <string>
 #include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
 #include <geometry_msgs/Point32.h>
 
 namespace geometry_msgs
 {
+  template <class ContainerAllocator>
+  struct Polygon_
+  {
+    typedef Polygon_<ContainerAllocator> Type;
 
-struct Polygon
+    Polygon_()
+        : points()
     {
-    std::vector<geometry_msgs::Point32> 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++)
-    {
-        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)
+    typedef std::vector<::geometry_msgs::Point32_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::geometry_msgs::Point32_<ContainerAllocator>>> _points_type;
+    _points_type points;
+
+    typedef boost::shared_ptr<::geometry_msgs::Polygon_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Polygon_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Polygon_
+
+  typedef ::geometry_msgs::Polygon_<std::allocator<void>> 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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Polygon_<ContainerAllocator1> &lhs, const ::geometry_msgs::Polygon_<ContainerAllocator2> &rhs)
+  {
+    return lhs.points == rhs.points;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Polygon_<ContainerAllocator1> &lhs, const ::geometry_msgs::Polygon_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif //POLYGON_H
+#endif // GEOMETRY_MSGS_MESSAGE_POLYGON_H

geometry_msgs/include/geometry_msgs/PolygonStamped.h

@@ -1,32 +1,65 @@
-// # This represents a Polygon with reference coordinate frame and timestamp
+// Generated by gencpp from file geometry_msgs/PolygonStamped.msg
-// Header header
+// DO NOT EDIT!
-// Polygon polygon
+
-#ifndef POLYGON_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H
-#define POLYGON_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Polygon.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct PolygonStamped
+  struct PolygonStamped_
   {
-    std_msgs::Header header;
+    typedef PolygonStamped_<ContainerAllocator> Type;
-    Polygon polygon;
-};
 
-inline bool operator==(const geometry_msgs::PolygonStamped &lhs, const geometry_msgs::PolygonStamped &rhs)
+    PolygonStamped_()
+        : header(), polygon()
+    {
+    }
+    PolygonStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), polygon(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Polygon_<ContainerAllocator> _polygon_type;
+    _polygon_type polygon;
+
+    typedef boost::shared_ptr<::geometry_msgs::PolygonStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::PolygonStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PolygonStamped_
+
+  typedef ::geometry_msgs::PolygonStamped_<std::allocator<void>> 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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::PolygonStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PolygonStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.polygon == rhs.polygon;
   }
 
-inline bool operator!=(const geometry_msgs::PolygonStamped &lhs, const geometry_msgs::PolygonStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::PolygonStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PolygonStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif //POLYGON_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H

geometry_msgs/include/geometry_msgs/Pose.h

@@ -1,37 +1,64 @@
-#ifndef POSE_H
+// Generated by gencpp from file geometry_msgs/Pose.msg
-#define POSE_H
+// DO NOT EDIT!
+
+#ifndef GEOMETRY_MSGS_MESSAGE_POSE_H
+#define GEOMETRY_MSGS_MESSAGE_POSE_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
-#include <cmath>
-#include <iostream>
 #include <geometry_msgs/Point.h>
 #include <geometry_msgs/Quaternion.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Pose
+  struct Pose_
   {
-    Point position;
+    typedef Pose_<ContainerAllocator> Type;
-    Quaternion orientation;
 
-    Pose() = default;
+    Pose_()
+        : position(), orientation()
+    {
+    }
+    Pose_(const ContainerAllocator &_alloc)
+        : position(_alloc), orientation(_alloc)
+    {
+      (void)_alloc;
+    }
 
-    Pose(Point position_, Quaternion orientation_)
+    typedef ::geometry_msgs::Point_<ContainerAllocator> _position_type;
-        : position(position_), orientation(orientation_) {};
+    _position_type position;
-};
+
+    typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _orientation_type;
+    _orientation_type orientation;
+
+    typedef boost::shared_ptr<::geometry_msgs::Pose_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Pose_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Pose_
+
+  typedef ::geometry_msgs::Pose_<std::allocator<void>> Pose;
+
+  typedef boost::shared_ptr<::geometry_msgs::Pose> PosePtr;
+  typedef boost::shared_ptr<::geometry_msgs::Pose const> PoseConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::Pose &lhs, const geometry_msgs::Pose &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Pose_<ContainerAllocator1> &lhs, const ::geometry_msgs::Pose_<ContainerAllocator2> &rhs)
   {
     return lhs.position == rhs.position &&
            lhs.orientation == rhs.orientation;
   }
 
-inline bool operator!=(const geometry_msgs::Pose &lhs, const geometry_msgs::Pose &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Pose_<ContainerAllocator1> &lhs, const ::geometry_msgs::Pose_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_POSE_H
-#endif // POSE_H

geometry_msgs/include/geometry_msgs/Pose2D.h

@@ -1,50 +1,66 @@
-// # Deprecated
+// Generated by gencpp from file geometry_msgs/Pose2D.msg
-// # Please use the full 3D pose.
+// 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.
+#include <string>
-
+#include <vector>
-
+#include <memory>
-// # This expresses a position and orientation on a 2D manifold.
+#include <boost/shared_ptr.hpp>
-
-// float64 x
-// float64 y
-// float64 theta
-
-#ifndef POSE2D_H
-#define POSE2D_H
-
-#include "utils.h"
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Pose2D
+  struct Pose2D_
   {
-    double x;
+    typedef Pose2D_<ContainerAllocator> Type;
-    double y;
-    double theta;
 
-    Pose2D() : x(0.0), y(0.0), theta(0.0) {}
+    Pose2D_()
-    Pose2D(double x_, double y_, double theta_)
+        : x(0.0), y(0.0), theta(0.0)
-        : x(x_), y(y_), theta(theta_) {}
-};
-
-// 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) &&
+    Pose2D_(const ContainerAllocator &_alloc)
-        isEqual(lhs.theta, rhs.theta);
+        : x(0.0), y(0.0), theta(0.0)
+    {
+      (void)_alloc;
     }
 
-inline bool operator!=(const geometry_msgs::Pose2D &lhs, const geometry_msgs::Pose2D &rhs)
+    typedef double _x_type;
+    _x_type x;
+
+    typedef double _y_type;
+    _y_type y;
+
+    typedef double _theta_type;
+    _theta_type theta;
+
+    typedef boost::shared_ptr<::geometry_msgs::Pose2D_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Pose2D_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Pose2D_
+
+  typedef ::geometry_msgs::Pose2D_<std::allocator<void>> 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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Pose2D_<ContainerAllocator1> &lhs, const ::geometry_msgs::Pose2D_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.theta == rhs.theta;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Pose2D_<ContainerAllocator1> &lhs, const ::geometry_msgs::Pose2D_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // POSE2D_H
+#endif // GEOMETRY_MSGS_MESSAGE_POSE2D_H
-

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
+#ifndef GEOMETRY_MSGS_MESSAGE_POSEARRAY_H
-
+#define GEOMETRY_MSGS_MESSAGE_POSEARRAY_H
-// Pose[] poses
-#ifndef POSE_ARRAY_H
-#define POSE_ARRAY_H
 
+#include <string>
 #include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Pose.h>
 
-
-
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct PoseArray
+  struct PoseArray_
   {
-    std_msgs::Header header;
+    typedef PoseArray_<ContainerAllocator> Type;
-    std::vector<Pose> poses;
 
-    PoseArray() = default;
+    PoseArray_()
-};
+        : header(), poses()
+    {
+    }
+    PoseArray_(const ContainerAllocator &_alloc)
+        : header(_alloc), poses(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef std::vector<::geometry_msgs::Pose_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::geometry_msgs::Pose_<ContainerAllocator>>> _poses_type;
+    _poses_type poses;
+
+    typedef boost::shared_ptr<::geometry_msgs::PoseArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::PoseArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseArray_
+
+  typedef ::geometry_msgs::PoseArray_<std::allocator<void>> PoseArray;
+
+  typedef boost::shared_ptr<::geometry_msgs::PoseArray> PoseArrayPtr;
+  typedef boost::shared_ptr<::geometry_msgs::PoseArray const> PoseArrayConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::PoseArray &lhs, const geometry_msgs::PoseArray &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::PoseArray_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseArray_<ContainerAllocator2> &rhs)
   {
-    if(lhs.poses.size() != rhs.poses.size())
+    return lhs.header == rhs.header &&
-        return false;
+           lhs.poses == rhs.poses;
-    for(int i = 0; i < lhs.poses.size(); i++)
-    {
-        if(!(lhs.poses[i] == rhs.poses[i]))
-            return false;
-    }
-return lhs.header == rhs.header;
   }
 
-inline bool operator!=(const geometry_msgs::PoseArray &lhs, const geometry_msgs::PoseArray &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::PoseArray_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseArray_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // POSE_ARRAY_H
+#endif // GEOMETRY_MSGS_MESSAGE_POSEARRAY_H

geometry_msgs/include/geometry_msgs/PoseStamped.h

@@ -1,37 +1,65 @@
-// # A Pose with reference coordinate frame and timestamp
+// Generated by gencpp from file geometry_msgs/PoseStamped.msg
-// Header header
+// DO NOT EDIT!
-// Pose pose
+
-#ifndef POSE_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H
-#define POSE_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Pose.h>
 
-
-
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct PoseStamped
+  struct PoseStamped_
   {
-    std_msgs::Header header;
+    typedef PoseStamped_<ContainerAllocator> Type;
-    Pose pose;
 
-    PoseStamped() = default;
+    PoseStamped_()
-};
+        : header(), pose()
+    {
+    }
+    PoseStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), pose(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Pose_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::shared_ptr<::geometry_msgs::PoseStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::PoseStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseStamped_
+
+  typedef ::geometry_msgs::PoseStamped_<std::allocator<void>> PoseStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::PoseStamped> PoseStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::PoseStamped const> PoseStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::PoseStamped &lhs, const geometry_msgs::PoseStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::PoseStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.pose == rhs.pose;
   }
 
-inline bool operator!=(const geometry_msgs::PoseStamped &lhs, const geometry_msgs::PoseStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::PoseStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // POSE_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H

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
+#include <string>
-// # The orientation parameters use a fixed-axis representation.
+#include <vector>
-// # In order, the parameters are:
+#include <memory>
-// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
+#include <boost/shared_ptr.hpp>
-// float64[36] covariance
+#include <boost/array.hpp>
-
-#ifndef POSE_WITH_COVARIANCE_H
-#define POSE_WITH_COVARIANCE_H
-
-#include <array>
 #include <geometry_msgs/Pose.h>
 
-
 namespace geometry_msgs
 {
+  template <class ContainerAllocator>
+  struct PoseWithCovariance_
+  {
+    typedef PoseWithCovariance_<ContainerAllocator> Type;
 
-struct PoseWithCovariance
+    PoseWithCovariance_()
+        : pose(), covariance()
     {
-    Pose pose;
+      covariance.assign(0.0);
-    std::array<double, 36> 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)
-    {
-        if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
-        {
-            return false;
     }
-    }
+    PoseWithCovariance_(const ContainerAllocator &_alloc)
-return lhs.pose == rhs.pose;
+        : pose(_alloc), covariance()
+    {
+      (void)_alloc;
+      covariance.assign(0.0);
     }
 
-inline bool operator!=(const geometry_msgs::PoseWithCovariance &lhs, const geometry_msgs::PoseWithCovariance &rhs)
+    typedef ::geometry_msgs::Pose_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseWithCovariance_
+
+  typedef ::geometry_msgs::PoseWithCovariance_<std::allocator<void>> PoseWithCovariance;
+
+  typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance> PoseWithCovariancePtr;
+  typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance const> PoseWithCovarianceConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return lhs.pose == rhs.pose &&
+           lhs.covariance == rhs.covariance;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H
-#endif // POSE_WITH_COVARIANCE_H

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
+#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
-// PoseWithCovariance pose
+#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
 
-#ifndef POSE_WITH_COVARIANCE_STAMPED_H
+#include <string>
-#define POSE_WITH_COVARIANCE_STAMPED_H
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/PoseWithCovariance.h>
 
-
-
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct PoseWithCovarianceStamped
+  struct PoseWithCovarianceStamped_
   {
-    std_msgs::Header header;
+    typedef PoseWithCovarianceStamped_<ContainerAllocator> Type;
-    PoseWithCovariance pose;
 
-    PoseWithCovarianceStamped() = default;
+    PoseWithCovarianceStamped_()
-};
+        : header(), pose()
+    {
+    }
+    PoseWithCovarianceStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), pose(_alloc)
+    {
+      (void)_alloc;
+    }
 
-// constants requiring out of line definition
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
-inline bool operator==(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs)
+    _header_type header;
+
+    typedef ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseWithCovarianceStamped_
+
+  typedef ::geometry_msgs::PoseWithCovarianceStamped_<std::allocator<void>> PoseWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped> PoseWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped const> PoseWithCovarianceStampedConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.pose == rhs.pose;
   }
 
-inline bool operator!=(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
-
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
-#endif // POSE_WITH_COVARIANCE_STAMPED_H

geometry_msgs/include/geometry_msgs/Quaternion.h

@@ -1,40 +1,69 @@
-#ifndef QUATERNION_H
+// Generated by gencpp from file geometry_msgs/Quaternion.msg
-#define QUATERNION_H
+// DO NOT EDIT!
 
-#include "utils.h"
+#ifndef GEOMETRY_MSGS_MESSAGE_QUATERNION_H
+#define GEOMETRY_MSGS_MESSAGE_QUATERNION_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Quaternion
+  struct Quaternion_
   {
-    double x;
+    typedef Quaternion_<ContainerAllocator> Type;
-    double y;
-    double z;
-    double w;
 
-    // Constructor mặc định
+    Quaternion_()
-    Quaternion() : x(0.0), y(0.0), z(0.0), w(1.0) {}
+        : x(0.0), y(0.0), z(0.0), w(0.0)
-
-    // Constructor khởi tạo nhanh
-    Quaternion(double x_, double y_, double z_, double w_)
-        : x(x_), y(y_), z(z_), w(w_) {}
-};
-
-// 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) &&
+    Quaternion_(const ContainerAllocator &_alloc)
-        isEqual(lhs.z, rhs.z) &&
+        : x(0.0), y(0.0), z(0.0), w(0.0)
-        isEqual(lhs.w, rhs.w);
+    {
+      (void)_alloc;
     }
 
-inline bool operator!=(const geometry_msgs::Quaternion &lhs, const geometry_msgs::Quaternion &rhs)
+    typedef double _x_type;
+    _x_type x;
+
+    typedef double _y_type;
+    _y_type y;
+
+    typedef double _z_type;
+    _z_type z;
+
+    typedef double _w_type;
+    _w_type w;
+
+    typedef boost::shared_ptr<::geometry_msgs::Quaternion_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Quaternion_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Quaternion_
+
+  typedef ::geometry_msgs::Quaternion_<std::allocator<void>> 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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Quaternion_<ContainerAllocator1> &lhs, const ::geometry_msgs::Quaternion_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.z == rhs.z &&
+           lhs.w == rhs.w;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Quaternion_<ContainerAllocator1> &lhs, const ::geometry_msgs::Quaternion_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_QUATERNION_H
-#endif // QUATERNION_H

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
+#ifndef GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H
-// Quaternion quaternion
+#define GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H
 
-#ifndef QUATERNION_STAMPED_H
+#include <string>
-#define QUATERNION_STAMPED_H
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Quaternion.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct QuaternionStamped
+  struct QuaternionStamped_
   {
-    std_msgs::Header header;
+    typedef QuaternionStamped_<ContainerAllocator> Type;
-    Quaternion quaternion;
+
-    // Constructor mặc định
+    QuaternionStamped_()
-    QuaternionStamped() = default;
+        : header(), quaternion()
-};
+    {
+    }
+    QuaternionStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), quaternion(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _quaternion_type;
+    _quaternion_type quaternion;
+
+    typedef boost::shared_ptr<::geometry_msgs::QuaternionStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::QuaternionStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct QuaternionStamped_
+
+  typedef ::geometry_msgs::QuaternionStamped_<std::allocator<void>> QuaternionStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::QuaternionStamped> QuaternionStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::QuaternionStamped const> QuaternionStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::QuaternionStamped &lhs, const geometry_msgs::QuaternionStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::QuaternionStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::QuaternionStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.quaternion == rhs.quaternion;
   }
 
-inline bool operator!=(const geometry_msgs::QuaternionStamped &lhs, const geometry_msgs::QuaternionStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::QuaternionStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::QuaternionStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // QUATERNION_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H

geometry_msgs/include/geometry_msgs/Transform.h

@@ -1,35 +1,65 @@
-#ifndef TRANSFORM_H
+// Generated by gencpp from file geometry_msgs/Transform.msg
-#define TRANSFORM_H
+// DO NOT EDIT!
 
-#include "geometry_msgs/Vector3.h"
+#ifndef GEOMETRY_MSGS_MESSAGE_TRANSFORM_H
-#include "geometry_msgs/Quaternion.h"
+#define GEOMETRY_MSGS_MESSAGE_TRANSFORM_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <geometry_msgs/Vector3.h>
+#include <geometry_msgs/Quaternion.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Transform
+  struct Transform_
   {
-    Vector3 translation;
+    typedef Transform_<ContainerAllocator> Type;
-    Quaternion rotation;
 
-    Transform() = default;
+    Transform_()
-    Transform(Vector3 translation_, Quaternion rotation_)
+        : translation(), rotation()
-        : translation(translation_), rotation(rotation_) {}
+    {
-};
+    }
+    Transform_(const ContainerAllocator &_alloc)
+        : translation(_alloc), rotation(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::geometry_msgs::Vector3_<ContainerAllocator> _translation_type;
+    _translation_type translation;
+
+    typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _rotation_type;
+    _rotation_type rotation;
+
+    typedef boost::shared_ptr<::geometry_msgs::Transform_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Transform_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Transform_
+
+  typedef ::geometry_msgs::Transform_<std::allocator<void>> Transform;
+
+  typedef boost::shared_ptr<::geometry_msgs::Transform> TransformPtr;
+  typedef boost::shared_ptr<::geometry_msgs::Transform const> TransformConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::Transform &lhs, const geometry_msgs::Transform &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Transform_<ContainerAllocator1> &lhs, const ::geometry_msgs::Transform_<ContainerAllocator2> &rhs)
   {
     return lhs.translation == rhs.translation &&
            lhs.rotation == rhs.rotation;
   }
 
-inline bool operator!=(const geometry_msgs::Transform &lhs, const geometry_msgs::Transform &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Transform_<ContainerAllocator1> &lhs, const ::geometry_msgs::Transform_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
-
 } // namespace geometry_msgs
 
-#endif // TRANSFORM_H
+#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORM_H

geometry_msgs/include/geometry_msgs/TransformStamped.h

@@ -1,33 +1,69 @@
-#ifndef TRANSFORM_STAMPED_H
+// Generated by gencpp from file geometry_msgs/TransformStamped.msg
-#define TRANSFORM_STAMPED_H
+// 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 <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <geometry_msgs/Transform.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct TransformStamped
+  struct TransformStamped_
   {
-    std_msgs::Header header;
+    typedef TransformStamped_<ContainerAllocator> Type;
-    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;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _child_frame_id_type;
+    _child_frame_id_type child_frame_id;
+
+    typedef ::geometry_msgs::Transform_<ContainerAllocator> _transform_type;
+    _transform_type transform;
+
+    typedef boost::shared_ptr<::geometry_msgs::TransformStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::TransformStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TransformStamped_
+
+  typedef ::geometry_msgs::TransformStamped_<std::allocator<void>> TransformStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::TransformStamped> TransformStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::TransformStamped const> TransformStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::TransformStamped &lhs, const geometry_msgs::TransformStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::TransformStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::TransformStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.child_frame_id == rhs.child_frame_id &&
            lhs.transform == rhs.transform;
   }
 
-inline bool operator!=(const geometry_msgs::TransformStamped &lhs, const geometry_msgs::TransformStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::TransformStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::TransformStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // TRANSFORM_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H

geometry_msgs/include/geometry_msgs/Twist.h

@@ -1,40 +1,65 @@
-// # This expresses velocity in free space broken into its linear and angular parts.
+// Generated by gencpp from file geometry_msgs/Twist.msg
-// Vector3 linear
+// DO NOT EDIT!
-// Vector3 angular
 
-#ifndef TWIST_H
+#ifndef GEOMETRY_MSGS_MESSAGE_TWIST_H
-#define TWIST_H
+#define GEOMETRY_MSGS_MESSAGE_TWIST_H
 
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <geometry_msgs/Vector3.h>
 #include <geometry_msgs/Vector3.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Twist
+  struct Twist_
   {
-    Vector3 linear;
+    typedef Twist_<ContainerAllocator> Type;
-    Vector3 angular;
 
-    // Constructor mặc định
+    Twist_()
-    Twist() : linear(), angular() {}
+        : linear(), angular()
+    {
+    }
+    Twist_(const ContainerAllocator &_alloc)
+        : linear(_alloc), angular(_alloc)
+    {
+      (void)_alloc;
+    }
 
-    // Constructor khởi tạo nhanh
+    typedef ::geometry_msgs::Vector3_<ContainerAllocator> _linear_type;
-    Twist(const Vector3& linear_, const Vector3& angular_)
+    _linear_type linear;
-        : linear(linear_), angular(angular_) {}
+
-};
+    typedef ::geometry_msgs::Vector3_<ContainerAllocator> _angular_type;
+    _angular_type angular;
+
+    typedef boost::shared_ptr<::geometry_msgs::Twist_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Twist_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Twist_
+
+  typedef ::geometry_msgs::Twist_<std::allocator<void>> Twist;
+
+  typedef boost::shared_ptr<::geometry_msgs::Twist> TwistPtr;
+  typedef boost::shared_ptr<::geometry_msgs::Twist const> TwistConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Twist_<ContainerAllocator1> &lhs, const ::geometry_msgs::Twist_<ContainerAllocator2> &rhs)
   {
     return lhs.linear == rhs.linear &&
            lhs.angular == rhs.angular;
   }
 
-inline bool operator!=(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Twist_<ContainerAllocator1> &lhs, const ::geometry_msgs::Twist_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // ACCEL_H
+#endif // GEOMETRY_MSGS_MESSAGE_TWIST_H

geometry_msgs/include/geometry_msgs/TwistStamped.h

@@ -1,36 +1,65 @@
-// # A twist with reference coordinate frame and timestamp
+// Generated by gencpp from file geometry_msgs/TwistStamped.msg
-// Header header
+// DO NOT EDIT!
-// Twist twist
 
-#ifndef TWIST_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H
-#define TWIST_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Twist.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct TwistStamped
+  struct TwistStamped_
   {
-    std_msgs::Header header;
+    typedef TwistStamped_<ContainerAllocator> Type;
-    Twist twist;
+
-    // Constructor mặc định
+    TwistStamped_()
-    TwistStamped() = default;
+        : header(), twist()
-};
+    {
+    }
+    TwistStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), twist(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Twist_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::shared_ptr<::geometry_msgs::TwistStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::TwistStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistStamped_
+
+  typedef ::geometry_msgs::TwistStamped_<std::allocator<void>> TwistStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::TwistStamped> TwistStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::TwistStamped const> TwistStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::TwistStamped &lhs, const geometry_msgs::TwistStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::TwistStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::TwistStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.twist == rhs.twist;
   }
 
-inline bool operator!=(const geometry_msgs::TwistStamped &lhs, const geometry_msgs::TwistStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::TwistStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::TwistStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // TWIST_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H

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
+#include <string>
-// # The orientation parameters use a fixed-axis representation.
+#include <vector>
-// # In order, the parameters are:
+#include <memory>
-// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
+#include <boost/shared_ptr.hpp>
-// float64[36] covariance
+#include <boost/array.hpp>
-
-#ifndef TWIST_WITH_COVARIANCE_H
-#define TWIST_WITH_COVARIANCE_H
-
-#include <array>
 #include <geometry_msgs/Twist.h>
 
-
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct TwistWithCovariance
+  struct TwistWithCovariance_
   {
-    Twist twist;
+    typedef TwistWithCovariance_<ContainerAllocator> Type;
-    std::array<double, 36> covariance;
 
-    TwistWithCovariance() : twist(), covariance{{0.0}} {};
+    TwistWithCovariance_()
-};
+        : twist(), covariance()
+    {
+      covariance.assign(0.0);
+    }
+    TwistWithCovariance_(const ContainerAllocator &_alloc)
+        : twist(_alloc), covariance()
+    {
+      (void)_alloc;
+      covariance.assign(0.0);
+    }
+
+    typedef ::geometry_msgs::Twist_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistWithCovariance_
+
+  typedef ::geometry_msgs::TwistWithCovariance_<std::allocator<void>> TwistWithCovariance;
+
+  typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance> TwistWithCovariancePtr;
+  typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance const> TwistWithCovarianceConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::TwistWithCovariance &lhs, const geometry_msgs::TwistWithCovariance &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator2> &rhs)
   {
-    for(size_t i = 0; i < 36; ++i)
+    return lhs.twist == rhs.twist &&
-    {
+           lhs.covariance == rhs.covariance;
-        if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
-        {
-            return false;
-        }
-    }
-return lhs.twist == rhs.twist;
   }
 
-inline bool operator!=(const geometry_msgs::TwistWithCovariance &lhs, const geometry_msgs::TwistWithCovariance &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
-
 } // namespace geometry_msgs
 
-#endif // TWIST_WITH_COVARIANCE_H
+#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H

geometry_msgs/include/geometry_msgs/TwistWithCovarianceStamped.h

@@ -1,38 +1,65 @@
-// # This represents an estimated twist with reference coordinate frame and timestamp.
+// Generated by gencpp from file geometry_msgs/TwistWithCovarianceStamped.msg
-// Header header
+// DO NOT EDIT!
-// TwistWithCovariance twist
 
-#ifndef TWIST_WITH_COVARIANCE_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H
-#define TWIST_WITH_COVARIANCE_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/TwistWithCovariance.h>
 
-
-
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct TwistWithCovarianceStamped
+  struct TwistWithCovarianceStamped_
   {
-    std_msgs::Header header;
+    typedef TwistWithCovarianceStamped_<ContainerAllocator> Type;
-    TwistWithCovariance twist;
 
-    TwistWithCovarianceStamped() = default;
+    TwistWithCovarianceStamped_()
-};
+        : header(), twist()
+    {
+    }
+    TwistWithCovarianceStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), twist(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistWithCovarianceStamped_
+
+  typedef ::geometry_msgs::TwistWithCovarianceStamped_<std::allocator<void>> TwistWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped> TwistWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped const> TwistWithCovarianceStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::TwistWithCovarianceStamped &lhs, const geometry_msgs::TwistWithCovarianceStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.twist == rhs.twist;
   }
 
-inline bool operator!=(const geometry_msgs::TwistWithCovarianceStamped &lhs, const geometry_msgs::TwistWithCovarianceStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // TWIST_WITH_COVARIANCE_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H

geometry_msgs/include/geometry_msgs/Vector3.h

@@ -1,39 +1,63 @@
-#ifndef VECTOR_3_H
+// Generated by gencpp from file geometry_msgs/Vector3.msg
-#define VECTOR_3_H
+// DO NOT EDIT!
 
-#include "utils.h"
+#ifndef GEOMETRY_MSGS_MESSAGE_VECTOR3_H
+#define GEOMETRY_MSGS_MESSAGE_VECTOR3_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Vector3
+  struct Vector3_
   {
-    double x;
+    typedef Vector3_<ContainerAllocator> Type;
-    double y;
-    double z;
 
-    // Constructor mặc định
+    Vector3_()
-    Vector3() : x(0.0), y(0.0), z(0.0) {}
+        : x(0.0), y(0.0), z(0.0)
-
-    // Constructor khởi tạo nhanh
-    Vector3(double x_, double y_, double z_)
-        : x(x_), y(y_), z(z_) {}
-};
-
-// 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) &&
+    Vector3_(const ContainerAllocator &_alloc)
-        isEqual(lhs.z, rhs.z);
+        : x(0.0), y(0.0), z(0.0)
+    {
+      (void)_alloc;
     }
 
-inline bool operator!=(const geometry_msgs::Vector3 &lhs, const geometry_msgs::Vector3 &rhs)
+    typedef double _x_type;
+    _x_type x;
+
+    typedef double _y_type;
+    _y_type y;
+
+    typedef double _z_type;
+    _z_type z;
+
+    typedef boost::shared_ptr<::geometry_msgs::Vector3_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Vector3_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Vector3_
+
+  typedef ::geometry_msgs::Vector3_<std::allocator<void>> Vector3;
+
+  typedef boost::shared_ptr<::geometry_msgs::Vector3> Vector3Ptr;
+  typedef boost::shared_ptr<::geometry_msgs::Vector3 const> Vector3ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Vector3_<ContainerAllocator1> &lhs, const ::geometry_msgs::Vector3_<ContainerAllocator2> &rhs)
+  {
+    return lhs.x == rhs.x &&
+           lhs.y == rhs.y &&
+           lhs.z == rhs.z;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Vector3_<ContainerAllocator1> &lhs, const ::geometry_msgs::Vector3_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
-
 } // namespace geometry_msgs
-
+#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3_H
-#endif // VECTOR_3_H

geometry_msgs/include/geometry_msgs/Vector3Stamped.h

@@ -1,37 +1,65 @@
-// # This represents a Vector3 with reference coordinate frame and timestamp
+// Generated by gencpp from file geometry_msgs/Vector3Stamped.msg
-// Header header
+// DO NOT EDIT!
-// Vector3 vector
 
-#ifndef VECTOR_3_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H
-#define VECTOR_3_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Vector3.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Vector3Stamped
+  struct Vector3Stamped_
   {
-    std_msgs::Header header;
+    typedef Vector3Stamped_<ContainerAllocator> Type;
-    Vector3 vector;
+
-    // Constructor mặc định
+    Vector3Stamped_()
-    Vector3Stamped() = default;
+        : header(), vector()
-};
+    {
+    }
+    Vector3Stamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), vector(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Vector3_<ContainerAllocator> _vector_type;
+    _vector_type vector;
+
+    typedef boost::shared_ptr<::geometry_msgs::Vector3Stamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Vector3Stamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Vector3Stamped_
+
+  typedef ::geometry_msgs::Vector3Stamped_<std::allocator<void>> Vector3Stamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::Vector3Stamped> Vector3StampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::Vector3Stamped const> Vector3StampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::Vector3Stamped &lhs, const geometry_msgs::Vector3Stamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Vector3Stamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::Vector3Stamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.vector == rhs.vector;
   }
 
-inline bool operator!=(const geometry_msgs::Vector3Stamped &lhs, const geometry_msgs::Vector3Stamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Vector3Stamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::Vector3Stamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
-
 } // namespace geometry_msgs
 
-#endif // VECTOR_3_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H

geometry_msgs/include/geometry_msgs/Wrench.h

@@ -1,38 +1,65 @@
-// # This represents force in free space, separated into
+// Generated by gencpp from file geometry_msgs/Wrench.msg
-// # its linear and angular parts.
+// DO NOT EDIT!
-// Vector3  force
-// Vector3  torque
 
-#ifndef WRENCH_H
+#ifndef GEOMETRY_MSGS_MESSAGE_WRENCH_H
-#define WRENCH_H
+#define GEOMETRY_MSGS_MESSAGE_WRENCH_H
 
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <geometry_msgs/Vector3.h>
 #include <geometry_msgs/Vector3.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct Wrench
+  struct Wrench_
   {
-    Vector3  force;
+    typedef Wrench_<ContainerAllocator> Type;
-    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;
+    }
+
+    typedef ::geometry_msgs::Vector3_<ContainerAllocator> _force_type;
+    _force_type force;
+
+    typedef ::geometry_msgs::Vector3_<ContainerAllocator> _torque_type;
+    _torque_type torque;
+
+    typedef boost::shared_ptr<::geometry_msgs::Wrench_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::Wrench_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Wrench_
+
+  typedef ::geometry_msgs::Wrench_<std::allocator<void>> Wrench;
+
+  typedef boost::shared_ptr<::geometry_msgs::Wrench> WrenchPtr;
+  typedef boost::shared_ptr<::geometry_msgs::Wrench const> WrenchConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::Wrench &lhs, const geometry_msgs::Wrench &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::Wrench_<ContainerAllocator1> &lhs, const ::geometry_msgs::Wrench_<ContainerAllocator2> &rhs)
   {
     return lhs.force == rhs.force &&
            lhs.torque == rhs.torque;
   }
 
-inline bool operator!=(const geometry_msgs::Wrench &lhs, const geometry_msgs::Wrench &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::Wrench_<ContainerAllocator1> &lhs, const ::geometry_msgs::Wrench_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // WRENCH_H
+#endif // GEOMETRY_MSGS_MESSAGE_WRENCH_H

geometry_msgs/include/geometry_msgs/WrenchStamped.h

@@ -1,36 +1,65 @@
-// # A wrench with reference coordinate frame and timestamp
+// Generated by gencpp from file geometry_msgs/WrenchStamped.msg
-// Header header
+// DO NOT EDIT!
-// Wrench wrench
 
-#ifndef WRENCH_STAMPED_H
+#ifndef GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H
-#define WRENCH_STAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
 
 #include <std_msgs/Header.h>
 #include <geometry_msgs/Wrench.h>
 
 namespace geometry_msgs
 {
-
+  template <class ContainerAllocator>
-struct WrenchStamped
+  struct WrenchStamped_
   {
-    std_msgs::Header header;
+    typedef WrenchStamped_<ContainerAllocator> Type;
-    Wrench wrench;
+
-    // Constructor mặc định
+    WrenchStamped_()
-    WrenchStamped() = default;
+        : header(), wrench()
-};
+    {
+    }
+    WrenchStamped_(const ContainerAllocator &_alloc)
+        : header(_alloc), wrench(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
+    _header_type header;
+
+    typedef ::geometry_msgs::Wrench_<ContainerAllocator> _wrench_type;
+    _wrench_type wrench;
+
+    typedef boost::shared_ptr<::geometry_msgs::WrenchStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::geometry_msgs::WrenchStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct WrenchStamped_
+
+  typedef ::geometry_msgs::WrenchStamped_<std::allocator<void>> WrenchStamped;
+
+  typedef boost::shared_ptr<::geometry_msgs::WrenchStamped> WrenchStampedPtr;
+  typedef boost::shared_ptr<::geometry_msgs::WrenchStamped const> WrenchStampedConstPtr;
 
   // constants requiring out of line definition
-inline bool operator==(const geometry_msgs::WrenchStamped &lhs, const geometry_msgs::WrenchStamped &rhs)
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::geometry_msgs::WrenchStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::WrenchStamped_<ContainerAllocator2> &rhs)
   {
     return lhs.header == rhs.header &&
            lhs.wrench == rhs.wrench;
   }
 
-inline bool operator!=(const geometry_msgs::WrenchStamped &lhs, const geometry_msgs::WrenchStamped &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::geometry_msgs::WrenchStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::WrenchStamped_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace geometry_msgs
 
-#endif // WRENCH_STAMPED_H
+#endif // GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H

nav_msgs/include/nav_msgs/MapMetaData.h

@@ -5,7 +5,7 @@
 #include <string>
 #include <vector>
 #include "geometry_msgs/Pose.h"
-// #include "utils.h"
+#include "utils.h"
 
 namespace nav_msgs
 {

std_msgs/include/std_msgs/Header.h

@@ -1,32 +1,66 @@
-#ifndef STD_MSGS_HEADER_H
+// Generated by gencpp from file std_msgs/Header.msg
-#define STD_MSGS_HEADER_H
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_HEADER_H
+#define STD_MSGS_MESSAGE_HEADER_H
 
 #include <string>
-#include <cstdint>
+#include <vector>
+#include <memory>
+
 #include <robot/time.h>
 
-namespace std_msgs {
+namespace std_msgs
-
-struct Header
 {
-  uint32_t seq;  // số thứ tự message
+  template <class ContainerAllocator>
-  robot::Time stamp; // thời gian timestamp
+  struct Header_
-  std::string frame_id;
+  {
+    typedef Header_<ContainerAllocator> 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)
+    typedef uint32_t _seq_type;
+    _seq_type seq;
+
+    typedef robot::Time _stamp_type;
+    _stamp_type stamp;
+
+    typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _frame_id_type;
+    _frame_id_type frame_id;
+
+    typedef std::shared_ptr<::std_msgs::Header_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::std_msgs::Header_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Header_
+
+  typedef ::std_msgs::Header_<std::allocator<void>> 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 <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Header_<ContainerAllocator1> &lhs, const ::std_msgs::Header_<ContainerAllocator2> &rhs)
   {
     return lhs.seq == rhs.seq &&
            lhs.stamp == rhs.stamp &&
            lhs.frame_id == rhs.frame_id;
   }
 
-inline bool operator!=(const std_msgs::Header &lhs, const std_msgs::Header &rhs)
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Header_<ContainerAllocator1> &lhs, const ::std_msgs::Header_<ContainerAllocator2> &rhs)
   {
     return !(lhs == rhs);
   }
 
 } // namespace std_msgs
-#endif
+
+#endif // STD_MSGS_MESSAGE_HEADER_H