add more files msgs

CMakeLists.txt

@@ -3,6 +3,8 @@ project(common_msgs)
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
+add_subdirectory(utils)
+
 if (NOT TARGET std_msgs)
     add_subdirectory(std_msgs)
 endif()

geometry_msgs/CMakeLists.txt

@@ -15,7 +15,7 @@ target_include_directories(geometry_msgs
 )
 
 # Liên kết với std_msgs nếu bạn có file Header.h trong include/std_msgs/
-target_link_libraries(geometry_msgs INTERFACE std_msgs)
+target_link_libraries(geometry_msgs INTERFACE std_msgs utils)
 
 # --- Cài đặt thư viện vào hệ thống khi chạy make install ---
 install(TARGETS geometry_msgs

geometry_msgs/include/geometry_msgs/Accel.h

@@ -23,6 +23,19 @@ struct Accel
         : linear(linear_), angular(angular_) {}
 };
 
+// constants requiring out of line definition
+inline bool operator==(const geometry_msgs::Accel &lhs, const geometry_msgs::Accel &rhs)
+{
+return lhs.linear == rhs.linear &&
+        lhs.angular == rhs.angular;
+}
+
+inline bool operator!=(const geometry_msgs::Accel &lhs, const geometry_msgs::Accel &rhs)
+{
+return !(lhs == rhs);
+}
+
+
 } // namespace geometry_msgs
 
 #endif // ACCEL_H

geometry_msgs/include/geometry_msgs/AccelStamped.h

@@ -19,6 +19,18 @@ struct AccelStamped
     AccelStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::AccelStamped &lhs, const geometry_msgs::AccelStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // ACCEL_STAMPED_H

geometry_msgs/include/geometry_msgs/AccelWithCovariance.h

@@ -22,9 +22,27 @@ struct AccelWithCovariance
     Accel accel;
     std::array<double, 36> covariance;
     // Constructor mặc định
-    AccelWithCovariance() = default;
+    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)
+    {
+        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)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // ACCEL_WITH_COVARIANCE_H

geometry_msgs/include/geometry_msgs/AccelWithCovarianceStamped.h

@@ -19,6 +19,18 @@ struct AccelWithCovarianceStamped
     AccelWithCovarianceStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::AccelWithCovarianceStamped &lhs, const geometry_msgs::AccelWithCovarianceStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // ACCEL_WITH_COVARIANCE_STAMPED_H

geometry_msgs/include/geometry_msgs/Inertia.h

@@ -1,20 +1,3 @@
-// # Mass [kg]
-// float64 m
-
-// # Center of mass [m]
-// geometry_msgs/Vector3 com
-
-// # Inertia Tensor [kg-m^2]
-// #     | ixx ixy ixz |
-// # I = | ixy iyy iyz |
-// #     | ixz iyz izz |
-// float64 ixx
-// float64 ixy
-// float64 ixz
-// float64 iyy
-// float64 iyz
-// float64 izz
-
 #ifndef INERTIA_H
 #define INERTIA_H
 
@@ -33,8 +16,46 @@ struct Inertia
     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(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 &&
+        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);
+}
+
+inline bool operator!=(const geometry_msgs::Inertia &lhs, const geometry_msgs::Inertia &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // INERTIA_H

geometry_msgs/include/geometry_msgs/InertiaStamped.h

@@ -18,6 +18,18 @@ struct InertiaStamped
     InertiaStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::InertiaStamped &lhs, const geometry_msgs::InertiaStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // INERTIA_STAMPED_H

geometry_msgs/include/geometry_msgs/Point.h

@@ -3,6 +3,7 @@
 
 #include <cmath>
 #include <iostream>
+#include "utils.h"
 
 namespace geometry_msgs
 {
@@ -21,6 +22,20 @@ struct Point
         : 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) &&
+        isEqual(lhs.z, rhs.z);
+}
+
+inline bool operator!=(const geometry_msgs::Point &lhs, const geometry_msgs::Point &rhs)
+{
+return !(lhs == rhs);
+}
+
+
 } // namespace geometry_msgs
 
 #endif // POINT_H

geometry_msgs/include/geometry_msgs/Point32.h

@@ -1,6 +1,8 @@
 #ifndef POINT_32_H
 #define POINT_32_H
 
+#include "utils.h"
+
 namespace geometry_msgs
 {
 struct Point32
@@ -8,7 +10,25 @@ struct Point32
     float x;
     float y;
     float z;
+
+    Point32() : x(0.0f), y(0.0f), z(0.0f) {}
+    Point32(float x_, float y_, float z_)
+        : 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) &&
+        isEqual(lhs.z, rhs.z);
+}
+
+inline bool operator!=(const geometry_msgs::Point32 &lhs, const geometry_msgs::Point32 &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif //POINT_32_H

geometry_msgs/include/geometry_msgs/PointStamped.h

@@ -16,6 +16,19 @@ struct PointStamped
     PointStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::PointStamped &lhs, const geometry_msgs::PointStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
+
 } // namespace geometry_msgs
 
 #endif //POINT_STAMPED_H

geometry_msgs/include/geometry_msgs/Polygon.h

@@ -11,6 +11,23 @@ struct Polygon
     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;
+}
+
+inline bool operator!=(const geometry_msgs::Polygon &lhs, const geometry_msgs::Polygon &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif //POLYGON_H

geometry_msgs/include/geometry_msgs/PolygonStamped.h

@@ -16,6 +16,17 @@ struct PolygonStamped
     Polygon polygon;
 };
 
+inline bool operator==(const geometry_msgs::PolygonStamped &lhs, const geometry_msgs::PolygonStamped &rhs)
+{
+    return lhs.header == rhs.header &&
+        lhs.polygon == rhs.polygon;
+}
+
+inline bool operator!=(const geometry_msgs::PolygonStamped &lhs, const geometry_msgs::PolygonStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif //POLYGON_STAMPED_H

geometry_msgs/include/geometry_msgs/Pose.h

@@ -15,8 +15,23 @@ struct Pose
     Quaternion orientation;
 
     Pose() = default;
+    
+    Pose(Point position_, Quaternion orientation_)
+        : position(position_), orientation(orientation_) {};
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::Pose &lhs, const geometry_msgs::Pose &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // POSE_H

geometry_msgs/include/geometry_msgs/Pose2D.h

@@ -15,6 +15,8 @@
 #ifndef POSE2D_H
 #define POSE2D_H
 
+#include "utils.h"
+
 namespace geometry_msgs
 {
 
@@ -23,8 +25,25 @@ struct Pose2D
     double x;
     double y;
     double theta;
+
+    Pose2D() : x(0.0), y(0.0), theta(0.0) {}
+    Pose2D(double x_, double y_, double theta_)
+        : 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) &&
+        isEqual(lhs.theta, rhs.theta);
+}
+
+inline bool operator!=(const geometry_msgs::Pose2D &lhs, const geometry_msgs::Pose2D &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // POSE2D_H

geometry_msgs/include/geometry_msgs/PoseArray.h

@@ -23,6 +23,24 @@ struct PoseArray
     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++)
+    {
+        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)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // POSE_ARRAY_H

geometry_msgs/include/geometry_msgs/PoseStamped.h

@@ -20,6 +20,18 @@ struct PoseStamped
     PoseStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::PoseStamped &lhs, const geometry_msgs::PoseStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // POSE_STAMPED_H

geometry_msgs/include/geometry_msgs/PoseWithCovariance.h

@@ -23,9 +23,27 @@ struct PoseWithCovariance
     Pose pose;
     std::array<double, 36> covariance;
 
-    PoseWithCovariance() = default;
+    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;
+        }
+    }
+return lhs.pose == rhs.pose;
+}
+
+inline bool operator!=(const geometry_msgs::PoseWithCovariance &lhs, const geometry_msgs::PoseWithCovariance &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // POSE_WITH_COVARIANCE_H

geometry_msgs/include/geometry_msgs/PoseWithCovarianceStamped.h

@@ -22,6 +22,19 @@ struct PoseWithCovarianceStamped
     PoseWithCovarianceStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
+
 } // namespace geometry_msgs
 
 #endif // POSE_WITH_COVARIANCE_STAMPED_H

geometry_msgs/include/geometry_msgs/Quaternion.h

@@ -1,6 +1,8 @@
 #ifndef QUATERNION_H
 #define QUATERNION_H
 
+#include "utils.h"
+
 namespace geometry_msgs
 {
 
@@ -19,6 +21,20 @@ struct Quaternion
         : 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) &&
+        isEqual(lhs.z, rhs.z) &&
+        isEqual(lhs.w, rhs.w);
+}
+
+inline bool operator!=(const geometry_msgs::Quaternion &lhs, const geometry_msgs::Quaternion &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // QUATERNION_H

geometry_msgs/include/geometry_msgs/QuaternionStamped.h

@@ -20,6 +20,18 @@ struct QuaternionStamped
     QuaternionStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::QuaternionStamped &lhs, const geometry_msgs::QuaternionStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // QUATERNION_STAMPED_H

geometry_msgs/include/geometry_msgs/Transform.h

@@ -11,8 +11,25 @@ struct Transform
 {
     Vector3 translation;
     Quaternion rotation;
+
+    Transform() = default;
+    Transform(Vector3 translation_, Quaternion rotation_)
+        : translation(translation_), rotation(rotation_) {}
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::Transform &lhs, const geometry_msgs::Transform &rhs)
+{
+return !(lhs == rhs);
+}
+
+
 } // namespace geometry_msgs
 
 #endif // TRANSFORM_H

geometry_msgs/include/geometry_msgs/TransformStamped.h

@@ -15,6 +15,19 @@ struct TransformStamped
     Transform transform;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::TransformStamped &lhs, const geometry_msgs::TransformStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // TRANSFORM_STAMPED_H

geometry_msgs/include/geometry_msgs/Twist.h

@@ -23,6 +23,18 @@ struct Twist
         : linear(linear_), angular(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;
+}
+
+inline bool operator!=(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // ACCEL_H

geometry_msgs/include/geometry_msgs/TwistStamped.h

@@ -19,6 +19,18 @@ struct TwistStamped
     TwistStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::TwistStamped &lhs, const geometry_msgs::TwistStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // TWIST_STAMPED_H

geometry_msgs/include/geometry_msgs/TwistWithCovariance.h

@@ -23,9 +23,28 @@ struct TwistWithCovariance
     Twist twist;
     std::array<double, 36> covariance;
 
-    TwistWithCovariance() = default;
+    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)
+    {
+        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)
+{
+return !(lhs == rhs);
+}
+
+
 } // namespace geometry_msgs
 
 #endif // TWIST_WITH_COVARIANCE_H

geometry_msgs/include/geometry_msgs/TwistWithCovarianceStamped.h

@@ -6,7 +6,7 @@
 #define TWIST_WITH_COVARIANCE_STAMPED_H
 
 #include <std_msgs/Header.h>
-#include <geometry_msgs/PoseWithCovariance.h>
+#include <geometry_msgs/TwistWithCovariance.h>
 
 
 
@@ -21,6 +21,18 @@ struct TwistWithCovarianceStamped
     TwistWithCovarianceStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::TwistWithCovarianceStamped &lhs, const geometry_msgs::TwistWithCovarianceStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // TWIST_WITH_COVARIANCE_STAMPED_H

geometry_msgs/include/geometry_msgs/Vector3.h

@@ -1,6 +1,8 @@
 #ifndef VECTOR_3_H
 #define VECTOR_3_H
 
+#include "utils.h"
+
 namespace geometry_msgs
 {
 
@@ -18,6 +20,20 @@ struct Vector3
         : 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) &&
+        isEqual(lhs.z, rhs.z);
+}
+
+inline bool operator!=(const geometry_msgs::Vector3 &lhs, const geometry_msgs::Vector3 &rhs)
+{
+return !(lhs == rhs);
+}
+
+
 } // namespace geometry_msgs
 
 #endif // VECTOR_3_H

geometry_msgs/include/geometry_msgs/Vector3Stamped.h

@@ -19,6 +19,19 @@ struct Vector3Stamped
     Vector3Stamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::Vector3Stamped &lhs, const geometry_msgs::Vector3Stamped &rhs)
+{
+return !(lhs == rhs);
+}
+
+
 } // namespace geometry_msgs
 
 #endif // VECTOR_3_STAMPED_H

geometry_msgs/include/geometry_msgs/Wrench.h

@@ -17,8 +17,22 @@ struct Wrench
     Vector3  torque;
     // Constructor mặc định
     Wrench() = default;
+    
+    Wrench(Vector3 force_, Vector3 torque_) : force(force_), torque(torque_) {};
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::Wrench &lhs, const geometry_msgs::Wrench &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // WRENCH_H

geometry_msgs/include/geometry_msgs/WrenchStamped.h

@@ -19,6 +19,18 @@ struct WrenchStamped
     WrenchStamped() = default;
 };
 
+// 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;
+}
+
+inline bool operator!=(const geometry_msgs::WrenchStamped &lhs, const geometry_msgs::WrenchStamped &rhs)
+{
+return !(lhs == rhs);
+}
+
 } // namespace geometry_msgs
 
 #endif // WRENCH_STAMPED_H

map_msgs/include/map_msgs/OccupancyGridUpdate.h

@@ -8,12 +8,28 @@ namespace map_msgs
 struct OccupancyGridUpdate
 {
     std_msgs::Header header;  // Thời gian và frame của bản đồ cập nhật
-    int32_t x = 0;            // Tọa độ x của góc trên bên trái của vùng cập nhật trong bản đồ
-    int32_t y = 0;            // Tọa độ y của góc trên bên trái của vùng cập nhật trong bản đồ
-    uint32_t width = 0;       // Chiều rộng của vùng cập nhật
-    uint32_t height = 0;      // Chiều cao của vùng cập nhật
+    int32_t x;                // Tọa độ x của góc trên bên trái của vùng cập nhật trong bản đồ
+    int32_t y;                // Tọa độ y của góc trên bên trái của vùng cập nhật trong bản đồ
+    uint32_t width;           // Chiều rộng của vùng cập nhật
+    uint32_t height;          // Chiều cao của vùng cập nhật
     std::vector<int8_t> data; // Dữ liệu cập nhật của vùng (giá trị từ -1 đến 100, trong đó -1 là không biết, 0 là không có chướng ngại vật, và 100 là chướng ngại vật chắc chắn
     OccupancyGridUpdate() = default;
 };
+
+inline bool operator==(const map_msgs::OccupancyGridUpdate & lhs, const map_msgs::OccupancyGridUpdate & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.x == rhs.x &&
+    lhs.y == rhs.y &&
+    lhs.width == rhs.width &&
+    lhs.height == rhs.height &&
+    lhs.data == rhs.data;
+}
+
+
+inline bool operator!=(const map_msgs::OccupancyGridUpdate & lhs, const map_msgs::OccupancyGridUpdate & rhs)
+{
+  return !(lhs == rhs);
+}
 } // namespace map_msgs
 #endif

nav_msgs/include/nav_msgs/GetMap.h

@@ -0,0 +1,27 @@
+// Generated by gencpp from file nav_msgs/GetMap.msg
+// DO NOT EDIT!
+
+#ifndef NAV_MSGS_MESSAGE_GETMAP_H
+#define NAV_MSGS_MESSAGE_GETMAP_H
+
+#include <nav_msgs/GetMapRequest.h>
+#include <nav_msgs/GetMapResponse.h>
+
+namespace nav_msgs
+{
+
+  struct GetMap
+  {
+
+    typedef GetMapRequest Request;
+    typedef GetMapResponse Response;
+    Request request;
+    Response response;
+
+    typedef Request RequestType;
+    typedef Response ResponseType;
+
+  }; // struct GetMap
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAP_H

nav_msgs/include/nav_msgs/GetMapAction.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file nav_msgs/GetMapAction.msg
+// DO NOT EDIT!
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPACTION_H
+#define NAV_MSGS_MESSAGE_GETMAPACTION_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <nav_msgs/GetMapActionGoal.h>
+#include <nav_msgs/GetMapActionResult.h>
+#include <nav_msgs/GetMapActionFeedback.h>
+
+namespace nav_msgs
+{
+  template <class ContainerAllocator>
+  struct GetMapAction_
+  {
+    typedef GetMapAction_<ContainerAllocator> Type;
+
+    GetMapAction_()
+        : action_goal(), action_result(), action_feedback()
+    {
+    }
+    GetMapAction_(const ContainerAllocator &_alloc)
+        : action_goal(_alloc), action_result(_alloc), action_feedback(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::nav_msgs::GetMapActionGoal_<ContainerAllocator> _action_goal_type;
+    _action_goal_type action_goal;
+
+    typedef ::nav_msgs::GetMapActionResult_<ContainerAllocator> _action_result_type;
+    _action_result_type action_result;
+
+    typedef ::nav_msgs::GetMapActionFeedback_<ContainerAllocator> _action_feedback_type;
+    _action_feedback_type action_feedback;
+
+    typedef boost::shared_ptr<::nav_msgs::GetMapAction_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::nav_msgs::GetMapAction_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct GetMapAction_
+
+  typedef ::nav_msgs::GetMapAction_<std::allocator<void>> GetMapAction;
+
+  typedef boost::shared_ptr<::nav_msgs::GetMapAction> GetMapActionPtr;
+  typedef boost::shared_ptr<::nav_msgs::GetMapAction const> GetMapActionConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::nav_msgs::GetMapAction_<ContainerAllocator1> &lhs, const ::nav_msgs::GetMapAction_<ContainerAllocator2> &rhs)
+  {
+    return lhs.action_goal == rhs.action_goal &&
+           lhs.action_result == rhs.action_result &&
+           lhs.action_feedback == rhs.action_feedback;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::nav_msgs::GetMapAction_<ContainerAllocator1> &lhs, const ::nav_msgs::GetMapAction_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTION_H

nav_msgs/include/nav_msgs/GetMapActionFeedback.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file nav_msgs/GetMapActionFeedback.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H
+#define NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <actionlib_msgs/GoalStatus.h>
+#include <nav_msgs/GetMapFeedback.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionFeedback_
+{
+  typedef GetMapActionFeedback_<ContainerAllocator> Type;
+
+  GetMapActionFeedback_()
+    : header()
+    , status()
+    , feedback()  {
+    }
+  GetMapActionFeedback_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , status(_alloc)
+    , feedback(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::nav_msgs::GetMapFeedback_<ContainerAllocator>  _feedback_type;
+  _feedback_type feedback;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionFeedback_
+
+typedef ::nav_msgs::GetMapActionFeedback_<std::allocator<void> > GetMapActionFeedback;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionFeedback > GetMapActionFeedbackPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionFeedback const> GetMapActionFeedbackConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapActionFeedback_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionFeedback_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.status == rhs.status &&
+    lhs.feedback == rhs.feedback;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetMapActionFeedback_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionFeedback_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H

nav_msgs/include/nav_msgs/GetMapActionGoal.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file nav_msgs/GetMapActionGoal.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H
+#define NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <actionlib_msgs/GoalID.h>
+#include <nav_msgs/GetMapGoal.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionGoal_
+{
+  typedef GetMapActionGoal_<ContainerAllocator> Type;
+
+  GetMapActionGoal_()
+    : header()
+    , goal_id()
+    , goal()  {
+    }
+  GetMapActionGoal_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , goal_id(_alloc)
+    , goal(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalID_<ContainerAllocator>  _goal_id_type;
+  _goal_id_type goal_id;
+
+   typedef  ::nav_msgs::GetMapGoal_<ContainerAllocator>  _goal_type;
+  _goal_type goal;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionGoal_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionGoal_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionGoal_
+
+typedef ::nav_msgs::GetMapActionGoal_<std::allocator<void> > GetMapActionGoal;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionGoal > GetMapActionGoalPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionGoal const> GetMapActionGoalConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapActionGoal_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionGoal_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.goal_id == rhs.goal_id &&
+    lhs.goal == rhs.goal;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetMapActionGoal_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionGoal_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H

nav_msgs/include/nav_msgs/GetMapActionResult.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file nav_msgs/GetMapActionResult.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H
+#define NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <actionlib_msgs/GoalStatus.h>
+#include <nav_msgs/GetMapResult.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionResult_
+{
+  typedef GetMapActionResult_<ContainerAllocator> Type;
+
+  GetMapActionResult_()
+    : header()
+    , status()
+    , result()  {
+    }
+  GetMapActionResult_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , status(_alloc)
+    , result(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::nav_msgs::GetMapResult_<ContainerAllocator>  _result_type;
+  _result_type result;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionResult_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionResult_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionResult_
+
+typedef ::nav_msgs::GetMapActionResult_<std::allocator<void> > GetMapActionResult;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionResult > GetMapActionResultPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionResult const> GetMapActionResultConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapActionResult_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionResult_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.status == rhs.status &&
+    lhs.result == rhs.result;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetMapActionResult_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionResult_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H

nav_msgs/include/nav_msgs/GetMapFeedback.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file nav_msgs/GetMapFeedback.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H
+#define NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapFeedback_
+{
+  typedef GetMapFeedback_<ContainerAllocator> Type;
+
+  GetMapFeedback_()
+    {
+    }
+  GetMapFeedback_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapFeedback_
+
+typedef ::nav_msgs::GetMapFeedback_<std::allocator<void> > GetMapFeedback;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapFeedback > GetMapFeedbackPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapFeedback const> GetMapFeedbackConstPtr;
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H

nav_msgs/include/nav_msgs/GetMapGoal.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file nav_msgs/GetMapGoal.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPGOAL_H
+#define NAV_MSGS_MESSAGE_GETMAPGOAL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapGoal_
+{
+  typedef GetMapGoal_<ContainerAllocator> Type;
+
+  GetMapGoal_()
+    {
+    }
+  GetMapGoal_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapGoal_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapGoal_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapGoal_
+
+typedef ::nav_msgs::GetMapGoal_<std::allocator<void> > GetMapGoal;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapGoal > GetMapGoalPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapGoal const> GetMapGoalConstPtr;
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPGOAL_H

nav_msgs/include/nav_msgs/GetMapRequest.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file nav_msgs/GetMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPREQUEST_H
+#define NAV_MSGS_MESSAGE_GETMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapRequest_
+{
+  typedef GetMapRequest_<ContainerAllocator> Type;
+
+  GetMapRequest_()
+    {
+    }
+  GetMapRequest_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapRequest_
+
+typedef ::nav_msgs::GetMapRequest_<std::allocator<void> > GetMapRequest;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapRequest > GetMapRequestPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapRequest const> GetMapRequestConstPtr;
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPREQUEST_H

nav_msgs/include/nav_msgs/GetMapResponse.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file nav_msgs/GetMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPRESPONSE_H
+#define NAV_MSGS_MESSAGE_GETMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <nav_msgs/OccupancyGrid.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapResponse_
+{
+  typedef GetMapResponse_<ContainerAllocator> Type;
+
+  GetMapResponse_()
+    : map()  {
+    }
+  GetMapResponse_(const ContainerAllocator& _alloc)
+    : map(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapResponse_
+
+typedef ::nav_msgs::GetMapResponse_<std::allocator<void> > GetMapResponse;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapResponse > GetMapResponsePtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapResponse const> GetMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPRESPONSE_H

nav_msgs/include/nav_msgs/GetMapResult.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file nav_msgs/GetMapResult.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPRESULT_H
+#define NAV_MSGS_MESSAGE_GETMAPRESULT_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <nav_msgs/OccupancyGrid.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapResult_
+{
+  typedef GetMapResult_<ContainerAllocator> Type;
+
+  GetMapResult_()
+    : map()  {
+    }
+  GetMapResult_(const ContainerAllocator& _alloc)
+    : map(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapResult_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapResult_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapResult_
+
+typedef ::nav_msgs::GetMapResult_<std::allocator<void> > GetMapResult;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapResult > GetMapResultPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapResult const> GetMapResultConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapResult_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapResult_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetMapResult_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapResult_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPRESULT_H

nav_msgs/include/nav_msgs/GetPlan.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file nav_msgs/GetPlan.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETPLAN_H
+#define NAV_MSGS_MESSAGE_GETPLAN_H
+
+
+#include <nav_msgs/GetPlanRequest.h>
+#include <nav_msgs/GetPlanResponse.h>
+
+
+namespace nav_msgs
+{
+
+struct GetPlan
+{
+
+typedef GetPlanRequest Request;
+typedef GetPlanResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct GetPlan
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETPLAN_H

nav_msgs/include/nav_msgs/GetPlanRequest.h

@@ -0,0 +1,75 @@
+// Generated by gencpp from file nav_msgs/GetPlanRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETPLANREQUEST_H
+#define NAV_MSGS_MESSAGE_GETPLANREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <geometry_msgs/PoseStamped.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetPlanRequest_
+{
+  typedef GetPlanRequest_<ContainerAllocator> Type;
+
+  GetPlanRequest_()
+    : start()
+    , goal()
+    , tolerance(0.0)  {
+    }
+  GetPlanRequest_(const ContainerAllocator& _alloc)
+    : start(_alloc)
+    , goal(_alloc)
+    , tolerance(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::geometry_msgs::PoseStamped  _start_type;
+  _start_type start;
+
+   typedef  ::geometry_msgs::PoseStamped  _goal_type;
+  _goal_type goal;
+
+   typedef float _tolerance_type;
+  _tolerance_type tolerance;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetPlanRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetPlanRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetPlanRequest_
+
+typedef ::nav_msgs::GetPlanRequest_<std::allocator<void> > GetPlanRequest;
+
+typedef boost::shared_ptr< ::nav_msgs::GetPlanRequest > GetPlanRequestPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetPlanRequest const> GetPlanRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetPlanRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::GetPlanRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.start == rhs.start &&
+    lhs.goal == rhs.goal &&
+    lhs.tolerance == rhs.tolerance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetPlanRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::GetPlanRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETPLANREQUEST_H

nav_msgs/include/nav_msgs/GetPlanResponse.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file nav_msgs/GetPlanResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETPLANRESPONSE_H
+#define NAV_MSGS_MESSAGE_GETPLANRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <nav_msgs/Path.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetPlanResponse_
+{
+  typedef GetPlanResponse_<ContainerAllocator> Type;
+
+  GetPlanResponse_()
+    : plan()  {
+    }
+  GetPlanResponse_(const ContainerAllocator& _alloc)
+    : plan(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::nav_msgs::Path_<ContainerAllocator>  _plan_type;
+  _plan_type plan;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetPlanResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetPlanResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetPlanResponse_
+
+typedef ::nav_msgs::GetPlanResponse_<std::allocator<void> > GetPlanResponse;
+
+typedef boost::shared_ptr< ::nav_msgs::GetPlanResponse > GetPlanResponsePtr;
+typedef boost::shared_ptr< ::nav_msgs::GetPlanResponse const> GetPlanResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetPlanResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::GetPlanResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.plan == rhs.plan;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetPlanResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::GetPlanResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETPLANRESPONSE_H

nav_msgs/include/nav_msgs/GridCells.h

@@ -21,8 +21,27 @@ struct GridCells
     float cell_width;
     float cell_height;
     std::vector<geometry_msgs::Point> cells;
+    
+    GridCells() = default;
 };
 
+inline bool operator==(const nav_msgs::GridCells & lhs, const nav_msgs::GridCells & rhs)
+{
+    if(lhs.cells.size() != rhs.cells.size()) return false;
+    for(int i = 0; i < lhs.cells.size(); i++)
+    {
+        if(lhs.cells[i] != rhs.cells[i]) return false;
+    }
+  return lhs.header == rhs.header &&
+    isEqual(lhs.cell_width, rhs.cell_width) &&
+    isEqual(lhs.cell_height, rhs.cell_height);
+}
+
+inline bool operator!=(const nav_msgs::GridCells & lhs, const nav_msgs::GridCells & rhs)
+{
+  return !(lhs == rhs);
+}
+
 }
 
 #endif //GRID_CELLS_H

nav_msgs/include/nav_msgs/LoadMap.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file nav_msgs/LoadMap.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_LOADMAP_H
+#define NAV_MSGS_MESSAGE_LOADMAP_H
+
+
+#include <nav_msgs/LoadMapRequest.h>
+#include <nav_msgs/LoadMapResponse.h>
+
+
+namespace nav_msgs
+{
+
+struct LoadMap
+{
+
+typedef LoadMapRequest Request;
+typedef LoadMapResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct LoadMap
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_LOADMAP_H

nav_msgs/include/nav_msgs/LoadMapRequest.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file nav_msgs/LoadMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_LOADMAPREQUEST_H
+#define NAV_MSGS_MESSAGE_LOADMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct LoadMapRequest_
+{
+  typedef LoadMapRequest_<ContainerAllocator> Type;
+
+  LoadMapRequest_()
+    : map_url()  {
+    }
+  LoadMapRequest_(const ContainerAllocator& _alloc)
+    : map_url(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _map_url_type;
+  _map_url_type map_url;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::LoadMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::LoadMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LoadMapRequest_
+
+typedef ::nav_msgs::LoadMapRequest_<std::allocator<void> > LoadMapRequest;
+
+typedef boost::shared_ptr< ::nav_msgs::LoadMapRequest > LoadMapRequestPtr;
+typedef boost::shared_ptr< ::nav_msgs::LoadMapRequest const> LoadMapRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::LoadMapRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::LoadMapRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.map_url == rhs.map_url;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::LoadMapRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::LoadMapRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_LOADMAPREQUEST_H

nav_msgs/include/nav_msgs/LoadMapResponse.h

@@ -0,0 +1,94 @@
+// Generated by gencpp from file nav_msgs/LoadMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H
+#define NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <nav_msgs/OccupancyGrid.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct LoadMapResponse_
+{
+  typedef LoadMapResponse_<ContainerAllocator> Type;
+
+  LoadMapResponse_()
+    : map()
+    , result(0)  {
+    }
+  LoadMapResponse_(const ContainerAllocator& _alloc)
+    : map(_alloc)
+    , result(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+   typedef uint8_t _result_type;
+  _result_type result;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(RESULT_SUCCESS)
+  #undef RESULT_SUCCESS
+#endif
+#if defined(_WIN32) && defined(RESULT_MAP_DOES_NOT_EXIST)
+  #undef RESULT_MAP_DOES_NOT_EXIST
+#endif
+#if defined(_WIN32) && defined(RESULT_INVALID_MAP_DATA)
+  #undef RESULT_INVALID_MAP_DATA
+#endif
+#if defined(_WIN32) && defined(RESULT_INVALID_MAP_METADATA)
+  #undef RESULT_INVALID_MAP_METADATA
+#endif
+#if defined(_WIN32) && defined(RESULT_UNDEFINED_FAILURE)
+  #undef RESULT_UNDEFINED_FAILURE
+#endif
+
+  enum {
+    RESULT_SUCCESS = 0u,
+    RESULT_MAP_DOES_NOT_EXIST = 1u,
+    RESULT_INVALID_MAP_DATA = 2u,
+    RESULT_INVALID_MAP_METADATA = 3u,
+    RESULT_UNDEFINED_FAILURE = 255u,
+  };
+
+
+  typedef boost::shared_ptr< ::nav_msgs::LoadMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::LoadMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LoadMapResponse_
+
+typedef ::nav_msgs::LoadMapResponse_<std::allocator<void> > LoadMapResponse;
+
+typedef boost::shared_ptr< ::nav_msgs::LoadMapResponse > LoadMapResponsePtr;
+typedef boost::shared_ptr< ::nav_msgs::LoadMapResponse const> LoadMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::LoadMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::LoadMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map &&
+    lhs.result == rhs.result;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::LoadMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::LoadMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H

nav_msgs/include/nav_msgs/MapMetaData.h

@@ -5,6 +5,7 @@
 #include <string>
 #include <vector>
 #include "geometry_msgs/Pose.h"
+// #include "utils.h"
 
 namespace nav_msgs
 {
@@ -16,8 +17,24 @@ struct MapMetaData
     uint32_t width;
     uint32_t height;
     geometry_msgs::Pose origin;
+
+    MapMetaData() : map_load_time(0.0), resolution(0.0), width(0), height(0), origin() {}
 };
 
+inline bool operator==(const nav_msgs::MapMetaData & lhs, const nav_msgs::MapMetaData & rhs)
+{
+  return isEqual(lhs.map_load_time, rhs.map_load_time) &&
+    isEqual(lhs.resolution, rhs.resolution) &&
+    lhs.width == rhs.width &&
+    lhs.height == rhs.height &&
+    lhs.origin == rhs.origin;
+}
+
+inline bool operator!=(const nav_msgs::MapMetaData & lhs, const nav_msgs::MapMetaData & rhs)
+{
+  return !(lhs == rhs);
+}
+
 }
 
 #endif //MAP_META_DATA_H

nav_msgs/include/nav_msgs/OccupancyGrid.h

@@ -4,7 +4,7 @@
 #include <cstdint>
 #include <string>
 #include <vector>
-#include "std_msgs/Header.h"
+#include <std_msgs/Header.h>
 #include <nav_msgs/MapMetaData.h>
 
 namespace nav_msgs
@@ -17,8 +17,26 @@ std_msgs::Header header;
 MapMetaData info;
 
 std::vector<uint8_t> data;
+OccupancyGrid() = default;
 };
 
+inline bool operator==(const nav_msgs::OccupancyGrid & lhs, const nav_msgs::OccupancyGrid & rhs)
+{
+    if(lhs.data.size() != rhs.data.size()) return false;
+    for(int i = 0; i < lhs.data.size(); i++)
+    {
+        if(lhs.data[i] != rhs.data[i]) return false;
+    }
+  return lhs.header == rhs.header &&
+    lhs.info == rhs.info;
+
 }
 
+inline bool operator!=(const nav_msgs::OccupancyGrid & lhs, const nav_msgs::OccupancyGrid & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
 #endif //OCCUPANCY_GRID_H

nav_msgs/include/nav_msgs/Odometry.h

@@ -25,8 +25,24 @@ struct Odometry
     std::string child_frame_id;
     geometry_msgs::PoseWithCovariance pose;
     geometry_msgs::TwistWithCovariance twist;
+
+    Odometry() = default;
 };
 
+inline bool operator==(const nav_msgs::Odometry & lhs, const nav_msgs::Odometry & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.child_frame_id == rhs.child_frame_id &&
+    lhs.pose == rhs.pose &&
+    lhs.twist == rhs.twist;
+}
+
+inline bool operator!=(const nav_msgs::Odometry & lhs, const nav_msgs::Odometry & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
 }
 
 #endif //ODOMETRY_H

nav_msgs/include/nav_msgs/Path.h

@@ -17,8 +17,25 @@ struct Path
 {
     std_msgs::Header header;
     std::vector<geometry_msgs::PoseStamped> poses;
+
+    Path() = default;
 };
 
+bool operator==(const nav_msgs::Path & lhs, const nav_msgs::Path & rhs)
+{
+    if(lhs.poses.size() != rhs.poses.size()) return false;
+    for(int i = 0; i < lhs.poses.size(); i++)
+    {
+        if(lhs.poses[i] != rhs.poses[i]) return false;
+    }
+  return lhs.header == rhs.header;
+}
+
+bool operator!=(const nav_msgs::Path & lhs, const nav_msgs::Path & rhs)
+{
+  return !(lhs == rhs);
+}
+
 }
 
 #endif //PATH_H

nav_msgs/include/nav_msgs/SetMap.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file nav_msgs/SetMap.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_SETMAP_H
+#define NAV_MSGS_MESSAGE_SETMAP_H
+
+
+#include <nav_msgs/SetMapRequest.h>
+#include <nav_msgs/SetMapResponse.h>
+
+
+namespace nav_msgs
+{
+
+struct SetMap
+{
+
+typedef SetMapRequest Request;
+typedef SetMapResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct SetMap
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_SETMAP_H

nav_msgs/include/nav_msgs/SetMapRequest.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file nav_msgs/SetMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_SETMAPREQUEST_H
+#define NAV_MSGS_MESSAGE_SETMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <nav_msgs/OccupancyGrid.h>
+#include <geometry_msgs/PoseWithCovarianceStamped.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct SetMapRequest_
+{
+  typedef SetMapRequest_<ContainerAllocator> Type;
+
+  SetMapRequest_()
+    : map()
+    , initial_pose()  {
+    }
+  SetMapRequest_(const ContainerAllocator& _alloc)
+    : map(_alloc)
+    , initial_pose(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+   typedef  ::geometry_msgs::PoseWithCovarianceStamped  _initial_pose_type;
+  _initial_pose_type initial_pose;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::SetMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::SetMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetMapRequest_
+
+typedef ::nav_msgs::SetMapRequest_<std::allocator<void> > SetMapRequest;
+
+typedef boost::shared_ptr< ::nav_msgs::SetMapRequest > SetMapRequestPtr;
+typedef boost::shared_ptr< ::nav_msgs::SetMapRequest const> SetMapRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::SetMapRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::SetMapRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map &&
+    lhs.initial_pose == rhs.initial_pose;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::SetMapRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::SetMapRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_SETMAPREQUEST_H

nav_msgs/include/nav_msgs/SetMapResponse.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file nav_msgs/SetMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_SETMAPRESPONSE_H
+#define NAV_MSGS_MESSAGE_SETMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct SetMapResponse_
+{
+  typedef SetMapResponse_<ContainerAllocator> Type;
+
+  SetMapResponse_()
+    : success(false)  {
+    }
+  SetMapResponse_(const ContainerAllocator& _alloc)
+    : success(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _success_type;
+  _success_type success;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::SetMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::SetMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetMapResponse_
+
+typedef ::nav_msgs::SetMapResponse_<std::allocator<void> > SetMapResponse;
+
+typedef boost::shared_ptr< ::nav_msgs::SetMapResponse > SetMapResponsePtr;
+typedef boost::shared_ptr< ::nav_msgs::SetMapResponse const> SetMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::SetMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::SetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.success == rhs.success;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::SetMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::SetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_SETMAPRESPONSE_H

sensor_msgs/include/sensor_msgs/BatteryState.h

@@ -60,4 +60,29 @@ struct BatteryState
   std::string serial_number;
 };
 
+inline bool operator==(const sensor_msgs::BatteryState& lhs, const sensor_msgs::BatteryState& rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.voltage == rhs.voltage &&
+    lhs.temperature == rhs.temperature &&
+    lhs.current == rhs.current &&
+    lhs.charge == rhs.charge &&
+    lhs.capacity == rhs.capacity &&
+    lhs.design_capacity == rhs.design_capacity &&
+    lhs.percentage == rhs.percentage &&
+    lhs.power_supply_status == rhs.power_supply_status &&
+    lhs.power_supply_health == rhs.power_supply_health &&
+    lhs.power_supply_technology == rhs.power_supply_technology &&
+    lhs.present == rhs.present &&
+    lhs.cell_voltage == rhs.cell_voltage &&
+    lhs.cell_temperature == rhs.cell_temperature &&
+    lhs.location == rhs.location &&
+    lhs.serial_number == rhs.serial_number;
+}
+
+inline bool operator!=(const sensor_msgs::BatteryState& lhs, const sensor_msgs::BatteryState& rhs)
+{
+  return !(lhs == rhs);
+}
+
 }  // namespace sensor_msgs

std_msgs/include/std_msgs/Bool.h

@@ -0,0 +1,61 @@
+// Generated by gencpp from file std_msgs/Bool.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_BOOL_H
+#define STD_MSGS_MESSAGE_BOOL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+template <class ContainerAllocator>
+struct Bool_
+{
+  typedef Bool_<ContainerAllocator> Type;
+
+  Bool_()
+    : data(false)  {
+    }
+  Bool_(const ContainerAllocator& _alloc)
+    : data(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _data_type;
+  _data_type data;
+
+
+  typedef boost::shared_ptr< ::std_msgs::Bool_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::std_msgs::Bool_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Bool_
+
+typedef ::std_msgs::Bool_<std::allocator<void> > Bool;
+
+typedef boost::shared_ptr< ::std_msgs::Bool > BoolPtr;
+typedef boost::shared_ptr< ::std_msgs::Bool const> BoolConstPtr;
+
+// constants requiring out of line definition
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::std_msgs::Bool_<ContainerAllocator1> & lhs, const ::std_msgs::Bool_<ContainerAllocator2> & rhs)
+{
+  return lhs.data == rhs.data;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::std_msgs::Bool_<ContainerAllocator1> & lhs, const ::std_msgs::Bool_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_BOOL_H

std_msgs/include/std_msgs/Byte.h

@@ -0,0 +1,56 @@
+// Generated by gencpp from file std_msgs/Byte.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_BYTE_H
+#define STD_MSGS_MESSAGE_BYTE_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Byte_
+  {
+    typedef Byte_<ContainerAllocator> Type;
+
+    Byte_()
+        : data(0)
+    {
+    }
+    Byte_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef int8_t _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Byte_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Byte_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Byte_
+
+  typedef ::std_msgs::Byte_<std::allocator<void>> Byte;
+
+  typedef boost::shared_ptr<::std_msgs::Byte> BytePtr;
+  typedef boost::shared_ptr<::std_msgs::Byte const> ByteConstPtr;
+
+  // constants requiring out of line definition
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Byte_<ContainerAllocator1> &lhs, const ::std_msgs::Byte_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Byte_<ContainerAllocator1> &lhs, const ::std_msgs::Byte_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_BYTE_H

std_msgs/include/std_msgs/ByteMultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/ByteMultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_BYTEMULTIARRAY_H
+#define STD_MSGS_MESSAGE_BYTEMULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct ByteMultiArray_
+  {
+    typedef ByteMultiArray_<ContainerAllocator> Type;
+
+    ByteMultiArray_()
+        : layout(), data()
+    {
+    }
+    ByteMultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<int8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int8_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::ByteMultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::ByteMultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct ByteMultiArray_
+
+  typedef ::std_msgs::ByteMultiArray_<std::allocator<void>> ByteMultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::ByteMultiArray> ByteMultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::ByteMultiArray const> ByteMultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::ByteMultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::ByteMultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::ByteMultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::ByteMultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+#endif // STD_MSGS_MESSAGE_BYTEMULTIARRAY_H

std_msgs/include/std_msgs/Char.h

@@ -0,0 +1,56 @@
+// Generated by gencpp from file std_msgs/Char.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_CHAR_H
+#define STD_MSGS_MESSAGE_CHAR_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Char_
+  {
+    typedef Char_<ContainerAllocator> Type;
+
+    Char_()
+        : data(0)
+    {
+    }
+    Char_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef uint8_t _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Char_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Char_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Char_
+
+  typedef ::std_msgs::Char_<std::allocator<void>> Char;
+
+  typedef boost::shared_ptr<::std_msgs::Char> CharPtr;
+  typedef boost::shared_ptr<::std_msgs::Char const> CharConstPtr;
+
+  // constants requiring out of line definition
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Char_<ContainerAllocator1> &lhs, const ::std_msgs::Char_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Char_<ContainerAllocator1> &lhs, const ::std_msgs::Char_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_CHAR_H

std_msgs/include/std_msgs/ColorRGBA.h

@@ -0,0 +1,69 @@
+// Generated by gencpp from file std_msgs/ColorRGBA.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_COLORRGBA_H
+#define STD_MSGS_MESSAGE_COLORRGBA_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct ColorRGBA_
+  {
+    typedef ColorRGBA_<ContainerAllocator> Type;
+
+    ColorRGBA_()
+        : r(0.0), g(0.0), b(0.0), a(0.0)
+    {
+    }
+    ColorRGBA_(const ContainerAllocator &_alloc)
+        : r(0.0), g(0.0), b(0.0), a(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef float _r_type;
+    _r_type r;
+
+    typedef float _g_type;
+    _g_type g;
+
+    typedef float _b_type;
+    _b_type b;
+
+    typedef float _a_type;
+    _a_type a;
+
+    typedef boost::shared_ptr<::std_msgs::ColorRGBA_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::ColorRGBA_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct ColorRGBA_
+
+  typedef ::std_msgs::ColorRGBA_<std::allocator<void>> ColorRGBA;
+
+  typedef boost::shared_ptr<::std_msgs::ColorRGBA> ColorRGBAPtr;
+  typedef boost::shared_ptr<::std_msgs::ColorRGBA const> ColorRGBAConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::ColorRGBA_<ContainerAllocator1> &lhs, const ::std_msgs::ColorRGBA_<ContainerAllocator2> &rhs)
+  {
+    return lhs.r == rhs.r &&
+           lhs.g == rhs.g &&
+           lhs.b == rhs.b &&
+           lhs.a == rhs.a;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::ColorRGBA_<ContainerAllocator1> &lhs, const ::std_msgs::ColorRGBA_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_COLORRGBA_H

std_msgs/include/std_msgs/Duration.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file std_msgs/Duration.msg
+// DO NOT EDIT!
+
+
+#ifndef STD_MSGS_MESSAGE_DURATION_H
+#define STD_MSGS_MESSAGE_DURATION_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <robot/duration.h>
+
+namespace std_msgs
+{
+template <class ContainerAllocator>
+struct Duration_
+{
+  typedef Duration_<ContainerAllocator> Type;
+
+  Duration_()
+    : data()  {
+    }
+  Duration_(const ContainerAllocator& _alloc)
+    : data()  {
+  (void)_alloc;
+    }
+
+   typedef robot::Duration _data_type;
+  _data_type data;
+
+  typedef std::shared_ptr< ::std_msgs::Duration_<ContainerAllocator> > Ptr;
+  typedef std::shared_ptr< ::std_msgs::Duration_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Duration_
+
+typedef ::std_msgs::Duration_<std::allocator<void> > Duration;
+
+typedef std::shared_ptr< ::std_msgs::Duration > DurationPtr;
+typedef std::shared_ptr< ::std_msgs::Duration const> DurationConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::std_msgs::Duration_<ContainerAllocator1> & lhs, const ::std_msgs::Duration_<ContainerAllocator2> & rhs)
+{
+  return lhs.data == rhs.data;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::std_msgs::Duration_<ContainerAllocator1> & lhs, const ::std_msgs::Duration_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_DURATION_H

std_msgs/include/std_msgs/Empty.h

@@ -0,0 +1,40 @@
+// Generated by gencpp from file std_msgs/Empty.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_EMPTY_H
+#define STD_MSGS_MESSAGE_EMPTY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Empty_
+  {
+    typedef Empty_<ContainerAllocator> Type;
+
+    Empty_()
+    {
+    }
+    Empty_(const ContainerAllocator &_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef boost::shared_ptr<::std_msgs::Empty_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Empty_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Empty_
+
+  typedef ::std_msgs::Empty_<std::allocator<void>> Empty;
+
+  typedef boost::shared_ptr<::std_msgs::Empty> EmptyPtr;
+  typedef boost::shared_ptr<::std_msgs::Empty const> EmptyConstPtr;
+
+  // constants requiring out of line definition
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_EMPTY_H

std_msgs/include/std_msgs/Float32.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file std_msgs/Float32.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_FLOAT32_H
+#define STD_MSGS_MESSAGE_FLOAT32_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Float32_
+  {
+    typedef Float32_<ContainerAllocator> Type;
+
+    Float32_()
+        : data(0.0)
+    {
+    }
+    Float32_(const ContainerAllocator &_alloc)
+        : data(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef float _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Float32_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Float32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Float32_
+
+  typedef ::std_msgs::Float32_<std::allocator<void>> Float32;
+
+  typedef boost::shared_ptr<::std_msgs::Float32> Float32Ptr;
+  typedef boost::shared_ptr<::std_msgs::Float32 const> Float32ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Float32_<ContainerAllocator1> &lhs, const ::std_msgs::Float32_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Float32_<ContainerAllocator1> &lhs, const ::std_msgs::Float32_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_FLOAT32_H

std_msgs/include/std_msgs/Float32MultiArray.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file std_msgs/Float32MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H
+#define STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Float32MultiArray_
+  {
+    typedef Float32MultiArray_<ContainerAllocator> Type;
+
+    Float32MultiArray_()
+        : layout(), data()
+    {
+    }
+    Float32MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Float32MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Float32MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Float32MultiArray_
+
+  typedef ::std_msgs::Float32MultiArray_<std::allocator<void>> Float32MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::Float32MultiArray> Float32MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::Float32MultiArray const> Float32MultiArrayConstPtr;
+
+  // constants requiring out of line definition
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Float32MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Float32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Float32MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Float32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H

std_msgs/include/std_msgs/Float64.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file std_msgs/Float64.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_FLOAT64_H
+#define STD_MSGS_MESSAGE_FLOAT64_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Float64_
+  {
+    typedef Float64_<ContainerAllocator> Type;
+
+    Float64_()
+        : data(0.0)
+    {
+    }
+    Float64_(const ContainerAllocator &_alloc)
+        : data(0.0)
+    {
+      (void)_alloc;
+    }
+
+    typedef double _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Float64_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Float64_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Float64_
+
+  typedef ::std_msgs::Float64_<std::allocator<void>> Float64;
+
+  typedef boost::shared_ptr<::std_msgs::Float64> Float64Ptr;
+  typedef boost::shared_ptr<::std_msgs::Float64 const> Float64ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Float64_<ContainerAllocator1> &lhs, const ::std_msgs::Float64_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Float64_<ContainerAllocator1> &lhs, const ::std_msgs::Float64_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_FLOAT64_H

std_msgs/include/std_msgs/Float64MultiArray.h

@@ -0,0 +1,59 @@
+// Generated by gencpp from file std_msgs/Float64MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H
+#define STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Float64MultiArray_
+  {
+    typedef Float64MultiArray_<ContainerAllocator> Type;
+
+    Float64MultiArray_()
+        : layout(), data()
+    {
+    }
+    Float64MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Float64MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Float64MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Float64MultiArray_
+
+  typedef ::std_msgs::Float64MultiArray_<std::allocator<void>> Float64MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::Float64MultiArray> Float64MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::Float64MultiArray const> Float64MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Float64MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Float64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Float64MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Float64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+#endif // STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H

std_msgs/include/std_msgs/Header.h

@@ -9,24 +9,24 @@ namespace std_msgs {
 
 struct Header
 {
-  uint32_t seq = 0;  // số thứ tự message
-  robot::Time stamp = robot::Time(0); // thời gian theo giây (Unix time)
+  uint32_t seq;  // số thứ tự message
+  robot::Time stamp; // thời gian timestamp
   std::string frame_id;
 
-  Header() = default;
-
-  // Hàm tạo nhanh header với timestamp hiện tại
-  static Header now(const std::string& frame = "")
-  {
-    robot::Time time_now = robot::Time::now();
-    Header h;
-    h.seq = 0;
-    h.stamp = time_now;
-    h.frame_id = frame;
-    return h;
-  }
+  Header() : seq(0), stamp(robot::Time::now()), frame_id("") {}
 };
 
-}  // namespace std_msgs
+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;
+}
 
+inline bool operator!=(const std_msgs::Header &lhs, const std_msgs::Header &rhs)
+{
+  return !(lhs == rhs);
+}
+
+}  // namespace std_msgs
 #endif

std_msgs/include/std_msgs/Int16.h

@@ -0,0 +1,57 @@
+// Generated by gencpp from file std_msgs/Int16.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_INT16_H
+#define STD_MSGS_MESSAGE_INT16_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Int16_
+  {
+    typedef Int16_<ContainerAllocator> Type;
+
+    Int16_()
+        : data(0)
+    {
+    }
+    Int16_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef int16_t _data_type;
+    _data_type data;
+
+    typedef std::shared_ptr<::std_msgs::Int16_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::std_msgs::Int16_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int16_
+
+  typedef ::std_msgs::Int16_<std::allocator<void>> Int16;
+
+  typedef std::shared_ptr<::std_msgs::Int16> Int16Ptr;
+  typedef std::shared_ptr<::std_msgs::Int16 const> Int16ConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Int16_<ContainerAllocator1> &lhs, const ::std_msgs::Int16_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Int16_<ContainerAllocator1> &lhs, const ::std_msgs::Int16_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT16_H

std_msgs/include/std_msgs/Int16MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/Int16MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_INT16MULTIARRAY_H
+#define STD_MSGS_MESSAGE_INT16MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Int16MultiArray_
+  {
+    typedef Int16MultiArray_<ContainerAllocator> Type;
+
+    Int16MultiArray_()
+        : layout(), data()
+    {
+    }
+    Int16MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<int16_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int16_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Int16MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Int16MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int16MultiArray_
+
+  typedef ::std_msgs::Int16MultiArray_<std::allocator<void>> Int16MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::Int16MultiArray> Int16MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::Int16MultiArray const> Int16MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Int16MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Int16MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Int16MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Int16MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT16MULTIARRAY_H

std_msgs/include/std_msgs/Int32.h

@@ -0,0 +1,57 @@
+// Generated by gencpp from file std_msgs/Int32.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_INT32_H
+#define STD_MSGS_MESSAGE_INT32_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Int32_
+  {
+    typedef Int32_<ContainerAllocator> Type;
+
+    Int32_()
+        : data(0)
+    {
+    }
+    Int32_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef int32_t _data_type;
+    _data_type data;
+
+    typedef std::shared_ptr<::std_msgs::Int32_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::std_msgs::Int32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int32_
+
+  typedef ::std_msgs::Int32_<std::allocator<void>> Int32;
+
+  typedef std::shared_ptr<::std_msgs::Int32> Int32Ptr;
+  typedef std::shared_ptr<::std_msgs::Int32 const> Int32ConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Int32_<ContainerAllocator1> &lhs, const ::std_msgs::Int32_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Int32_<ContainerAllocator1> &lhs, const ::std_msgs::Int32_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT32_H

std_msgs/include/std_msgs/Int32MultiArray.h

@@ -0,0 +1,61 @@
+// Generated by gencpp from file std_msgs/Int32MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_INT32MULTIARRAY_H
+#define STD_MSGS_MESSAGE_INT32MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Int32MultiArray_
+  {
+    typedef Int32MultiArray_<ContainerAllocator> Type;
+
+    Int32MultiArray_()
+        : layout(), data()
+    {
+    }
+    Int32MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<int32_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int32_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Int32MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Int32MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int32MultiArray_
+
+  typedef ::std_msgs::Int32MultiArray_<std::allocator<void>> Int32MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::Int32MultiArray> Int32MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::Int32MultiArray const> Int32MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Int32MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Int32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Int32MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Int32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT32MULTIARRAY_H

std_msgs/include/std_msgs/Int64.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file std_msgs/Int64.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_INT64_H
+#define STD_MSGS_MESSAGE_INT64_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Int64_
+  {
+    typedef Int64_<ContainerAllocator> Type;
+
+    Int64_()
+        : data(0)
+    {
+    }
+    Int64_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef int64_t _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Int64_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Int64_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int64_
+
+  typedef ::std_msgs::Int64_<std::allocator<void>> Int64;
+
+  typedef boost::shared_ptr<::std_msgs::Int64> Int64Ptr;
+  typedef boost::shared_ptr<::std_msgs::Int64 const> Int64ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Int64_<ContainerAllocator1> &lhs, const ::std_msgs::Int64_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Int64_<ContainerAllocator1> &lhs, const ::std_msgs::Int64_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT64_H

std_msgs/include/std_msgs/Int64MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/Int64MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_INT64MULTIARRAY_H
+#define STD_MSGS_MESSAGE_INT64MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Int64MultiArray_
+  {
+    typedef Int64MultiArray_<ContainerAllocator> Type;
+
+    Int64MultiArray_()
+        : layout(), data()
+    {
+    }
+    Int64MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<int64_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int64_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Int64MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Int64MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int64MultiArray_
+
+  typedef ::std_msgs::Int64MultiArray_<std::allocator<void>> Int64MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::Int64MultiArray> Int64MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::Int64MultiArray const> Int64MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Int64MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Int64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Int64MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Int64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT64MULTIARRAY_H

std_msgs/include/std_msgs/Int8.h

@@ -0,0 +1,57 @@
+// Generated by gencpp from file std_msgs/Int8.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_INT8_H
+#define STD_MSGS_MESSAGE_INT8_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Int8_
+  {
+    typedef Int8_<ContainerAllocator> Type;
+
+    Int8_()
+        : data(0)
+    {
+    }
+    Int8_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef int8_t _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Int8_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Int8_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int8_
+
+  typedef ::std_msgs::Int8_<std::allocator<void>> Int8;
+
+  typedef boost::shared_ptr<::std_msgs::Int8> Int8Ptr;
+  typedef boost::shared_ptr<::std_msgs::Int8 const> Int8ConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Int8_<ContainerAllocator1> &lhs, const ::std_msgs::Int8_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Int8_<ContainerAllocator1> &lhs, const ::std_msgs::Int8_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT8_H

std_msgs/include/std_msgs/Int8MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/Int8MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_INT8MULTIARRAY_H
+#define STD_MSGS_MESSAGE_INT8MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Int8MultiArray_
+  {
+    typedef Int8MultiArray_<ContainerAllocator> Type;
+
+    Int8MultiArray_()
+        : layout(), data()
+    {
+    }
+    Int8MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<int8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int8_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::Int8MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::Int8MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int8MultiArray_
+
+  typedef ::std_msgs::Int8MultiArray_<std::allocator<void>> Int8MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::Int8MultiArray> Int8MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::Int8MultiArray const> Int8MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Int8MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Int8MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Int8MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::Int8MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT8MULTIARRAY_H

std_msgs/include/std_msgs/MultiArrayDimension.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file std_msgs/MultiArrayDimension.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H
+#define STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct MultiArrayDimension_
+  {
+    typedef MultiArrayDimension_<ContainerAllocator> Type;
+
+    MultiArrayDimension_()
+        : label(), size(0), stride(0)
+    {
+    }
+    MultiArrayDimension_(const ContainerAllocator &_alloc)
+        : label(_alloc), size(0), stride(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _label_type;
+    _label_type label;
+
+    typedef uint32_t _size_type;
+    _size_type size;
+
+    typedef uint32_t _stride_type;
+    _stride_type stride;
+
+    typedef boost::shared_ptr<::std_msgs::MultiArrayDimension_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::MultiArrayDimension_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct MultiArrayDimension_
+
+  typedef ::std_msgs::MultiArrayDimension_<std::allocator<void>> MultiArrayDimension;
+
+  typedef boost::shared_ptr<::std_msgs::MultiArrayDimension> MultiArrayDimensionPtr;
+  typedef boost::shared_ptr<::std_msgs::MultiArrayDimension const> MultiArrayDimensionConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::MultiArrayDimension_<ContainerAllocator1> &lhs, const ::std_msgs::MultiArrayDimension_<ContainerAllocator2> &rhs)
+  {
+    return lhs.label == rhs.label &&
+           lhs.size == rhs.size &&
+           lhs.stride == rhs.stride;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::MultiArrayDimension_<ContainerAllocator1> &lhs, const ::std_msgs::MultiArrayDimension_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H

std_msgs/include/std_msgs/MultiArrayLayout.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/MultiArrayLayout.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H
+#define STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayDimension.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct MultiArrayLayout_
+  {
+    typedef MultiArrayLayout_<ContainerAllocator> Type;
+
+    MultiArrayLayout_()
+        : dim(), data_offset(0)
+    {
+    }
+    MultiArrayLayout_(const ContainerAllocator &_alloc)
+        : dim(_alloc), data_offset(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef std::vector<::std_msgs::MultiArrayDimension_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::std_msgs::MultiArrayDimension_<ContainerAllocator>>> _dim_type;
+    _dim_type dim;
+
+    typedef uint32_t _data_offset_type;
+    _data_offset_type data_offset;
+
+    typedef boost::shared_ptr<::std_msgs::MultiArrayLayout_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::MultiArrayLayout_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct MultiArrayLayout_
+
+  typedef ::std_msgs::MultiArrayLayout_<std::allocator<void>> MultiArrayLayout;
+
+  typedef boost::shared_ptr<::std_msgs::MultiArrayLayout> MultiArrayLayoutPtr;
+  typedef boost::shared_ptr<::std_msgs::MultiArrayLayout const> MultiArrayLayoutConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::MultiArrayLayout_<ContainerAllocator1> &lhs, const ::std_msgs::MultiArrayLayout_<ContainerAllocator2> &rhs)
+  {
+    return lhs.dim == rhs.dim &&
+           lhs.data_offset == rhs.data_offset;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::MultiArrayLayout_<ContainerAllocator1> &lhs, const ::std_msgs::MultiArrayLayout_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H

std_msgs/include/std_msgs/String.h

@@ -0,0 +1,57 @@
+// Generated by gencpp from file std_msgs/String.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_STRING_H
+#define STD_MSGS_MESSAGE_STRING_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct String_
+  {
+    typedef String_<ContainerAllocator> Type;
+
+    String_()
+        : data()
+    {
+    }
+    String_(const ContainerAllocator &_alloc)
+        : data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _data_type;
+    _data_type data;
+
+    typedef std::shared_ptr<::std_msgs::String_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::std_msgs::String_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct String_
+
+  typedef ::std_msgs::String_<std::allocator<void>> String;
+
+  typedef std::shared_ptr<::std_msgs::String> StringPtr;
+  typedef std::shared_ptr<::std_msgs::String const> StringConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::String_<ContainerAllocator1> &lhs, const ::std_msgs::String_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::String_<ContainerAllocator1> &lhs, const ::std_msgs::String_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_STRING_H

std_msgs/include/std_msgs/Time.h

@@ -0,0 +1,59 @@
+// Generated by gencpp from file std_msgs/Time.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_TIME_H
+#define STD_MSGS_MESSAGE_TIME_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include <robot/time.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct Time_
+  {
+    typedef Time_<ContainerAllocator> Type;
+
+    Time_()
+        : data()
+    {
+    }
+    Time_(const ContainerAllocator &_alloc)
+        : data()
+    {
+      (void)_alloc;
+    }
+
+    typedef robot::Time _data_type;
+    _data_type data;
+
+    typedef std::shared_ptr<::std_msgs::Time_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::std_msgs::Time_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Time_
+
+  typedef ::std_msgs::Time_<std::allocator<void>> Time;
+
+  typedef std::shared_ptr<::std_msgs::Time> TimePtr;
+  typedef std::shared_ptr<::std_msgs::Time const> TimeConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::Time_<ContainerAllocator1> &lhs, const ::std_msgs::Time_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::Time_<ContainerAllocator1> &lhs, const ::std_msgs::Time_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_TIME_H

std_msgs/include/std_msgs/UInt16.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file std_msgs/UInt16.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_UINT16_H
+#define STD_MSGS_MESSAGE_UINT16_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct UInt16_
+  {
+    typedef UInt16_<ContainerAllocator> Type;
+
+    UInt16_()
+        : data(0)
+    {
+    }
+    UInt16_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef uint16_t _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::UInt16_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::UInt16_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt16_
+
+  typedef ::std_msgs::UInt16_<std::allocator<void>> UInt16;
+
+  typedef boost::shared_ptr<::std_msgs::UInt16> UInt16Ptr;
+  typedef boost::shared_ptr<::std_msgs::UInt16 const> UInt16ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::UInt16_<ContainerAllocator1> &lhs, const ::std_msgs::UInt16_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::UInt16_<ContainerAllocator1> &lhs, const ::std_msgs::UInt16_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT16_H

std_msgs/include/std_msgs/UInt16MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/UInt16MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_UINT16MULTIARRAY_H
+#define STD_MSGS_MESSAGE_UINT16MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct UInt16MultiArray_
+  {
+    typedef UInt16MultiArray_<ContainerAllocator> Type;
+
+    UInt16MultiArray_()
+        : layout(), data()
+    {
+    }
+    UInt16MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<uint16_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint16_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::UInt16MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::UInt16MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt16MultiArray_
+
+  typedef ::std_msgs::UInt16MultiArray_<std::allocator<void>> UInt16MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::UInt16MultiArray> UInt16MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::UInt16MultiArray const> UInt16MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::UInt16MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::UInt16MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::UInt16MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::UInt16MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT16MULTIARRAY_H

std_msgs/include/std_msgs/UInt32.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file std_msgs/UInt32.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_UINT32_H
+#define STD_MSGS_MESSAGE_UINT32_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct UInt32_
+  {
+    typedef UInt32_<ContainerAllocator> Type;
+
+    UInt32_()
+        : data(0)
+    {
+    }
+    UInt32_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef uint32_t _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::UInt32_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::UInt32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt32_
+
+  typedef ::std_msgs::UInt32_<std::allocator<void>> UInt32;
+
+  typedef boost::shared_ptr<::std_msgs::UInt32> UInt32Ptr;
+  typedef boost::shared_ptr<::std_msgs::UInt32 const> UInt32ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::UInt32_<ContainerAllocator1> &lhs, const ::std_msgs::UInt32_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::UInt32_<ContainerAllocator1> &lhs, const ::std_msgs::UInt32_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT32_H

std_msgs/include/std_msgs/UInt32MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/UInt32MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_UINT32MULTIARRAY_H
+#define STD_MSGS_MESSAGE_UINT32MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct UInt32MultiArray_
+  {
+    typedef UInt32MultiArray_<ContainerAllocator> Type;
+
+    UInt32MultiArray_()
+        : layout(), data()
+    {
+    }
+    UInt32MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<uint32_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint32_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::UInt32MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::UInt32MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt32MultiArray_
+
+  typedef ::std_msgs::UInt32MultiArray_<std::allocator<void>> UInt32MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::UInt32MultiArray> UInt32MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::UInt32MultiArray const> UInt32MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::UInt32MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::UInt32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::UInt32MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::UInt32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT32MULTIARRAY_H

std_msgs/include/std_msgs/UInt64.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file std_msgs/UInt64.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_UINT64_H
+#define STD_MSGS_MESSAGE_UINT64_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct UInt64_
+  {
+    typedef UInt64_<ContainerAllocator> Type;
+
+    UInt64_()
+        : data(0)
+    {
+    }
+    UInt64_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef uint64_t _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::UInt64_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::UInt64_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt64_
+
+  typedef ::std_msgs::UInt64_<std::allocator<void>> UInt64;
+
+  typedef boost::shared_ptr<::std_msgs::UInt64> UInt64Ptr;
+  typedef boost::shared_ptr<::std_msgs::UInt64 const> UInt64ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::UInt64_<ContainerAllocator1> &lhs, const ::std_msgs::UInt64_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::UInt64_<ContainerAllocator1> &lhs, const ::std_msgs::UInt64_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT64_H

std_msgs/include/std_msgs/UInt64MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/UInt64MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_UINT64MULTIARRAY_H
+#define STD_MSGS_MESSAGE_UINT64MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct UInt64MultiArray_
+  {
+    typedef UInt64MultiArray_<ContainerAllocator> Type;
+
+    UInt64MultiArray_()
+        : layout(), data()
+    {
+    }
+    UInt64MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<uint64_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint64_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::UInt64MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::UInt64MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt64MultiArray_
+
+  typedef ::std_msgs::UInt64MultiArray_<std::allocator<void>> UInt64MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::UInt64MultiArray> UInt64MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::UInt64MultiArray const> UInt64MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::UInt64MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::UInt64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::UInt64MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::UInt64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT64MULTIARRAY_H

std_msgs/include/std_msgs/UInt8.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file std_msgs/UInt8.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_UINT8_H
+#define STD_MSGS_MESSAGE_UINT8_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct UInt8_
+  {
+    typedef UInt8_<ContainerAllocator> Type;
+
+    UInt8_()
+        : data(0)
+    {
+    }
+    UInt8_(const ContainerAllocator &_alloc)
+        : data(0)
+    {
+      (void)_alloc;
+    }
+
+    typedef uint8_t _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::UInt8_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::UInt8_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt8_
+
+  typedef ::std_msgs::UInt8_<std::allocator<void>> UInt8;
+
+  typedef boost::shared_ptr<::std_msgs::UInt8> UInt8Ptr;
+  typedef boost::shared_ptr<::std_msgs::UInt8 const> UInt8ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::UInt8_<ContainerAllocator1> &lhs, const ::std_msgs::UInt8_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::UInt8_<ContainerAllocator1> &lhs, const ::std_msgs::UInt8_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT8_H

std_msgs/include/std_msgs/UInt8MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file std_msgs/UInt8MultiArray.msg
+// DO NOT EDIT!
+
+#ifndef STD_MSGS_MESSAGE_UINT8MULTIARRAY_H
+#define STD_MSGS_MESSAGE_UINT8MULTIARRAY_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <std_msgs/MultiArrayLayout.h>
+
+namespace std_msgs
+{
+  template <class ContainerAllocator>
+  struct UInt8MultiArray_
+  {
+    typedef UInt8MultiArray_<ContainerAllocator> Type;
+
+    UInt8MultiArray_()
+        : layout(), data()
+    {
+    }
+    UInt8MultiArray_(const ContainerAllocator &_alloc)
+        : layout(_alloc), data(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
+    _layout_type layout;
+
+    typedef std::vector<uint8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>> _data_type;
+    _data_type data;
+
+    typedef boost::shared_ptr<::std_msgs::UInt8MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::std_msgs::UInt8MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt8MultiArray_
+
+  typedef ::std_msgs::UInt8MultiArray_<std::allocator<void>> UInt8MultiArray;
+
+  typedef boost::shared_ptr<::std_msgs::UInt8MultiArray> UInt8MultiArrayPtr;
+  typedef boost::shared_ptr<::std_msgs::UInt8MultiArray const> UInt8MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::std_msgs::UInt8MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::UInt8MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::std_msgs::UInt8MultiArray_<ContainerAllocator1> &lhs, const ::std_msgs::UInt8MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT8MULTIARRAY_H

utils/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required(VERSION 3.10)
+
+# --- Project riêng cho utils ---
+project(utils LANGUAGES CXX)
+
+# --- Tạo INTERFACE library (header-only) ---
+add_library(utils INTERFACE)
+
+# --- Include directories ---
+target_include_directories(utils
+    INTERFACE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>   # build nội bộ
+        $<INSTALL_INTERFACE:include/utils>             # dùng khi install/export
+)
+
+# --- Cài đặt header files ---
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/
+        DESTINATION include/utils
+        FILES_MATCHING PATTERN "*.h"
+)
+
+# --- Cài đặt target INTERFACE để export ---
+install(TARGETS utils
+        EXPORT utils-targets
+)
+
+# --- Export target file ---
+install(EXPORT utils-targets
+        FILE utils-targets.cmake
+        NAMESPACE utils::
+        DESTINATION lib/cmake/utils
+)

utils/utils.h

@@ -0,0 +1,11 @@
+#ifndef UTILIS_MSGS_H
+#define UTILIS_MSGS_H
+#include <cmath>
+
+template <typename T>
+bool isEqual(const T& a, const T& b, double eps = 1e-5)
+{
+    return std::fabs(a - b) < eps;
+}
+
+#endif // UTILIS_MSGS_H