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.
// 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;
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);
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

73
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
{
template <class ContainerAllocator>
struct AccelStamped_
{
typedef AccelStamped_<ContainerAllocator> Type;
struct AccelStamped
{
std_msgs::Header header;
Accel accel;
// Constructor mặc định
AccelStamped() = default;
};
AccelStamped_()
: header(), accel()
{
}
AccelStamped_(const ContainerAllocator &_alloc)
: header(_alloc), accel(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::AccelStamped &lhs, const geometry_msgs::AccelStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.accel == rhs.accel;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
inline bool operator!=(const geometry_msgs::AccelStamped &lhs, const geometry_msgs::AccelStamped &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Accel_<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;
}
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

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
// # 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
{
template <class ContainerAllocator>
struct AccelWithCovariance_
{
typedef AccelWithCovariance_<ContainerAllocator> Type;
struct AccelWithCovariance
{
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)
AccelWithCovariance_()
: accel(), covariance()
{
if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
{
return false;
}
covariance.assign(0.0);
}
AccelWithCovariance_(const ContainerAllocator &_alloc)
: accel(_alloc), covariance()
{
(void)_alloc;
covariance.assign(0.0);
}
return lhs.accel == rhs.accel;
}
inline bool operator!=(const geometry_msgs::AccelWithCovariance &lhs, const geometry_msgs::AccelWithCovariance &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Accel_<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
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
#endif // ACCEL_WITH_COVARIANCE_H
#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_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.
// 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
{
template <class ContainerAllocator>
struct AccelWithCovarianceStamped_
{
typedef AccelWithCovarianceStamped_<ContainerAllocator> Type;
struct AccelWithCovarianceStamped
{
std_msgs::Header header;
AccelWithCovariance accel;
// Constructor mặc định
AccelWithCovarianceStamped() = default;
};
AccelWithCovarianceStamped_()
: header(), accel()
{
}
AccelWithCovarianceStamped_(const ContainerAllocator &_alloc)
: header(_alloc), accel(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::AccelWithCovarianceStamped &lhs, const geometry_msgs::AccelWithCovarianceStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.accel == rhs.accel;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
inline bool operator!=(const geometry_msgs::AccelWithCovarianceStamped &lhs, const geometry_msgs::AccelWithCovarianceStamped &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::AccelWithCovariance_<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
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
#endif // ACCEL_WITH_COVARIANCE_STAMPED_H
#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H

125
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
{
template <class ContainerAllocator>
struct Inertia_
{
typedef Inertia_<ContainerAllocator> Type;
struct Inertia
{
double m;
Vector3 com;
double ixx;
double ixy;
double ixz;
double iyy;
double iyz;
double izz;
Inertia_()
: m(0.0), com(), ixx(0.0), ixy(0.0), ixz(0.0), iyy(0.0), iyz(0.0), izz(0.0)
{
}
Inertia_(const ContainerAllocator &_alloc)
: m(0.0), com(_alloc), ixx(0.0), ixy(0.0), ixz(0.0), iyy(0.0), iyz(0.0), izz(0.0)
{
(void)_alloc;
}
Inertia() :
m(0.0),
com(),
ixx(0.0),
ixy(0.0),
ixz(0.0),
iyy(0.0),
iyz(0.0),
izz(0.0) {};
Inertia(double m_, Vector3 com_, double ixx_, double ixy_, double ixz_,
double iyy_, double iyz_, double izz_) :
m(m_),
com(com_),
ixx(ixx_),
ixy(ixy_),
ixz(ixz_),
iyy(iyy_),
iyz(iyz_),
izz(izz_) {};
};
typedef double _m_type;
_m_type m;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Inertia &lhs, const geometry_msgs::Inertia &rhs)
{
return isEqual(lhs.m, rhs.m) &&
lhs.com == rhs.com &&
isEqual(lhs.ixx, rhs.ixx) &&
isEqual(lhs.ixy, rhs.ixy) &&
isEqual(lhs.ixz, rhs.ixz) &&
isEqual(lhs.iyy, rhs.iyy) &&
isEqual(lhs.iyz, rhs.iyz) &&
isEqual(lhs.izz, rhs.izz);
}
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _com_type;
_com_type com;
inline bool operator!=(const geometry_msgs::Inertia &lhs, const geometry_msgs::Inertia &rhs)
{
return !(lhs == rhs);
}
typedef double _ixx_type;
_ixx_type ixx;
typedef double _ixy_type;
_ixy_type ixy;
typedef double _ixz_type;
_ixz_type ixz;
typedef double _iyy_type;
_iyy_type iyy;
typedef double _iyz_type;
_iyz_type iyz;
typedef double _izz_type;
_izz_type izz;
typedef boost::shared_ptr<::geometry_msgs::Inertia_<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

74
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
{
template <class ContainerAllocator>
struct InertiaStamped_
{
typedef InertiaStamped_<ContainerAllocator> Type;
struct InertiaStamped
{
std_msgs::Header header;
Inertia inertia;
// Constructor mặc định
InertiaStamped() = default;
};
InertiaStamped_()
: header(), inertia()
{
}
InertiaStamped_(const ContainerAllocator &_alloc)
: header(_alloc), inertia(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::InertiaStamped &lhs, const geometry_msgs::InertiaStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.inertia == rhs.inertia;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
inline bool operator!=(const geometry_msgs::InertiaStamped &lhs, const geometry_msgs::InertiaStamped &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Inertia_<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
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
#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
#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
{
template <class ContainerAllocator>
struct Point_
{
typedef Point_<ContainerAllocator> Type;
struct Point
{
double x;
double y;
double z;
Point_()
: x(0.0), y(0.0), z(0.0)
{
}
Point_(const ContainerAllocator &_alloc)
: x(0.0), y(0.0), z(0.0)
{
(void)_alloc;
}
// Constructor mặc định
Point() : x(0.0), y(0.0), z(0.0) {}
typedef double _x_type;
_x_type x;
// Constructor khởi tạo nhanh
Point(double x_, double y_, double z_ = 0.0)
: x(x_), y(y_), z(z_) {}
};
typedef double _y_type;
_y_type y;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Point &lhs, const geometry_msgs::Point &rhs)
{
return isEqual(lhs.x, rhs.x) &&
isEqual(lhs.y, rhs.y) &&
isEqual(lhs.z, rhs.z);
}
typedef double _z_type;
_z_type z;
inline bool operator!=(const geometry_msgs::Point &lhs, const geometry_msgs::Point &rhs)
{
return !(lhs == rhs);
}
typedef boost::shared_ptr<::geometry_msgs::Point_<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

80
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
{
float x;
float y;
float z;
template <class ContainerAllocator>
struct Point32_
{
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_) {}
};
Point32_()
: x(0.0), y(0.0), z(0.0)
{
}
Point32_(const ContainerAllocator &_alloc)
: x(0.0), y(0.0), z(0.0)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Point32 &lhs, const geometry_msgs::Point32 &rhs)
{
return isEqual(lhs.x, rhs.x) &&
isEqual(lhs.y, rhs.y) &&
isEqual(lhs.z, rhs.z);
}
typedef float _x_type;
_x_type x;
inline bool operator!=(const geometry_msgs::Point32 &lhs, const geometry_msgs::Point32 &rhs)
{
return !(lhs == rhs);
}
typedef float _y_type;
_y_type y;
typedef float _z_type;
_z_type z;
typedef boost::shared_ptr<::geometry_msgs::Point32_<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

81
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
{
std_msgs::Header header;
geometry_msgs::Point point;
PointStamped() = default;
};
template <class ContainerAllocator>
struct PointStamped_
{
typedef PointStamped_<ContainerAllocator> Type;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::PointStamped &lhs, const geometry_msgs::PointStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.point == rhs.point;
}
PointStamped_()
: header(), point()
{
}
PointStamped_(const ContainerAllocator &_alloc)
: header(_alloc), point(_alloc)
{
(void)_alloc;
}
inline bool operator!=(const geometry_msgs::PointStamped &lhs, const geometry_msgs::PointStamped &rhs)
{
return !(lhs == rhs);
}
typedef ::std_msgs::Header_<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
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
#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
#define POLYGON_H
#include<vector>
#include<geometry_msgs/Point32.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
{
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++)
Polygon_()
: points()
{
if(!(lhs.points[i] == rhs.points[i]))
return false;
}
return true;
}
Polygon_(const ContainerAllocator &_alloc)
: points(_alloc)
{
(void)_alloc;
}
inline bool operator!=(const geometry_msgs::Polygon &lhs, const geometry_msgs::Polygon &rhs)
{
return !(lhs == rhs);
}
typedef std::vector<::geometry_msgs::Point32_<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

75
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!
#include<std_msgs/Header.h>
#include<geometry_msgs/Polygon.h>
#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
{
template <class ContainerAllocator>
struct PolygonStamped_
{
typedef PolygonStamped_<ContainerAllocator> Type;
struct PolygonStamped
{
std_msgs::Header header;
Polygon polygon;
};
PolygonStamped_()
: header(), polygon()
{
}
PolygonStamped_(const ContainerAllocator &_alloc)
: header(_alloc), polygon(_alloc)
{
(void)_alloc;
}
inline bool operator==(const geometry_msgs::PolygonStamped &lhs, const geometry_msgs::PolygonStamped &rhs)
{
typedef ::std_msgs::Header_<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;
}
lhs.polygon == rhs.polygon;
}
inline bool operator!=(const geometry_msgs::PolygonStamped &lhs, const geometry_msgs::PolygonStamped &rhs)
{
return !(lhs == 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

77
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
{
template <class ContainerAllocator>
struct Pose_
{
typedef Pose_<ContainerAllocator> Type;
struct Pose
{
Point position;
Quaternion orientation;
Pose_()
: position(), orientation()
{
}
Pose_(const ContainerAllocator &_alloc)
: position(_alloc), orientation(_alloc)
{
(void)_alloc;
}
Pose() = default;
Pose(Point position_, Quaternion orientation_)
: position(position_), orientation(orientation_) {};
};
typedef ::geometry_msgs::Point_<ContainerAllocator> _position_type;
_position_type position;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Pose &lhs, const geometry_msgs::Pose &rhs)
{
return lhs.position == rhs.position &&
lhs.orientation == rhs.orientation;
}
typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _orientation_type;
_orientation_type orientation;
inline bool operator!=(const geometry_msgs::Pose &lhs, const geometry_msgs::Pose &rhs)
{
return !(lhs == rhs);
}
typedef boost::shared_ptr<::geometry_msgs::Pose_<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
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
#endif // POSE_H
#endif // GEOMETRY_MSGS_MESSAGE_POSE_H

92
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
{
template <class ContainerAllocator>
struct Pose2D_
{
typedef Pose2D_<ContainerAllocator> Type;
struct Pose2D
{
double x;
double y;
double theta;
Pose2D_()
: x(0.0), y(0.0), theta(0.0)
{
}
Pose2D_(const ContainerAllocator &_alloc)
: x(0.0), y(0.0), theta(0.0)
{
(void)_alloc;
}
Pose2D() : x(0.0), y(0.0), theta(0.0) {}
Pose2D(double x_, double y_, double theta_)
: x(x_), y(y_), theta(theta_) {}
};
typedef double _x_type;
_x_type x;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Pose2D &lhs, const geometry_msgs::Pose2D &rhs)
{
return isEqual(lhs.x, rhs.x) &&
isEqual(lhs.y, rhs.y) &&
isEqual(lhs.theta, rhs.theta);
}
typedef double _y_type;
_y_type y;
inline bool operator!=(const geometry_msgs::Pose2D &lhs, const geometry_msgs::Pose2D &rhs)
{
return !(lhs == rhs);
}
typedef double _theta_type;
_theta_type theta;
typedef boost::shared_ptr<::geometry_msgs::Pose2D_<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

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
// 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
{
template <class ContainerAllocator>
struct PoseArray_
{
typedef PoseArray_<ContainerAllocator> Type;
struct PoseArray
{
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++)
PoseArray_()
: header(), poses()
{
if(!(lhs.poses[i] == rhs.poses[i]))
return false;
}
return lhs.header == rhs.header;
}
PoseArray_(const ContainerAllocator &_alloc)
: header(_alloc), poses(_alloc)
{
(void)_alloc;
}
inline bool operator!=(const geometry_msgs::PoseArray &lhs, const geometry_msgs::PoseArray &rhs)
{
return !(lhs == rhs);
}
typedef ::std_msgs::Header_<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
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
#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
// 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
{
template <class ContainerAllocator>
struct PoseStamped_
{
typedef PoseStamped_<ContainerAllocator> Type;
struct PoseStamped
{
std_msgs::Header header;
Pose pose;
PoseStamped_()
: header(), pose()
{
}
PoseStamped_(const ContainerAllocator &_alloc)
: header(_alloc), pose(_alloc)
{
(void)_alloc;
}
PoseStamped() = default;
};
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::PoseStamped &lhs, const geometry_msgs::PoseStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.pose == rhs.pose;
}
typedef ::geometry_msgs::Pose_<ContainerAllocator> _pose_type;
_pose_type pose;
inline bool operator!=(const geometry_msgs::PoseStamped &lhs, const geometry_msgs::PoseStamped &rhs)
{
return !(lhs == rhs);
}
typedef boost::shared_ptr<::geometry_msgs::PoseStamped_<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
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
#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
// # 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
{
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)
PoseWithCovariance_()
: pose(), covariance()
{
if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
{
return false;
}
covariance.assign(0.0);
}
PoseWithCovariance_(const ContainerAllocator &_alloc)
: pose(_alloc), covariance()
{
(void)_alloc;
covariance.assign(0.0);
}
return lhs.pose == rhs.pose;
}
inline bool operator!=(const geometry_msgs::PoseWithCovariance &lhs, const geometry_msgs::PoseWithCovariance &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Pose_<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

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
// 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
{
template <class ContainerAllocator>
struct PoseWithCovarianceStamped_
{
typedef PoseWithCovarianceStamped_<ContainerAllocator> Type;
struct PoseWithCovarianceStamped
{
std_msgs::Header header;
PoseWithCovariance pose;
PoseWithCovarianceStamped_()
: header(), pose()
{
}
PoseWithCovarianceStamped_(const ContainerAllocator &_alloc)
: header(_alloc), pose(_alloc)
{
(void)_alloc;
}
PoseWithCovarianceStamped() = default;
};
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.pose == rhs.pose;
}
typedef ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> _pose_type;
_pose_type pose;
inline bool operator!=(const geometry_msgs::PoseWithCovarianceStamped &lhs, const geometry_msgs::PoseWithCovarianceStamped &rhs)
{
return !(lhs == rhs);
}
typedef boost::shared_ptr<::geometry_msgs::PoseWithCovarianceStamped_<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;
}
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

87
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
{
template <class ContainerAllocator>
struct Quaternion_
{
typedef Quaternion_<ContainerAllocator> Type;
struct Quaternion
{
double x;
double y;
double z;
double w;
Quaternion_()
: x(0.0), y(0.0), z(0.0), w(0.0)
{
}
Quaternion_(const ContainerAllocator &_alloc)
: x(0.0), y(0.0), z(0.0), w(0.0)
{
(void)_alloc;
}
// Constructor mặc định
Quaternion() : x(0.0), y(0.0), z(0.0), w(1.0) {}
typedef double _x_type;
_x_type x;
// Constructor khởi tạo nhanh
Quaternion(double x_, double y_, double z_, double w_)
: x(x_), y(y_), z(z_), w(w_) {}
};
typedef double _y_type;
_y_type y;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Quaternion &lhs, const geometry_msgs::Quaternion &rhs)
{
return isEqual(lhs.x, rhs.x) &&
isEqual(lhs.y, rhs.y) &&
isEqual(lhs.z, rhs.z) &&
isEqual(lhs.w, rhs.w);
}
typedef double _z_type;
_z_type z;
inline bool operator!=(const geometry_msgs::Quaternion &lhs, const geometry_msgs::Quaternion &rhs)
{
return !(lhs == rhs);
}
typedef double _w_type;
_w_type w;
typedef boost::shared_ptr<::geometry_msgs::Quaternion_<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

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
// 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
{
template <class ContainerAllocator>
struct QuaternionStamped_
{
typedef QuaternionStamped_<ContainerAllocator> Type;
struct QuaternionStamped
{
std_msgs::Header header;
Quaternion quaternion;
// Constructor mặc định
QuaternionStamped() = default;
};
QuaternionStamped_()
: header(), quaternion()
{
}
QuaternionStamped_(const ContainerAllocator &_alloc)
: header(_alloc), quaternion(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::QuaternionStamped &lhs, const geometry_msgs::QuaternionStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.quaternion == rhs.quaternion;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
inline bool operator!=(const geometry_msgs::QuaternionStamped &lhs, const geometry_msgs::QuaternionStamped &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Quaternion_<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
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
#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
#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
{
template <class ContainerAllocator>
struct Transform_
{
typedef Transform_<ContainerAllocator> Type;
struct Transform
{
Vector3 translation;
Quaternion rotation;
Transform_()
: translation(), rotation()
{
}
Transform_(const ContainerAllocator &_alloc)
: translation(_alloc), rotation(_alloc)
{
(void)_alloc;
}
Transform() = default;
Transform(Vector3 translation_, Quaternion rotation_)
: translation(translation_), rotation(rotation_) {}
};
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _translation_type;
_translation_type translation;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Transform &lhs, const geometry_msgs::Transform &rhs)
{
return lhs.translation == rhs.translation &&
lhs.rotation == rhs.rotation;
}
typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _rotation_type;
_rotation_type rotation;
inline bool operator!=(const geometry_msgs::Transform &lhs, const geometry_msgs::Transform &rhs)
{
return !(lhs == rhs);
}
typedef boost::shared_ptr<::geometry_msgs::Transform_<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
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
#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
#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
{
template <class ContainerAllocator>
struct TransformStamped_
{
typedef TransformStamped_<ContainerAllocator> Type;
struct TransformStamped
{
std_msgs::Header header;
std::string child_frame_id;
Transform transform;
};
TransformStamped_()
: header(), child_frame_id(), transform()
{
}
TransformStamped_(const ContainerAllocator &_alloc)
: header(_alloc), child_frame_id(_alloc), transform(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::TransformStamped &lhs, const geometry_msgs::TransformStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.child_frame_id == rhs.child_frame_id &&
lhs.transform == rhs.transform;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
inline bool operator!=(const geometry_msgs::TransformStamped &lhs, const geometry_msgs::TransformStamped &rhs)
{
return !(lhs == rhs);
}
typedef std::basic_string<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
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
#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.
// 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
{
template <class ContainerAllocator>
struct Twist_
{
typedef Twist_<ContainerAllocator> Type;
struct Twist
{
Vector3 linear;
Vector3 angular;
Twist_()
: linear(), angular()
{
}
Twist_(const ContainerAllocator &_alloc)
: linear(_alloc), angular(_alloc)
{
(void)_alloc;
}
// Constructor mặc định
Twist() : linear(), angular() {}
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _linear_type;
_linear_type linear;
// Constructor khởi tạo nhanh
Twist(const Vector3& linear_, const Vector3& angular_)
: linear(linear_), angular(angular_) {}
};
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _angular_type;
_angular_type angular;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs)
{
return lhs.linear == rhs.linear &&
lhs.angular == rhs.angular;
}
typedef boost::shared_ptr<::geometry_msgs::Twist_<ContainerAllocator>> Ptr;
typedef boost::shared_ptr<::geometry_msgs::Twist_<ContainerAllocator> const> ConstPtr;
inline bool operator!=(const geometry_msgs::Twist &lhs, const geometry_msgs::Twist &rhs)
{
return !(lhs == rhs);
}
}; // 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
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
#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
// 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
{
template <class ContainerAllocator>
struct TwistStamped_
{
typedef TwistStamped_<ContainerAllocator> Type;
struct TwistStamped
{
std_msgs::Header header;
Twist twist;
// Constructor mặc định
TwistStamped() = default;
};
TwistStamped_()
: header(), twist()
{
}
TwistStamped_(const ContainerAllocator &_alloc)
: header(_alloc), twist(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::TwistStamped &lhs, const geometry_msgs::TwistStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.twist == rhs.twist;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
inline bool operator!=(const geometry_msgs::TwistStamped &lhs, const geometry_msgs::TwistStamped &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Twist_<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
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
#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
// # 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
{
template <class ContainerAllocator>
struct TwistWithCovariance_
{
typedef TwistWithCovariance_<ContainerAllocator> Type;
struct TwistWithCovariance
{
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)
TwistWithCovariance_()
: twist(), covariance()
{
if (isEqual(lhs.covariance[i], rhs.covariance[i]) == false)
{
return false;
}
covariance.assign(0.0);
}
TwistWithCovariance_(const ContainerAllocator &_alloc)
: twist(_alloc), covariance()
{
(void)_alloc;
covariance.assign(0.0);
}
return lhs.twist == rhs.twist;
}
inline bool operator!=(const geometry_msgs::TwistWithCovariance &lhs, const geometry_msgs::TwistWithCovariance &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Twist_<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
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
#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.
// 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
{
template <class ContainerAllocator>
struct TwistWithCovarianceStamped_
{
typedef TwistWithCovarianceStamped_<ContainerAllocator> Type;
struct TwistWithCovarianceStamped
{
std_msgs::Header header;
TwistWithCovariance twist;
TwistWithCovarianceStamped_()
: header(), twist()
{
}
TwistWithCovarianceStamped_(const ContainerAllocator &_alloc)
: header(_alloc), twist(_alloc)
{
(void)_alloc;
}
TwistWithCovarianceStamped() = default;
};
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::TwistWithCovarianceStamped &lhs, const geometry_msgs::TwistWithCovarianceStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.twist == rhs.twist;
}
typedef ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> _twist_type;
_twist_type twist;
inline bool operator!=(const geometry_msgs::TwistWithCovarianceStamped &lhs, const geometry_msgs::TwistWithCovarianceStamped &rhs)
{
return !(lhs == rhs);
}
typedef boost::shared_ptr<::geometry_msgs::TwistWithCovarianceStamped_<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
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
#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
#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
{
template <class ContainerAllocator>
struct Vector3_
{
typedef Vector3_<ContainerAllocator> Type;
struct Vector3
{
double x;
double y;
double z;
Vector3_()
: x(0.0), y(0.0), z(0.0)
{
}
Vector3_(const ContainerAllocator &_alloc)
: x(0.0), y(0.0), z(0.0)
{
(void)_alloc;
}
// Constructor mặc định
Vector3() : x(0.0), y(0.0), z(0.0) {}
typedef double _x_type;
_x_type x;
// Constructor khởi tạo nhanh
Vector3(double x_, double y_, double z_)
: x(x_), y(y_), z(z_) {}
};
typedef double _y_type;
_y_type y;
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Vector3 &lhs, const geometry_msgs::Vector3 &rhs)
{
return isEqual(lhs.x, rhs.x) &&
isEqual(lhs.y, rhs.y) &&
isEqual(lhs.z, rhs.z);
}
typedef double _z_type;
_z_type z;
inline bool operator!=(const geometry_msgs::Vector3 &lhs, const geometry_msgs::Vector3 &rhs)
{
return !(lhs == rhs);
}
typedef boost::shared_ptr<::geometry_msgs::Vector3_<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

74
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
{
template <class ContainerAllocator>
struct Vector3Stamped_
{
typedef Vector3Stamped_<ContainerAllocator> Type;
struct Vector3Stamped
{
std_msgs::Header header;
Vector3 vector;
// Constructor mặc định
Vector3Stamped() = default;
};
Vector3Stamped_()
: header(), vector()
{
}
Vector3Stamped_(const ContainerAllocator &_alloc)
: header(_alloc), vector(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Vector3Stamped &lhs, const geometry_msgs::Vector3Stamped &rhs)
{
return lhs.header == rhs.header &&
lhs.vector == rhs.vector;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
inline bool operator!=(const geometry_msgs::Vector3Stamped &lhs, const geometry_msgs::Vector3Stamped &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Vector3_<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
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
#endif // VECTOR_3_STAMPED_H
#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H

79
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
{
template <class ContainerAllocator>
struct Wrench_
{
typedef Wrench_<ContainerAllocator> Type;
struct Wrench
{
Vector3 force;
Vector3 torque;
// Constructor mặc định
Wrench() = default;
Wrench(Vector3 force_, Vector3 torque_) : force(force_), torque(torque_) {};
};
Wrench_()
: force(), torque()
{
}
Wrench_(const ContainerAllocator &_alloc)
: force(_alloc), torque(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::Wrench &lhs, const geometry_msgs::Wrench &rhs)
{
return lhs.force == rhs.force &&
lhs.torque == rhs.torque;
}
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _force_type;
_force_type force;
inline bool operator!=(const geometry_msgs::Wrench &lhs, const geometry_msgs::Wrench &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Vector3_<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
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
#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
// 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
{
template <class ContainerAllocator>
struct WrenchStamped_
{
typedef WrenchStamped_<ContainerAllocator> Type;
struct WrenchStamped
{
std_msgs::Header header;
Wrench wrench;
// Constructor mặc định
WrenchStamped() = default;
};
WrenchStamped_()
: header(), wrench()
{
}
WrenchStamped_(const ContainerAllocator &_alloc)
: header(_alloc), wrench(_alloc)
{
(void)_alloc;
}
// constants requiring out of line definition
inline bool operator==(const geometry_msgs::WrenchStamped &lhs, const geometry_msgs::WrenchStamped &rhs)
{
return lhs.header == rhs.header &&
lhs.wrench == rhs.wrench;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
inline bool operator!=(const geometry_msgs::WrenchStamped &lhs, const geometry_msgs::WrenchStamped &rhs)
{
return !(lhs == rhs);
}
typedef ::geometry_msgs::Wrench_<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
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
#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
{

80
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)
{
return lhs.seq == rhs.seq &&
lhs.stamp == rhs.stamp &&
lhs.frame_id == rhs.frame_id;
}
typedef uint32_t _seq_type;
_seq_type seq;
inline bool operator!=(const std_msgs::Header &lhs, const std_msgs::Header &rhs)
{
return !(lhs == rhs);
}
typedef robot::Time _stamp_type;
_stamp_type stamp;
} // namespace std_msgs
#endif
typedef std::basic_string<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;
}
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