DuongTD/common_msgs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

HiepLM

Browse Source
This commit is contained in:
HiepLM 2025-12-05 11:30:39 +07:00
parent 2c40e67e32
commit e941fec3f8
31 changed files with 1738 additions and 809 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

206
geometry_msgs/include/geometry_msgs/Accel.h
View File

@ -1,36 +1,67 @@
// # This expresses acceleration in free space broken into its linear and angular parts.
// Vector3 linear
// Vector3 angular
// Generated by gencpp from file geometry_msgs/Accel.msg
// DO NOT EDIT!
#ifndef ACCEL_H
#define ACCEL_H
#ifndef GEOMETRY_MSGS_MESSAGE_ACCEL_H
#define GEOMETRY_MSGS_MESSAGE_ACCEL_H
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <geometry_msgs/Vector3.h>
#include <geometry_msgs/Vector3.h>
namespace geometry_msgs
{
struct Accel
template <class ContainerAllocator>
struct Accel_
{
Vector3 linear;
Vector3 angular;
typedef Accel_<ContainerAllocator> Type;
// Constructor mặc định
Accel() : linear(), angular() {}
Accel_()
: linear()
, angular() {
}
Accel_(const ContainerAllocator& _alloc)
: linear(_alloc)
, angular(_alloc) {
(void)_alloc;
}
// Constructor khởi tạo nhanh
Accel(const Vector3& linear_, const Vector3& angular_)
: linear(linear_), angular(angular_) {}
};
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Accel &lhs, const geometry_msgs::Accel &rhs)
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _linear_type;
_linear_type linear;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _angular_type;
_angular_type angular;
typedef boost::shared_ptr< ::geometry_msgs::Accel_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Accel_<ContainerAllocator> const> ConstPtr;
}; // struct Accel_
typedef ::geometry_msgs::Accel_<std::allocator<void> > Accel;
typedef boost::shared_ptr< ::geometry_msgs::Accel > AccelPtr;
typedef boost::shared_ptr< ::geometry_msgs::Accel const> AccelConstPtr;
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::geometry_msgs::Accel_<ContainerAllocator2> & rhs)
{
return lhs.linear == rhs.linear &&
lhs.angular == rhs.angular;
}
inline bool operator!=(const geometry_msgs::Accel &lhs, const geometry_msgs::Accel &rhs)
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::geometry_msgs::Accel_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
@ -38,4 +69,141 @@ return !(lhs == rhs);
} // namespace geometry_msgs
#endif // ACCEL_H
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Accel_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Accel_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Accel_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Accel_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Accel_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Accel_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Accel_<ContainerAllocator> >
{
static const char* value()
{
return "9f195f881246fdfa2798d1d3eebca84a";
}
static const char* value(const ::geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x9f195f881246fdfaULL;
static const uint64_t static_value2 = 0x2798d1d3eebca84aULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Accel_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Accel";
}
static const char* value(const ::geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Accel_<ContainerAllocator> >
{
static const char* value()
{
return "# This expresses acceleration in free space broken into its linear and angular parts.\n"
"Vector3 linear\n"
"Vector3 angular\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Vector3\n"
"# This represents a vector in free space. \n"
"# It is only meant to represent a direction. Therefore, it does not\n"
"# make sense to apply a translation to it (e.g., when applying a \n"
"# generic rigid transformation to a Vector3, tf2 will only apply the\n"
"# rotation). If you want your data to be translatable too, use the\n"
"# geometry_msgs/Point message instead.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
;
}
static const char* value(const ::geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Accel_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.linear);
stream.next(m.angular);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Accel_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Accel_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Accel_<ContainerAllocator>& v)
{
if (false || !indent.empty())
s << std::endl;
s << indent << "linear: ";
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.linear);
if (true || !indent.empty())
s << std::endl;
s << indent << "angular: ";
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.angular);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_ACCEL_H

59
geometry_msgs/include/geometry_msgs/AccelStamped.h
View File

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

80
geometry_msgs/include/geometry_msgs/AccelWithCovariance.h
View File

@ -1,49 +1,65 @@
// # This expresses acceleration in free space with uncertainty.
// Generated by gencpp from file geometry_msgs/AccelWithCovariance.msg
// DO NOT EDIT!
// Accel accel
#ifndef GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H
#define GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H
// # Row-major representation of the 6x6 covariance matrix
// # The orientation parameters use a fixed-axis representation.
// # In order, the parameters are:
// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
// float64[36] covariance
#ifndef ACCEL_WITH_COVARIANCE_H
#define ACCEL_WITH_COVARIANCE_H
#include <array>
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <boost/array.hpp>
#include <geometry_msgs/Accel.h>
namespace geometry_msgs
{
struct AccelWithCovariance
template <class ContainerAllocator>
struct AccelWithCovariance_
{
Accel accel;
std::array<double, 36> covariance;
// Constructor mặc định
AccelWithCovariance() : accel(), covariance{{0.0}} {};
};
typedef AccelWithCovariance_<ContainerAllocator> Type;
AccelWithCovariance_()
: accel(), covariance()
{
covariance.assign(0.0);
}
AccelWithCovariance_(const ContainerAllocator &_alloc)
: accel(_alloc), covariance()
{
(void)_alloc;
covariance.assign(0.0);
}
typedef ::geometry_msgs::Accel_<ContainerAllocator> _accel_type;
_accel_type accel;
typedef boost::array<double, 36> _covariance_type;
_covariance_type covariance;
typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance_<ContainerAllocator>> Ptr;
typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance_<ContainerAllocator> const> ConstPtr;
}; // struct AccelWithCovariance_
typedef ::geometry_msgs::AccelWithCovariance_<std::allocator<void>> AccelWithCovariance;
typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance> AccelWithCovariancePtr;
typedef boost::shared_ptr<::geometry_msgs::AccelWithCovariance const> AccelWithCovarianceConstPtr;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::AccelWithCovariance &lhs, const geometry_msgs::AccelWithCovariance &rhs)
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator2> &rhs)
{
for(size_t i = 0; i < 36; ++i)
{
if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
{
return false;
}
}
return lhs.accel == rhs.accel;
return lhs.accel == rhs.accel &&
lhs.covariance == rhs.covariance;
}
inline bool operator!=(const geometry_msgs::AccelWithCovariance &lhs, const geometry_msgs::AccelWithCovariance &rhs)
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator2> &rhs)
{
return !(lhs == rhs);
}
} // namespace geometry_msgs
#endif // ACCEL_WITH_COVARIANCE_H
#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H

60
geometry_msgs/include/geometry_msgs/AccelWithCovarianceStamped.h
View File

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

117
geometry_msgs/include/geometry_msgs/Inertia.h
View File

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

58
geometry_msgs/include/geometry_msgs/InertiaStamped.h
View File

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

78
geometry_msgs/include/geometry_msgs/Point.h
View File

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

70
geometry_msgs/include/geometry_msgs/Point32.h
View File

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

65
geometry_msgs/include/geometry_msgs/PointStamped.h
View File

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

61
geometry_msgs/include/geometry_msgs/Polygon.h
View File

@ -1,33 +1,60 @@
#ifndef POLYGON_H
#define POLYGON_H
// Generated by gencpp from file geometry_msgs/Polygon.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_POLYGON_H
#define GEOMETRY_MSGS_MESSAGE_POLYGON_H
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <geometry_msgs/Point32.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Polygon_
{
typedef Polygon_<ContainerAllocator> Type;
struct Polygon
Polygon_()
: points()
{
std::vector<geometry_msgs::Point32> points;
};
inline bool operator==(const geometry_msgs::Polygon &lhs, const geometry_msgs::Polygon &rhs)
{
if(lhs.points.size() != rhs.points.size())
return false;
for(int i = 0; i < lhs.points.size(); i++)
{
if(!(lhs.points[i] == rhs.points[i]))
return false;
}
return true;
Polygon_(const ContainerAllocator &_alloc)
: points(_alloc)
{
(void)_alloc;
}
inline bool operator!=(const geometry_msgs::Polygon &lhs, const geometry_msgs::Polygon &rhs)
typedef std::vector<::geometry_msgs::Point32_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::geometry_msgs::Point32_<ContainerAllocator>>> _points_type;
_points_type points;
typedef boost::shared_ptr<::geometry_msgs::Polygon_<ContainerAllocator>> Ptr;
typedef boost::shared_ptr<::geometry_msgs::Polygon_<ContainerAllocator> const> ConstPtr;
}; // struct Polygon_
typedef ::geometry_msgs::Polygon_<std::allocator<void>> Polygon;
typedef boost::shared_ptr<::geometry_msgs::Polygon> PolygonPtr;
typedef boost::shared_ptr<::geometry_msgs::Polygon const> PolygonConstPtr;
// constants requiring out of line definition
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::geometry_msgs::Polygon_<ContainerAllocator1> &lhs, const ::geometry_msgs::Polygon_<ContainerAllocator2> &rhs)
{
return lhs.points == rhs.points;
}
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::Polygon_<ContainerAllocator1> &lhs, const ::geometry_msgs::Polygon_<ContainerAllocator2> &rhs)
{
return !(lhs == rhs);
}
} // namespace geometry_msgs
#endif //POLYGON_H
#endif // GEOMETRY_MSGS_MESSAGE_POLYGON_H

59
geometry_msgs/include/geometry_msgs/PolygonStamped.h
View File

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

59
geometry_msgs/include/geometry_msgs/Pose.h
View File

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

84
geometry_msgs/include/geometry_msgs/Pose2D.h
View File

@ -1,50 +1,66 @@
// # Deprecated
// # Please use the full 3D pose.
// Generated by gencpp from file geometry_msgs/Pose2D.msg
// DO NOT EDIT!
// # In general our recommendation is to use a full 3D representation of everything and for 2D specific applications make the appropriate projections into the plane for their calculations but optimally will preserve the 3D information during processing.
#ifndef GEOMETRY_MSGS_MESSAGE_POSE2D_H
#define GEOMETRY_MSGS_MESSAGE_POSE2D_H
// # If we have parallel copies of 2D datatypes every UI and other pipeline will end up needing to have dual interfaces to plot everything. And you will end up with not being able to use 3D tools for 2D use cases even if they're completely valid, as you'd have to reimplement it with different inputs and outputs. It's not particularly hard to plot the 2D pose or compute the yaw error for the Pose message and there are already tools and libraries that can do this for you.
// # This expresses a position and orientation on a 2D manifold.
// float64 x
// float64 y
// float64 theta
#ifndef POSE2D_H
#define POSE2D_H
#include "utils.h"
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
namespace geometry_msgs
{
struct Pose2D
template <class ContainerAllocator>
struct Pose2D_
{
double x;
double y;
double theta;
typedef Pose2D_<ContainerAllocator> Type;
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)
Pose2D_()
: x(0.0), y(0.0), theta(0.0)
{
return isEqual(lhs.x, rhs.x) &&
isEqual(lhs.y, rhs.y) &&
isEqual(lhs.theta, rhs.theta);
}
Pose2D_(const ContainerAllocator &_alloc)
: x(0.0), y(0.0), theta(0.0)
{
(void)_alloc;
}
inline bool operator!=(const geometry_msgs::Pose2D &lhs, const geometry_msgs::Pose2D &rhs)
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _theta_type;
_theta_type theta;
typedef boost::shared_ptr<::geometry_msgs::Pose2D_<ContainerAllocator>> Ptr;
typedef boost::shared_ptr<::geometry_msgs::Pose2D_<ContainerAllocator> const> ConstPtr;
}; // struct Pose2D_
typedef ::geometry_msgs::Pose2D_<std::allocator<void>> Pose2D;
typedef boost::shared_ptr<::geometry_msgs::Pose2D> Pose2DPtr;
typedef boost::shared_ptr<::geometry_msgs::Pose2D const> Pose2DConstPtr;
// constants requiring out of line definition
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::geometry_msgs::Pose2D_<ContainerAllocator1> &lhs, const ::geometry_msgs::Pose2D_<ContainerAllocator2> &rhs)
{
return lhs.x == rhs.x &&
lhs.y == rhs.y &&
lhs.theta == rhs.theta;
}
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::Pose2D_<ContainerAllocator1> &lhs, const ::geometry_msgs::Pose2D_<ContainerAllocator2> &rhs)
{
return !(lhs == rhs);
}
} // namespace geometry_msgs
#endif // POSE2D_H
#endif // GEOMETRY_MSGS_MESSAGE_POSE2D_H

69
geometry_msgs/include/geometry_msgs/PoseArray.h
View File

@ -1,46 +1,65 @@
// # An array of poses with a header for global reference.
// Generated by gencpp from file geometry_msgs/PoseArray.msg
// DO NOT EDIT!
// Header header
// Pose[] poses
#ifndef POSE_ARRAY_H
#define POSE_ARRAY_H
#ifndef GEOMETRY_MSGS_MESSAGE_POSEARRAY_H
#define GEOMETRY_MSGS_MESSAGE_POSEARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <std_msgs/Header.h>
#include <geometry_msgs/Pose.h>
namespace geometry_msgs
{
struct PoseArray
template <class ContainerAllocator>
struct PoseArray_
{
std_msgs::Header header;
std::vector<Pose> poses;
typedef PoseArray_<ContainerAllocator> Type;
PoseArray() = default;
};
PoseArray_()
: header(), poses()
{
}
PoseArray_(const ContainerAllocator &_alloc)
: header(_alloc), poses(_alloc)
{
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::vector<::geometry_msgs::Pose_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::geometry_msgs::Pose_<ContainerAllocator>>> _poses_type;
_poses_type poses;
typedef boost::shared_ptr<::geometry_msgs::PoseArray_<ContainerAllocator>> Ptr;
typedef boost::shared_ptr<::geometry_msgs::PoseArray_<ContainerAllocator> const> ConstPtr;
}; // struct PoseArray_
typedef ::geometry_msgs::PoseArray_<std::allocator<void>> PoseArray;
typedef boost::shared_ptr<::geometry_msgs::PoseArray> PoseArrayPtr;
typedef boost::shared_ptr<::geometry_msgs::PoseArray const> PoseArrayConstPtr;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::PoseArray &lhs, const geometry_msgs::PoseArray &rhs)
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::geometry_msgs::PoseArray_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseArray_<ContainerAllocator2> &rhs)
{
if(lhs.poses.size() != rhs.poses.size())
return false;
for(int i = 0; i < lhs.poses.size(); i++)
{
if(!(lhs.poses[i] == rhs.poses[i]))
return false;
}
return lhs.header == rhs.header;
return lhs.header == rhs.header &&
lhs.poses == rhs.poses;
}
inline bool operator!=(const geometry_msgs::PoseArray &lhs, const geometry_msgs::PoseArray &rhs)
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::PoseArray_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseArray_<ContainerAllocator2> &rhs)
{
return !(lhs == rhs);
}
} // namespace geometry_msgs
#endif // POSE_ARRAY_H
#endif // GEOMETRY_MSGS_MESSAGE_POSEARRAY_H

60
geometry_msgs/include/geometry_msgs/PoseStamped.h
View File

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

80
geometry_msgs/include/geometry_msgs/PoseWithCovariance.h
View File

@ -1,49 +1,63 @@
// # This represents a pose in free space with uncertainty.
// Generated by gencpp from file geometry_msgs/PoseWithCovariance.msg
// DO NOT EDIT!
// Pose pose
#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H
#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H
// # Row-major representation of the 6x6 covariance matrix
// # The orientation parameters use a fixed-axis representation.
// # In order, the parameters are:
// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
// float64[36] covariance
#ifndef POSE_WITH_COVARIANCE_H
#define POSE_WITH_COVARIANCE_H
#include <array>
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <boost/array.hpp>
#include <geometry_msgs/Pose.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct PoseWithCovariance_
{
typedef PoseWithCovariance_<ContainerAllocator> Type;
struct PoseWithCovariance
PoseWithCovariance_()
: pose(), covariance()
{
Pose pose;
std::array<double, 36> covariance;
PoseWithCovariance() : pose(), covariance{{0.0}} {};
};
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::PoseWithCovariance &lhs, const geometry_msgs::PoseWithCovariance &rhs)
{
for(size_t i = 0; i < 36; ++i)
{
if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
{
return false;
covariance.assign(0.0);
}
}
return lhs.pose == rhs.pose;
PoseWithCovariance_(const ContainerAllocator &_alloc)
: pose(_alloc), covariance()
{
(void)_alloc;
covariance.assign(0.0);
}
inline bool operator!=(const geometry_msgs::PoseWithCovariance &lhs, const geometry_msgs::PoseWithCovariance &rhs)
typedef ::geometry_msgs::Pose_<ContainerAllocator> _pose_type;
_pose_type pose;
typedef boost::array<double, 36> _covariance_type;
_covariance_type covariance;
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance_<ContainerAllocator>> Ptr;
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance_<ContainerAllocator> const> ConstPtr;
}; // struct PoseWithCovariance_
typedef ::geometry_msgs::PoseWithCovariance_<std::allocator<void>> PoseWithCovariance;
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance> PoseWithCovariancePtr;
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovariance const> PoseWithCovarianceConstPtr;
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator2> &rhs)
{
return lhs.pose == rhs.pose &&
lhs.covariance == rhs.covariance;
}
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator2> &rhs)
{
return !(lhs == rhs);
}
} // namespace geometry_msgs
#endif // POSE_WITH_COVARIANCE_H
#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H

60
geometry_msgs/include/geometry_msgs/PoseWithCovarianceStamped.h
View File

@ -1,40 +1,62 @@
// # This expresses an estimated pose with a reference coordinate frame and timestamp
// Generated by gencpp from file geometry_msgs/PoseWithCovarianceStamped.msg
// DO NOT EDIT!
// Header header
// PoseWithCovariance pose
#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
#ifndef POSE_WITH_COVARIANCE_STAMPED_H
#define POSE_WITH_COVARIANCE_STAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <std_msgs/Header.h>
#include <geometry_msgs/PoseWithCovariance.h>
namespace geometry_msgs
{
struct PoseWithCovarianceStamped
template <class ContainerAllocator>
struct PoseWithCovarianceStamped_
{
std_msgs::Header header;
PoseWithCovariance pose;
typedef PoseWithCovarianceStamped_<ContainerAllocator> Type;
PoseWithCovarianceStamped() = default;
};
PoseWithCovarianceStamped_()
: header(), pose()
{
}
PoseWithCovarianceStamped_(const ContainerAllocator &_alloc)
: header(_alloc), pose(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs)
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> _pose_type;
_pose_type pose;
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator>> Ptr;
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
}; // struct PoseWithCovarianceStamped_
typedef ::geometry_msgs::PoseWithCovarianceStamped_<std::allocator<void>> PoseWithCovarianceStamped;
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped> PoseWithCovarianceStampedPtr;
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped const> PoseWithCovarianceStampedConstPtr;
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator2> &rhs)
{
return lhs.header == rhs.header &&
lhs.pose == rhs.pose;
}
inline bool operator!=(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs)
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator2> &rhs)
{
return !(lhs == rhs);
}
} // namespace geometry_msgs
#endif // POSE_WITH_COVARIANCE_STAMPED_H
#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H

81
geometry_msgs/include/geometry_msgs/Quaternion.h
View File

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

58
geometry_msgs/include/geometry_msgs/QuaternionStamped.h
View File

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

62
geometry_msgs/include/geometry_msgs/Transform.h
View File

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

62
geometry_msgs/include/geometry_msgs/TransformStamped.h
View File

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

61
geometry_msgs/include/geometry_msgs/Twist.h
View File

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

59
geometry_msgs/include/geometry_msgs/TwistStamped.h
View File

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

78
geometry_msgs/include/geometry_msgs/TwistWithCovariance.h
View File

@ -1,50 +1,66 @@
// # This expresses velocity in free space with uncertainty.
// Generated by gencpp from file geometry_msgs/TwistWithCovariance.msg
// DO NOT EDIT!
// Twist twist
#ifndef GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H
#define GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H
// # Row-major representation of the 6x6 covariance matrix
// # The orientation parameters use a fixed-axis representation.
// # In order, the parameters are:
// # (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)
// float64[36] covariance
#ifndef TWIST_WITH_COVARIANCE_H
#define TWIST_WITH_COVARIANCE_H
#include <array>
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <boost/array.hpp>
#include <geometry_msgs/Twist.h>
namespace geometry_msgs
{
struct TwistWithCovariance
template <class ContainerAllocator>
struct TwistWithCovariance_
{
Twist twist;
std::array<double, 36> covariance;
typedef TwistWithCovariance_<ContainerAllocator> Type;
TwistWithCovariance() : twist(), covariance{{0.0}} {};
};
TwistWithCovariance_()
: twist(), covariance()
{
covariance.assign(0.0);
}
TwistWithCovariance_(const ContainerAllocator &_alloc)
: twist(_alloc), covariance()
{
(void)_alloc;
covariance.assign(0.0);
}
typedef ::geometry_msgs::Twist_<ContainerAllocator> _twist_type;
_twist_type twist;
typedef boost::array<double, 36> _covariance_type;
_covariance_type covariance;
typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance_<ContainerAllocator>> Ptr;
typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance_<ContainerAllocator> const> ConstPtr;
}; // struct TwistWithCovariance_
typedef ::geometry_msgs::TwistWithCovariance_<std::allocator<void>> TwistWithCovariance;
typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance> TwistWithCovariancePtr;
typedef boost::shared_ptr<::geometry_msgs::TwistWithCovariance const> TwistWithCovarianceConstPtr;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::TwistWithCovariance &lhs, const geometry_msgs::TwistWithCovariance &rhs)
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator2> &rhs)
{
for(size_t i = 0; i < 36; ++i)
{
if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
{
return false;
}
}
return lhs.twist == rhs.twist;
return lhs.twist == rhs.twist &&
lhs.covariance == rhs.covariance;
}
inline bool operator!=(const geometry_msgs::TwistWithCovariance &lhs, const geometry_msgs::TwistWithCovariance &rhs)
template <typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator1> &lhs, const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator2> &rhs)
{
return !(lhs == rhs);
}
} // namespace geometry_msgs
#endif // TWIST_WITH_COVARIANCE_H
#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H

59
geometry_msgs/include/geometry_msgs/TwistWithCovarianceStamped.h
View File

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

74
geometry_msgs/include/geometry_msgs/Vector3.h
View File

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

60
geometry_msgs/include/geometry_msgs/Vector3Stamped.h
View File

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

61
geometry_msgs/include/geometry_msgs/Wrench.h
View File

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

59
geometry_msgs/include/geometry_msgs/WrenchStamped.h
View File

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

2
nav_msgs/include/nav_msgs/MapMetaData.h
View File

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

62
std_msgs/include/std_msgs/Header.h
View File

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