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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,33 +1,60 @@
#ifndef POLYGON_H // Generated by gencpp from file geometry_msgs/Polygon.msg
#define POLYGON_H // DO NOT EDIT!
#include<vector>
#include<geometry_msgs/Point32.h> #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 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;
return !(lhs == rhs);
} 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 } // namespace geometry_msgs
#endif //POLYGON_H #endif // GEOMETRY_MSGS_MESSAGE_POLYGON_H

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -1,33 +1,69 @@
#ifndef TRANSFORM_STAMPED_H // Generated by gencpp from file geometry_msgs/TransformStamped.msg
#define TRANSFORM_STAMPED_H // DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H
#include "std_msgs/Header.h"
#include "geometry_msgs/Transform.h"
#include <string> #include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <std_msgs/Header.h>
#include <geometry_msgs/Transform.h>
namespace geometry_msgs namespace geometry_msgs
{ {
template <class ContainerAllocator>
struct TransformStamped_
{
typedef TransformStamped_<ContainerAllocator> Type;
struct TransformStamped TransformStamped_()
{ : header(), child_frame_id(), transform()
std_msgs::Header header; {
std::string child_frame_id; }
Transform transform; TransformStamped_(const ContainerAllocator &_alloc)
}; : header(_alloc), child_frame_id(_alloc), transform(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
inline bool operator==(const geometry_msgs::TransformStamped &lhs, const geometry_msgs::TransformStamped &rhs) _header_type header;
{
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) 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;
return !(lhs == rhs);
} 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
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;
}
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 } // namespace geometry_msgs
#endif // TRANSFORM_STAMPED_H #endif // GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H

77
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. // Generated by gencpp from file geometry_msgs/Twist.msg
// Vector3 linear // DO NOT EDIT!
// Vector3 angular
#ifndef TWIST_H #ifndef GEOMETRY_MSGS_MESSAGE_TWIST_H
#define TWIST_H #define GEOMETRY_MSGS_MESSAGE_TWIST_H
#include <string>
#include <vector>
#include <memory>
#include <boost/shared_ptr.hpp>
#include <geometry_msgs/Vector3.h>
#include <geometry_msgs/Vector3.h> #include <geometry_msgs/Vector3.h>
namespace geometry_msgs namespace geometry_msgs
{ {
template <class ContainerAllocator>
struct Twist_
{
typedef Twist_<ContainerAllocator> Type;
struct Twist Twist_()
{ : linear(), angular()
Vector3 linear; {
Vector3 angular; }
Twist_(const ContainerAllocator &_alloc)
: linear(_alloc), angular(_alloc)
{
(void)_alloc;
}
// Constructor mặc định typedef ::geometry_msgs::Vector3_<ContainerAllocator> _linear_type;
Twist() : linear(), angular() {} _linear_type linear;
// Constructor khởi tạo nhanh typedef ::geometry_msgs::Vector3_<ContainerAllocator> _angular_type;
Twist(const Vector3& linear_, const Vector3& angular_) _angular_type angular;
: linear(linear_), angular(angular_) {}
};
// constants requiring out of line definition typedef boost::shared_ptr<::geometry_msgs::Twist_<ContainerAllocator>> Ptr;
inline bool operator==(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs) typedef boost::shared_ptr<::geometry_msgs::Twist_<ContainerAllocator> const> ConstPtr;
{
return lhs.linear == rhs.linear &&
lhs.angular == rhs.angular;
}
inline bool operator!=(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs) }; // struct Twist_
{
return !(lhs == rhs); 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
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;
}
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 } // namespace geometry_msgs
#endif // ACCEL_H #endif // GEOMETRY_MSGS_MESSAGE_TWIST_H

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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