pi/ar_basalt
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

v01

Browse Source
This commit is contained in:
Ivan
2022-04-05 11:42:28 +03:00
commit 6dc0eb0fcf
5565 changed files with 1200500 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

223
thirdparty/ros/include/geometry_msgs/Accel.h vendored Normal file
View File

@@ -0,0 +1,223 @@
// Generated by gencpp from file geometry_msgs/Accel.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_ACCEL_H
#define GEOMETRY_MSGS_MESSAGE_ACCEL_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Vector3.h>
#include <geometry_msgs/Vector3.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Accel_
{
typedef Accel_<ContainerAllocator> Type;
Accel_()
: linear()
, angular() {
}
Accel_(const ContainerAllocator& _alloc)
: linear(_alloc)
, angular(_alloc) {
(void)_alloc;
}
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;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Accel_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Accel_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::geometry_msgs::Accel_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace geometry_msgs
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)
{
s << indent << "linear: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.linear);
s << indent << "angular: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.angular);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_ACCEL_H

245
thirdparty/ros/include/geometry_msgs/AccelStamped.h vendored Normal file
View File

@@ -0,0 +1,245 @@
// Generated by gencpp from file geometry_msgs/AccelStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Accel.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct AccelStamped_
{
typedef AccelStamped_<ContainerAllocator> Type;
AccelStamped_()
: header()
, accel() {
}
AccelStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, accel(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Accel_<ContainerAllocator> _accel_type;
_accel_type accel;
typedef boost::shared_ptr< ::geometry_msgs::AccelStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::AccelStamped_<ContainerAllocator> const> ConstPtr;
}; // struct AccelStamped_
typedef ::geometry_msgs::AccelStamped_<std::allocator<void> > AccelStamped;
typedef boost::shared_ptr< ::geometry_msgs::AccelStamped > AccelStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::AccelStamped const> AccelStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::AccelStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::AccelStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::AccelStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::AccelStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::AccelStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::AccelStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::AccelStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::AccelStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::AccelStamped_<ContainerAllocator> >
{
static const char* value()
{
return "d8a98a5d81351b6eb0578c78557e7659";
}
static const char* value(const ::geometry_msgs::AccelStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xd8a98a5d81351b6eULL;
static const uint64_t static_value2 = 0xb0578c78557e7659ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::AccelStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/AccelStamped";
}
static const char* value(const ::geometry_msgs::AccelStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::AccelStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# An accel with reference coordinate frame and timestamp\n"
"Header header\n"
"Accel accel\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Accel\n"
"# 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::AccelStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::AccelStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.accel);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct AccelStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::AccelStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::AccelStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "accel: ";
s << std::endl;
Printer< ::geometry_msgs::Accel_<ContainerAllocator> >::stream(s, indent + " ", v.accel);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H

239
thirdparty/ros/include/geometry_msgs/AccelWithCovariance.h vendored Normal file
View File

@@ -0,0 +1,239 @@
// Generated by gencpp from file geometry_msgs/AccelWithCovariance.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H
#define GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Accel.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct AccelWithCovariance_
{
typedef AccelWithCovariance_<ContainerAllocator> Type;
AccelWithCovariance_()
: accel()
, covariance() {
covariance.assign(0.0);
}
AccelWithCovariance_(const ContainerAllocator& _alloc)
: accel(_alloc)
, covariance() {
(void)_alloc;
covariance.assign(0.0);
}
typedef ::geometry_msgs::Accel_<ContainerAllocator> _accel_type;
_accel_type accel;
typedef boost::array<double, 36> _covariance_type;
_covariance_type covariance;
typedef boost::shared_ptr< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> const> ConstPtr;
}; // struct AccelWithCovariance_
typedef ::geometry_msgs::AccelWithCovariance_<std::allocator<void> > AccelWithCovariance;
typedef boost::shared_ptr< ::geometry_msgs::AccelWithCovariance > AccelWithCovariancePtr;
typedef boost::shared_ptr< ::geometry_msgs::AccelWithCovariance const> AccelWithCovarianceConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "ad5a718d699c6be72a02b8d6a139f334";
}
static const char* value(const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xad5a718d699c6be7ULL;
static const uint64_t static_value2 = 0x2a02b8d6a139f334ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/AccelWithCovariance";
}
static const char* value(const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "# This expresses acceleration in free space with uncertainty.\n"
"\n"
"Accel accel\n"
"\n"
"# Row-major representation of the 6x6 covariance matrix\n"
"# The orientation parameters use a fixed-axis representation.\n"
"# In order, the parameters are:\n"
"# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n"
"float64[36] covariance\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Accel\n"
"# 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::AccelWithCovariance_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.accel);
stream.next(m.covariance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct AccelWithCovariance_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::AccelWithCovariance_<ContainerAllocator>& v)
{
s << indent << "accel: ";
s << std::endl;
Printer< ::geometry_msgs::Accel_<ContainerAllocator> >::stream(s, indent + " ", v.accel);
s << indent << "covariance[]" << std::endl;
for (size_t i = 0; i < v.covariance.size(); ++i)
{
s << indent << " covariance[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.covariance[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H

257
thirdparty/ros/include/geometry_msgs/AccelWithCovarianceStamped.h vendored Normal file
View File

@@ -0,0 +1,257 @@
// Generated by gencpp from file geometry_msgs/AccelWithCovarianceStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/AccelWithCovariance.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct AccelWithCovarianceStamped_
{
typedef AccelWithCovarianceStamped_<ContainerAllocator> Type;
AccelWithCovarianceStamped_()
: header()
, accel() {
}
AccelWithCovarianceStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, accel(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> _accel_type;
_accel_type accel;
typedef boost::shared_ptr< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
}; // struct AccelWithCovarianceStamped_
typedef ::geometry_msgs::AccelWithCovarianceStamped_<std::allocator<void> > AccelWithCovarianceStamped;
typedef boost::shared_ptr< ::geometry_msgs::AccelWithCovarianceStamped > AccelWithCovarianceStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::AccelWithCovarianceStamped const> AccelWithCovarianceStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "96adb295225031ec8d57fb4251b0a886";
}
static const char* value(const ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x96adb295225031ecULL;
static const uint64_t static_value2 = 0x8d57fb4251b0a886ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/AccelWithCovarianceStamped";
}
static const char* value(const ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents an estimated accel with reference coordinate frame and timestamp.\n"
"Header header\n"
"AccelWithCovariance accel\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/AccelWithCovariance\n"
"# This expresses acceleration in free space with uncertainty.\n"
"\n"
"Accel accel\n"
"\n"
"# Row-major representation of the 6x6 covariance matrix\n"
"# The orientation parameters use a fixed-axis representation.\n"
"# In order, the parameters are:\n"
"# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n"
"float64[36] covariance\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Accel\n"
"# 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::AccelWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.accel);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct AccelWithCovarianceStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "accel: ";
s << std::endl;
Printer< ::geometry_msgs::AccelWithCovariance_<ContainerAllocator> >::stream(s, indent + " ", v.accel);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H

288
thirdparty/ros/include/geometry_msgs/Inertia.h vendored Normal file
View File

@@ -0,0 +1,288 @@
// 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 <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Vector3.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Inertia_
{
typedef Inertia_<ContainerAllocator> Type;
Inertia_()
: m(0.0)
, com()
, ixx(0.0)
, ixy(0.0)
, ixz(0.0)
, iyy(0.0)
, iyz(0.0)
, izz(0.0) {
}
Inertia_(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;
}
typedef double _m_type;
_m_type m;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _com_type;
_com_type com;
typedef double _ixx_type;
_ixx_type ixx;
typedef double _ixy_type;
_ixy_type ixy;
typedef double _ixz_type;
_ixz_type ixz;
typedef double _iyy_type;
_iyy_type iyy;
typedef double _iyz_type;
_iyz_type iyz;
typedef double _izz_type;
_izz_type izz;
typedef boost::shared_ptr< ::geometry_msgs::Inertia_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Inertia_<ContainerAllocator> const> ConstPtr;
}; // struct Inertia_
typedef ::geometry_msgs::Inertia_<std::allocator<void> > Inertia;
typedef boost::shared_ptr< ::geometry_msgs::Inertia > InertiaPtr;
typedef boost::shared_ptr< ::geometry_msgs::Inertia const> InertiaConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Inertia_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Inertia_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Inertia_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Inertia_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Inertia_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Inertia_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Inertia_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Inertia_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Inertia_<ContainerAllocator> >
{
static const char* value()
{
return "1d26e4bb6c83ff141c5cf0d883c2b0fe";
}
static const char* value(const ::geometry_msgs::Inertia_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x1d26e4bb6c83ff14ULL;
static const uint64_t static_value2 = 0x1c5cf0d883c2b0feULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Inertia_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Inertia";
}
static const char* value(const ::geometry_msgs::Inertia_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Inertia_<ContainerAllocator> >
{
static const char* value()
{
return "# Mass [kg]\n"
"float64 m\n"
"\n"
"# Center of mass [m]\n"
"geometry_msgs/Vector3 com\n"
"\n"
"# Inertia Tensor [kg-m^2]\n"
"# | ixx ixy ixz |\n"
"# I = | ixy iyy iyz |\n"
"# | ixz iyz izz |\n"
"float64 ixx\n"
"float64 ixy\n"
"float64 ixz\n"
"float64 iyy\n"
"float64 iyz\n"
"float64 izz\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::Inertia_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Inertia_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.m);
stream.next(m.com);
stream.next(m.ixx);
stream.next(m.ixy);
stream.next(m.ixz);
stream.next(m.iyy);
stream.next(m.iyz);
stream.next(m.izz);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Inertia_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Inertia_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Inertia_<ContainerAllocator>& v)
{
s << indent << "m: ";
Printer<double>::stream(s, indent + " ", v.m);
s << indent << "com: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.com);
s << indent << "ixx: ";
Printer<double>::stream(s, indent + " ", v.ixx);
s << indent << "ixy: ";
Printer<double>::stream(s, indent + " ", v.ixy);
s << indent << "ixz: ";
Printer<double>::stream(s, indent + " ", v.ixz);
s << indent << "iyy: ";
Printer<double>::stream(s, indent + " ", v.iyy);
s << indent << "iyz: ";
Printer<double>::stream(s, indent + " ", v.iyz);
s << indent << "izz: ";
Printer<double>::stream(s, indent + " ", v.izz);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_INERTIA_H

257
thirdparty/ros/include/geometry_msgs/InertiaStamped.h vendored Normal file
View File

@@ -0,0 +1,257 @@
// Generated by gencpp from file geometry_msgs/InertiaStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Inertia.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct InertiaStamped_
{
typedef InertiaStamped_<ContainerAllocator> Type;
InertiaStamped_()
: header()
, inertia() {
}
InertiaStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, inertia(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Inertia_<ContainerAllocator> _inertia_type;
_inertia_type inertia;
typedef boost::shared_ptr< ::geometry_msgs::InertiaStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::InertiaStamped_<ContainerAllocator> const> ConstPtr;
}; // struct InertiaStamped_
typedef ::geometry_msgs::InertiaStamped_<std::allocator<void> > InertiaStamped;
typedef boost::shared_ptr< ::geometry_msgs::InertiaStamped > InertiaStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::InertiaStamped const> InertiaStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::InertiaStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::InertiaStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::InertiaStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::InertiaStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >
{
static const char* value()
{
return "ddee48caeab5a966c5e8d166654a9ac7";
}
static const char* value(const ::geometry_msgs::InertiaStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xddee48caeab5a966ULL;
static const uint64_t static_value2 = 0xc5e8d166654a9ac7ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/InertiaStamped";
}
static const char* value(const ::geometry_msgs::InertiaStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >
{
static const char* value()
{
return "Header header\n"
"Inertia inertia\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Inertia\n"
"# Mass [kg]\n"
"float64 m\n"
"\n"
"# Center of mass [m]\n"
"geometry_msgs/Vector3 com\n"
"\n"
"# Inertia Tensor [kg-m^2]\n"
"# | ixx ixy ixz |\n"
"# I = | ixy iyy iyz |\n"
"# | ixz iyz izz |\n"
"float64 ixx\n"
"float64 ixy\n"
"float64 ixz\n"
"float64 iyy\n"
"float64 iyz\n"
"float64 izz\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::InertiaStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.inertia);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct InertiaStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::InertiaStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::InertiaStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "inertia: ";
s << std::endl;
Printer< ::geometry_msgs::Inertia_<ContainerAllocator> >::stream(s, indent + " ", v.inertia);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H

216
thirdparty/ros/include/geometry_msgs/Point.h vendored Normal file
View File

@@ -0,0 +1,216 @@
// Generated by gencpp from file geometry_msgs/Point.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_POINT_H
#define GEOMETRY_MSGS_MESSAGE_POINT_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Point_
{
typedef Point_<ContainerAllocator> Type;
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;
}
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
typedef boost::shared_ptr< ::geometry_msgs::Point_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Point_<ContainerAllocator> const> ConstPtr;
}; // struct Point_
typedef ::geometry_msgs::Point_<std::allocator<void> > Point;
typedef boost::shared_ptr< ::geometry_msgs::Point > PointPtr;
typedef boost::shared_ptr< ::geometry_msgs::Point const> PointConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Point_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Point_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Point_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Point_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Point_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Point_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Point_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Point_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Point_<ContainerAllocator> >
{
static const char* value()
{
return "4a842b65f413084dc2b10fb484ea7f17";
}
static const char* value(const ::geometry_msgs::Point_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x4a842b65f413084dULL;
static const uint64_t static_value2 = 0xc2b10fb484ea7f17ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Point_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Point";
}
static const char* value(const ::geometry_msgs::Point_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Point_<ContainerAllocator> >
{
static const char* value()
{
return "# This contains the position of a point in free space\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
;
}
static const char* value(const ::geometry_msgs::Point_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Point_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.x);
stream.next(m.y);
stream.next(m.z);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Point_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Point_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Point_<ContainerAllocator>& v)
{
s << indent << "x: ";
Printer<double>::stream(s, indent + " ", v.x);
s << indent << "y: ";
Printer<double>::stream(s, indent + " ", v.y);
s << indent << "z: ";
Printer<double>::stream(s, indent + " ", v.z);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POINT_H

223
thirdparty/ros/include/geometry_msgs/Point32.h vendored Normal file
View File

@@ -0,0 +1,223 @@
// Generated by gencpp from file geometry_msgs/Point32.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_POINT32_H
#define GEOMETRY_MSGS_MESSAGE_POINT32_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Point32_
{
typedef Point32_<ContainerAllocator> Type;
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;
}
typedef float _x_type;
_x_type x;
typedef float _y_type;
_y_type y;
typedef float _z_type;
_z_type z;
typedef boost::shared_ptr< ::geometry_msgs::Point32_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Point32_<ContainerAllocator> const> ConstPtr;
}; // struct Point32_
typedef ::geometry_msgs::Point32_<std::allocator<void> > Point32;
typedef boost::shared_ptr< ::geometry_msgs::Point32 > Point32Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Point32 const> Point32ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Point32_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Point32_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Point32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Point32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Point32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Point32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Point32_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Point32_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Point32_<ContainerAllocator> >
{
static const char* value()
{
return "cc153912f1453b708d221682bc23d9ac";
}
static const char* value(const ::geometry_msgs::Point32_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xcc153912f1453b70ULL;
static const uint64_t static_value2 = 0x8d221682bc23d9acULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Point32_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Point32";
}
static const char* value(const ::geometry_msgs::Point32_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Point32_<ContainerAllocator> >
{
static const char* value()
{
return "# This contains the position of a point in free space(with 32 bits of precision).\n"
"# It is recommeded to use Point wherever possible instead of Point32. \n"
"# \n"
"# This recommendation is to promote interoperability. \n"
"#\n"
"# This message is designed to take up less space when sending\n"
"# lots of points at once, as in the case of a PointCloud. \n"
"\n"
"float32 x\n"
"float32 y\n"
"float32 z\n"
;
}
static const char* value(const ::geometry_msgs::Point32_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Point32_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.x);
stream.next(m.y);
stream.next(m.z);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Point32_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Point32_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Point32_<ContainerAllocator>& v)
{
s << indent << "x: ";
Printer<float>::stream(s, indent + " ", v.x);
s << indent << "y: ";
Printer<float>::stream(s, indent + " ", v.y);
s << indent << "z: ";
Printer<float>::stream(s, indent + " ", v.z);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POINT32_H

233
thirdparty/ros/include/geometry_msgs/PointStamped.h vendored Normal file
View File

@@ -0,0 +1,233 @@
// 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 <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Point.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct PointStamped_
{
typedef PointStamped_<ContainerAllocator> Type;
PointStamped_()
: header()
, point() {
}
PointStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, point(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Point_<ContainerAllocator> _point_type;
_point_type point;
typedef boost::shared_ptr< ::geometry_msgs::PointStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::PointStamped_<ContainerAllocator> const> ConstPtr;
}; // struct PointStamped_
typedef ::geometry_msgs::PointStamped_<std::allocator<void> > PointStamped;
typedef boost::shared_ptr< ::geometry_msgs::PointStamped > PointStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::PointStamped const> PointStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PointStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::PointStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PointStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PointStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PointStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PointStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PointStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PointStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::PointStamped_<ContainerAllocator> >
{
static const char* value()
{
return "c63aecb41bfdfd6b7e1fac37c7cbe7bf";
}
static const char* value(const ::geometry_msgs::PointStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xc63aecb41bfdfd6bULL;
static const uint64_t static_value2 = 0x7e1fac37c7cbe7bfULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::PointStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/PointStamped";
}
static const char* value(const ::geometry_msgs::PointStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::PointStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents a Point with reference coordinate frame and timestamp\n"
"Header header\n"
"Point point\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point\n"
"# This contains the position of a point in free space\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
;
}
static const char* value(const ::geometry_msgs::PointStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::PointStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.point);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PointStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::PointStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PointStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "point: ";
s << std::endl;
Printer< ::geometry_msgs::Point_<ContainerAllocator> >::stream(s, indent + " ", v.point);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H

217
thirdparty/ros/include/geometry_msgs/Polygon.h vendored Normal file
View File

@@ -0,0 +1,217 @@
// 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 <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Point32.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Polygon_
{
typedef Polygon_<ContainerAllocator> Type;
Polygon_()
: points() {
}
Polygon_(const ContainerAllocator& _alloc)
: points(_alloc) {
(void)_alloc;
}
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 ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Polygon_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Polygon_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Polygon_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Polygon_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Polygon_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Polygon_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Polygon_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Polygon_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Polygon_<ContainerAllocator> >
{
static const char* value()
{
return "cd60a26494a087f577976f0329fa120e";
}
static const char* value(const ::geometry_msgs::Polygon_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xcd60a26494a087f5ULL;
static const uint64_t static_value2 = 0x77976f0329fa120eULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Polygon_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Polygon";
}
static const char* value(const ::geometry_msgs::Polygon_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Polygon_<ContainerAllocator> >
{
static const char* value()
{
return "#A specification of a polygon where the first and last points are assumed to be connected\n"
"Point32[] points\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point32\n"
"# This contains the position of a point in free space(with 32 bits of precision).\n"
"# It is recommeded to use Point wherever possible instead of Point32. \n"
"# \n"
"# This recommendation is to promote interoperability. \n"
"#\n"
"# This message is designed to take up less space when sending\n"
"# lots of points at once, as in the case of a PointCloud. \n"
"\n"
"float32 x\n"
"float32 y\n"
"float32 z\n"
;
}
static const char* value(const ::geometry_msgs::Polygon_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Polygon_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.points);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Polygon_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Polygon_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Polygon_<ContainerAllocator>& v)
{
s << indent << "points[]" << std::endl;
for (size_t i = 0; i < v.points.size(); ++i)
{
s << indent << " points[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::geometry_msgs::Point32_<ContainerAllocator> >::stream(s, indent + " ", v.points[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POLYGON_H

245
thirdparty/ros/include/geometry_msgs/PolygonStamped.h vendored Normal file
View File

@@ -0,0 +1,245 @@
// Generated by gencpp from file geometry_msgs/PolygonStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Polygon.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct PolygonStamped_
{
typedef PolygonStamped_<ContainerAllocator> Type;
PolygonStamped_()
: header()
, polygon() {
}
PolygonStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, polygon(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Polygon_<ContainerAllocator> _polygon_type;
_polygon_type polygon;
typedef boost::shared_ptr< ::geometry_msgs::PolygonStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::PolygonStamped_<ContainerAllocator> const> ConstPtr;
}; // struct PolygonStamped_
typedef ::geometry_msgs::PolygonStamped_<std::allocator<void> > PolygonStamped;
typedef boost::shared_ptr< ::geometry_msgs::PolygonStamped > PolygonStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::PolygonStamped const> PolygonStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PolygonStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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;
}
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
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PolygonStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PolygonStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PolygonStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >
{
static const char* value()
{
return "c6be8f7dc3bee7fe9e8d296070f53340";
}
static const char* value(const ::geometry_msgs::PolygonStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xc6be8f7dc3bee7feULL;
static const uint64_t static_value2 = 0x9e8d296070f53340ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/PolygonStamped";
}
static const char* value(const ::geometry_msgs::PolygonStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents a Polygon with reference coordinate frame and timestamp\n"
"Header header\n"
"Polygon polygon\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Polygon\n"
"#A specification of a polygon where the first and last points are assumed to be connected\n"
"Point32[] points\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point32\n"
"# This contains the position of a point in free space(with 32 bits of precision).\n"
"# It is recommeded to use Point wherever possible instead of Point32. \n"
"# \n"
"# This recommendation is to promote interoperability. \n"
"#\n"
"# This message is designed to take up less space when sending\n"
"# lots of points at once, as in the case of a PointCloud. \n"
"\n"
"float32 x\n"
"float32 y\n"
"float32 z\n"
;
}
static const char* value(const ::geometry_msgs::PolygonStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.polygon);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PolygonStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::PolygonStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PolygonStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "polygon: ";
s << std::endl;
Printer< ::geometry_msgs::Polygon_<ContainerAllocator> >::stream(s, indent + " ", v.polygon);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H

226
thirdparty/ros/include/geometry_msgs/Pose.h vendored Normal file
View File

@@ -0,0 +1,226 @@
// 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 <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Point.h>
#include <geometry_msgs/Quaternion.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Pose_
{
typedef Pose_<ContainerAllocator> Type;
Pose_()
: position()
, orientation() {
}
Pose_(const ContainerAllocator& _alloc)
: position(_alloc)
, orientation(_alloc) {
(void)_alloc;
}
typedef ::geometry_msgs::Point_<ContainerAllocator> _position_type;
_position_type position;
typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _orientation_type;
_orientation_type orientation;
typedef boost::shared_ptr< ::geometry_msgs::Pose_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Pose_<ContainerAllocator> const> ConstPtr;
}; // struct Pose_
typedef ::geometry_msgs::Pose_<std::allocator<void> > Pose;
typedef boost::shared_ptr< ::geometry_msgs::Pose > PosePtr;
typedef boost::shared_ptr< ::geometry_msgs::Pose const> PoseConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Pose_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Pose_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Pose_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Pose_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Pose_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Pose_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Pose_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Pose_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Pose_<ContainerAllocator> >
{
static const char* value()
{
return "e45d45a5a1ce597b249e23fb30fc871f";
}
static const char* value(const ::geometry_msgs::Pose_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xe45d45a5a1ce597bULL;
static const uint64_t static_value2 = 0x249e23fb30fc871fULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Pose_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Pose";
}
static const char* value(const ::geometry_msgs::Pose_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Pose_<ContainerAllocator> >
{
static const char* value()
{
return "# A representation of pose in free space, composed of position and orientation. \n"
"Point position\n"
"Quaternion orientation\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point\n"
"# This contains the position of a point in free space\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::Pose_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Pose_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.position);
stream.next(m.orientation);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Pose_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Pose_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Pose_<ContainerAllocator>& v)
{
s << indent << "position: ";
s << std::endl;
Printer< ::geometry_msgs::Point_<ContainerAllocator> >::stream(s, indent + " ", v.position);
s << indent << "orientation: ";
s << std::endl;
Printer< ::geometry_msgs::Quaternion_<ContainerAllocator> >::stream(s, indent + " ", v.orientation);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POSE_H

225
thirdparty/ros/include/geometry_msgs/Pose2D.h vendored Normal file
View File

@@ -0,0 +1,225 @@
// Generated by gencpp from file geometry_msgs/Pose2D.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_POSE2D_H
#define GEOMETRY_MSGS_MESSAGE_POSE2D_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Pose2D_
{
typedef Pose2D_<ContainerAllocator> Type;
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;
}
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _theta_type;
_theta_type theta;
typedef boost::shared_ptr< ::geometry_msgs::Pose2D_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Pose2D_<ContainerAllocator> const> ConstPtr;
}; // struct Pose2D_
typedef ::geometry_msgs::Pose2D_<std::allocator<void> > Pose2D;
typedef boost::shared_ptr< ::geometry_msgs::Pose2D > Pose2DPtr;
typedef boost::shared_ptr< ::geometry_msgs::Pose2D const> Pose2DConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Pose2D_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Pose2D_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Pose2D_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Pose2D_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Pose2D_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Pose2D_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Pose2D_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Pose2D_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Pose2D_<ContainerAllocator> >
{
static const char* value()
{
return "938fa65709584ad8e77d238529be13b8";
}
static const char* value(const ::geometry_msgs::Pose2D_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x938fa65709584ad8ULL;
static const uint64_t static_value2 = 0xe77d238529be13b8ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Pose2D_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Pose2D";
}
static const char* value(const ::geometry_msgs::Pose2D_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Pose2D_<ContainerAllocator> >
{
static const char* value()
{
return "# Deprecated\n"
"# Please use the full 3D pose.\n"
"\n"
"# 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.\n"
"\n"
"# 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.\n"
"\n"
"\n"
"# This expresses a position and orientation on a 2D manifold.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 theta\n"
;
}
static const char* value(const ::geometry_msgs::Pose2D_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Pose2D_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.x);
stream.next(m.y);
stream.next(m.theta);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Pose2D_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Pose2D_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Pose2D_<ContainerAllocator>& v)
{
s << indent << "x: ";
Printer<double>::stream(s, indent + " ", v.x);
s << indent << "y: ";
Printer<double>::stream(s, indent + " ", v.y);
s << indent << "theta: ";
Printer<double>::stream(s, indent + " ", v.theta);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POSE2D_H

255
thirdparty/ros/include/geometry_msgs/PoseArray.h vendored Normal file
View File

@@ -0,0 +1,255 @@
// Generated by gencpp from file geometry_msgs/PoseArray.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_POSEARRAY_H
#define GEOMETRY_MSGS_MESSAGE_POSEARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Pose.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct PoseArray_
{
typedef PoseArray_<ContainerAllocator> Type;
PoseArray_()
: header()
, poses() {
}
PoseArray_(const ContainerAllocator& _alloc)
: header(_alloc)
, poses(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::vector< ::geometry_msgs::Pose_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::geometry_msgs::Pose_<ContainerAllocator> >> _poses_type;
_poses_type poses;
typedef boost::shared_ptr< ::geometry_msgs::PoseArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::PoseArray_<ContainerAllocator> const> ConstPtr;
}; // struct PoseArray_
typedef ::geometry_msgs::PoseArray_<std::allocator<void> > PoseArray;
typedef boost::shared_ptr< ::geometry_msgs::PoseArray > PoseArrayPtr;
typedef boost::shared_ptr< ::geometry_msgs::PoseArray const> PoseArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PoseArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::PoseArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PoseArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PoseArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PoseArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PoseArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PoseArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PoseArray_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::PoseArray_<ContainerAllocator> >
{
static const char* value()
{
return "916c28c5764443f268b296bb671b9d97";
}
static const char* value(const ::geometry_msgs::PoseArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x916c28c5764443f2ULL;
static const uint64_t static_value2 = 0x68b296bb671b9d97ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::PoseArray_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/PoseArray";
}
static const char* value(const ::geometry_msgs::PoseArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::PoseArray_<ContainerAllocator> >
{
static const char* value()
{
return "# An array of poses with a header for global reference.\n"
"\n"
"Header header\n"
"\n"
"Pose[] poses\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Pose\n"
"# A representation of pose in free space, composed of position and orientation. \n"
"Point position\n"
"Quaternion orientation\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point\n"
"# This contains the position of a point in free space\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::PoseArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::PoseArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.poses);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PoseArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::PoseArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PoseArray_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "poses[]" << std::endl;
for (size_t i = 0; i < v.poses.size(); ++i)
{
s << indent << " poses[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::geometry_msgs::Pose_<ContainerAllocator> >::stream(s, indent + " ", v.poses[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POSEARRAY_H

248
thirdparty/ros/include/geometry_msgs/PoseStamped.h vendored Normal file
View File

@@ -0,0 +1,248 @@
// 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 <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Pose.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct PoseStamped_
{
typedef PoseStamped_<ContainerAllocator> Type;
PoseStamped_()
: header()
, pose() {
}
PoseStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, pose(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Pose_<ContainerAllocator> _pose_type;
_pose_type pose;
typedef boost::shared_ptr< ::geometry_msgs::PoseStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::PoseStamped_<ContainerAllocator> const> ConstPtr;
}; // struct PoseStamped_
typedef ::geometry_msgs::PoseStamped_<std::allocator<void> > PoseStamped;
typedef boost::shared_ptr< ::geometry_msgs::PoseStamped > PoseStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::PoseStamped const> PoseStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PoseStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::PoseStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PoseStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PoseStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PoseStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PoseStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PoseStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PoseStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::PoseStamped_<ContainerAllocator> >
{
static const char* value()
{
return "d3812c3cbc69362b77dc0b19b345f8f5";
}
static const char* value(const ::geometry_msgs::PoseStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xd3812c3cbc69362bULL;
static const uint64_t static_value2 = 0x77dc0b19b345f8f5ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::PoseStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/PoseStamped";
}
static const char* value(const ::geometry_msgs::PoseStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::PoseStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# A Pose with reference coordinate frame and timestamp\n"
"Header header\n"
"Pose pose\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Pose\n"
"# A representation of pose in free space, composed of position and orientation. \n"
"Point position\n"
"Quaternion orientation\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point\n"
"# This contains the position of a point in free space\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::PoseStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::PoseStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.pose);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PoseStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::PoseStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PoseStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "pose: ";
s << std::endl;
Printer< ::geometry_msgs::Pose_<ContainerAllocator> >::stream(s, indent + " ", v.pose);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H

242
thirdparty/ros/include/geometry_msgs/PoseWithCovariance.h vendored Normal file
View File

@@ -0,0 +1,242 @@
// Generated by gencpp from file geometry_msgs/PoseWithCovariance.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H
#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Pose.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct PoseWithCovariance_
{
typedef PoseWithCovariance_<ContainerAllocator> Type;
PoseWithCovariance_()
: pose()
, covariance() {
covariance.assign(0.0);
}
PoseWithCovariance_(const ContainerAllocator& _alloc)
: pose(_alloc)
, covariance() {
(void)_alloc;
covariance.assign(0.0);
}
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;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "c23e848cf1b7533a8d7c259073a97e6f";
}
static const char* value(const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xc23e848cf1b7533aULL;
static const uint64_t static_value2 = 0x8d7c259073a97e6fULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/PoseWithCovariance";
}
static const char* value(const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents a pose in free space with uncertainty.\n"
"\n"
"Pose pose\n"
"\n"
"# Row-major representation of the 6x6 covariance matrix\n"
"# The orientation parameters use a fixed-axis representation.\n"
"# In order, the parameters are:\n"
"# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n"
"float64[36] covariance\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Pose\n"
"# A representation of pose in free space, composed of position and orientation. \n"
"Point position\n"
"Quaternion orientation\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point\n"
"# This contains the position of a point in free space\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.pose);
stream.next(m.covariance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PoseWithCovariance_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PoseWithCovariance_<ContainerAllocator>& v)
{
s << indent << "pose: ";
s << std::endl;
Printer< ::geometry_msgs::Pose_<ContainerAllocator> >::stream(s, indent + " ", v.pose);
s << indent << "covariance[]" << std::endl;
for (size_t i = 0; i < v.covariance.size(); ++i)
{
s << indent << " covariance[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.covariance[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H

261
thirdparty/ros/include/geometry_msgs/PoseWithCovarianceStamped.h vendored Normal file
View File

@@ -0,0 +1,261 @@
// Generated by gencpp from file geometry_msgs/PoseWithCovarianceStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/PoseWithCovariance.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct PoseWithCovarianceStamped_
{
typedef PoseWithCovarianceStamped_<ContainerAllocator> Type;
PoseWithCovarianceStamped_()
: header()
, pose() {
}
PoseWithCovarianceStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, pose(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> _pose_type;
_pose_type pose;
typedef boost::shared_ptr< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
}; // struct PoseWithCovarianceStamped_
typedef ::geometry_msgs::PoseWithCovarianceStamped_<std::allocator<void> > PoseWithCovarianceStamped;
typedef boost::shared_ptr< ::geometry_msgs::PoseWithCovarianceStamped > PoseWithCovarianceStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::PoseWithCovarianceStamped const> PoseWithCovarianceStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "953b798c0f514ff060a53a3498ce6246";
}
static const char* value(const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x953b798c0f514ff0ULL;
static const uint64_t static_value2 = 0x60a53a3498ce6246ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/PoseWithCovarianceStamped";
}
static const char* value(const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# This expresses an estimated pose with a reference coordinate frame and timestamp\n"
"\n"
"Header header\n"
"PoseWithCovariance pose\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/PoseWithCovariance\n"
"# This represents a pose in free space with uncertainty.\n"
"\n"
"Pose pose\n"
"\n"
"# Row-major representation of the 6x6 covariance matrix\n"
"# The orientation parameters use a fixed-axis representation.\n"
"# In order, the parameters are:\n"
"# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n"
"float64[36] covariance\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Pose\n"
"# A representation of pose in free space, composed of position and orientation. \n"
"Point position\n"
"Quaternion orientation\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Point\n"
"# This contains the position of a point in free space\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.pose);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PoseWithCovarianceStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "pose: ";
s << std::endl;
Printer< ::geometry_msgs::PoseWithCovariance_<ContainerAllocator> >::stream(s, indent + " ", v.pose);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H

227
thirdparty/ros/include/geometry_msgs/Quaternion.h vendored Normal file
View File

@@ -0,0 +1,227 @@
// Generated by gencpp from file geometry_msgs/Quaternion.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_QUATERNION_H
#define GEOMETRY_MSGS_MESSAGE_QUATERNION_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Quaternion_
{
typedef Quaternion_<ContainerAllocator> Type;
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;
}
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
typedef double _w_type;
_w_type w;
typedef boost::shared_ptr< ::geometry_msgs::Quaternion_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Quaternion_<ContainerAllocator> const> ConstPtr;
}; // struct Quaternion_
typedef ::geometry_msgs::Quaternion_<std::allocator<void> > Quaternion;
typedef boost::shared_ptr< ::geometry_msgs::Quaternion > QuaternionPtr;
typedef boost::shared_ptr< ::geometry_msgs::Quaternion const> QuaternionConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Quaternion_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Quaternion_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Quaternion_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Quaternion_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Quaternion_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Quaternion_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Quaternion_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Quaternion_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Quaternion_<ContainerAllocator> >
{
static const char* value()
{
return "a779879fadf0160734f906b8c19c7004";
}
static const char* value(const ::geometry_msgs::Quaternion_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xa779879fadf01607ULL;
static const uint64_t static_value2 = 0x34f906b8c19c7004ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Quaternion_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Quaternion";
}
static const char* value(const ::geometry_msgs::Quaternion_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Quaternion_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::Quaternion_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Quaternion_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.x);
stream.next(m.y);
stream.next(m.z);
stream.next(m.w);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Quaternion_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Quaternion_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Quaternion_<ContainerAllocator>& v)
{
s << indent << "x: ";
Printer<double>::stream(s, indent + " ", v.x);
s << indent << "y: ";
Printer<double>::stream(s, indent + " ", v.y);
s << indent << "z: ";
Printer<double>::stream(s, indent + " ", v.z);
s << indent << "w: ";
Printer<double>::stream(s, indent + " ", v.w);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_QUATERNION_H

236
thirdparty/ros/include/geometry_msgs/QuaternionStamped.h vendored Normal file
View File

@@ -0,0 +1,236 @@
// Generated by gencpp from file geometry_msgs/QuaternionStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Quaternion.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct QuaternionStamped_
{
typedef QuaternionStamped_<ContainerAllocator> Type;
QuaternionStamped_()
: header()
, quaternion() {
}
QuaternionStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, quaternion(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _quaternion_type;
_quaternion_type quaternion;
typedef boost::shared_ptr< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> const> ConstPtr;
}; // struct QuaternionStamped_
typedef ::geometry_msgs::QuaternionStamped_<std::allocator<void> > QuaternionStamped;
typedef boost::shared_ptr< ::geometry_msgs::QuaternionStamped > QuaternionStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::QuaternionStamped const> QuaternionStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::QuaternionStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >
{
static const char* value()
{
return "e57f1e547e0e1fd13504588ffc8334e2";
}
static const char* value(const ::geometry_msgs::QuaternionStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xe57f1e547e0e1fd1ULL;
static const uint64_t static_value2 = 0x3504588ffc8334e2ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/QuaternionStamped";
}
static const char* value(const ::geometry_msgs::QuaternionStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents an orientation with reference coordinate frame and timestamp.\n"
"\n"
"Header header\n"
"Quaternion quaternion\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::QuaternionStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.quaternion);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct QuaternionStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::QuaternionStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::QuaternionStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "quaternion: ";
s << std::endl;
Printer< ::geometry_msgs::Quaternion_<ContainerAllocator> >::stream(s, indent + " ", v.quaternion);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H

232
thirdparty/ros/include/geometry_msgs/Transform.h vendored Normal file
View File

@@ -0,0 +1,232 @@
// Generated by gencpp from file geometry_msgs/Transform.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_TRANSFORM_H
#define GEOMETRY_MSGS_MESSAGE_TRANSFORM_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Vector3.h>
#include <geometry_msgs/Quaternion.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Transform_
{
typedef Transform_<ContainerAllocator> Type;
Transform_()
: translation()
, rotation() {
}
Transform_(const ContainerAllocator& _alloc)
: translation(_alloc)
, rotation(_alloc) {
(void)_alloc;
}
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _translation_type;
_translation_type translation;
typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _rotation_type;
_rotation_type rotation;
typedef boost::shared_ptr< ::geometry_msgs::Transform_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Transform_<ContainerAllocator> const> ConstPtr;
}; // struct Transform_
typedef ::geometry_msgs::Transform_<std::allocator<void> > Transform;
typedef boost::shared_ptr< ::geometry_msgs::Transform > TransformPtr;
typedef boost::shared_ptr< ::geometry_msgs::Transform const> TransformConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Transform_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Transform_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Transform_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Transform_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Transform_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Transform_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Transform_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Transform_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Transform_<ContainerAllocator> >
{
static const char* value()
{
return "ac9eff44abf714214112b05d54a3cf9b";
}
static const char* value(const ::geometry_msgs::Transform_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xac9eff44abf71421ULL;
static const uint64_t static_value2 = 0x4112b05d54a3cf9bULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Transform_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Transform";
}
static const char* value(const ::geometry_msgs::Transform_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Transform_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents the transform between two coordinate frames in free space.\n"
"\n"
"Vector3 translation\n"
"Quaternion rotation\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"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::Transform_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Transform_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.translation);
stream.next(m.rotation);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Transform_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Transform_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Transform_<ContainerAllocator>& v)
{
s << indent << "translation: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.translation);
s << indent << "rotation: ";
s << std::endl;
Printer< ::geometry_msgs::Quaternion_<ContainerAllocator> >::stream(s, indent + " ", v.rotation);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORM_H

270
thirdparty/ros/include/geometry_msgs/TransformStamped.h vendored Normal file
View File

@@ -0,0 +1,270 @@
// 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 <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Transform.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct TransformStamped_
{
typedef TransformStamped_<ContainerAllocator> Type;
TransformStamped_()
: header()
, child_frame_id()
, transform() {
}
TransformStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, child_frame_id(_alloc)
, transform(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _child_frame_id_type;
_child_frame_id_type child_frame_id;
typedef ::geometry_msgs::Transform_<ContainerAllocator> _transform_type;
_transform_type transform;
typedef boost::shared_ptr< ::geometry_msgs::TransformStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::TransformStamped_<ContainerAllocator> const> ConstPtr;
}; // struct TransformStamped_
typedef ::geometry_msgs::TransformStamped_<std::allocator<void> > TransformStamped;
typedef boost::shared_ptr< ::geometry_msgs::TransformStamped > TransformStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::TransformStamped const> TransformStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::TransformStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::TransformStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::TransformStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::TransformStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::TransformStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::TransformStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::TransformStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::TransformStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::TransformStamped_<ContainerAllocator> >
{
static const char* value()
{
return "b5764a33bfeb3588febc2682852579b0";
}
static const char* value(const ::geometry_msgs::TransformStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xb5764a33bfeb3588ULL;
static const uint64_t static_value2 = 0xfebc2682852579b0ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::TransformStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/TransformStamped";
}
static const char* value(const ::geometry_msgs::TransformStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::TransformStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# This expresses a transform from coordinate frame header.frame_id\n"
"# to the coordinate frame child_frame_id\n"
"#\n"
"# This message is mostly used by the \n"
"# <a href=\"http://wiki.ros.org/tf\">tf</a> package. \n"
"# See its documentation for more information.\n"
"\n"
"Header header\n"
"string child_frame_id # the frame id of the child frame\n"
"Transform transform\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Transform\n"
"# This represents the transform between two coordinate frames in free space.\n"
"\n"
"Vector3 translation\n"
"Quaternion rotation\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"
"================================================================================\n"
"MSG: geometry_msgs/Quaternion\n"
"# This represents an orientation in free space in quaternion form.\n"
"\n"
"float64 x\n"
"float64 y\n"
"float64 z\n"
"float64 w\n"
;
}
static const char* value(const ::geometry_msgs::TransformStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::TransformStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.child_frame_id);
stream.next(m.transform);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct TransformStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::TransformStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::TransformStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "child_frame_id: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.child_frame_id);
s << indent << "transform: ";
s << std::endl;
Printer< ::geometry_msgs::Transform_<ContainerAllocator> >::stream(s, indent + " ", v.transform);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H

223
thirdparty/ros/include/geometry_msgs/Twist.h vendored Normal file
View File

@@ -0,0 +1,223 @@
// Generated by gencpp from file geometry_msgs/Twist.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_TWIST_H
#define GEOMETRY_MSGS_MESSAGE_TWIST_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Vector3.h>
#include <geometry_msgs/Vector3.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Twist_
{
typedef Twist_<ContainerAllocator> Type;
Twist_()
: linear()
, angular() {
}
Twist_(const ContainerAllocator& _alloc)
: linear(_alloc)
, angular(_alloc) {
(void)_alloc;
}
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _linear_type;
_linear_type linear;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _angular_type;
_angular_type angular;
typedef boost::shared_ptr< ::geometry_msgs::Twist_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Twist_<ContainerAllocator> const> ConstPtr;
}; // struct Twist_
typedef ::geometry_msgs::Twist_<std::allocator<void> > Twist;
typedef boost::shared_ptr< ::geometry_msgs::Twist > TwistPtr;
typedef boost::shared_ptr< ::geometry_msgs::Twist const> TwistConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Twist_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Twist_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Twist_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Twist_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Twist_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Twist_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Twist_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Twist_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Twist_<ContainerAllocator> >
{
static const char* value()
{
return "9f195f881246fdfa2798d1d3eebca84a";
}
static const char* value(const ::geometry_msgs::Twist_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x9f195f881246fdfaULL;
static const uint64_t static_value2 = 0x2798d1d3eebca84aULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Twist_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Twist";
}
static const char* value(const ::geometry_msgs::Twist_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Twist_<ContainerAllocator> >
{
static const char* value()
{
return "# This expresses velocity 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::Twist_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Twist_<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 Twist_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Twist_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Twist_<ContainerAllocator>& v)
{
s << indent << "linear: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.linear);
s << indent << "angular: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.angular);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_TWIST_H

245
thirdparty/ros/include/geometry_msgs/TwistStamped.h vendored Normal file
View File

@@ -0,0 +1,245 @@
// Generated by gencpp from file geometry_msgs/TwistStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Twist.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct TwistStamped_
{
typedef TwistStamped_<ContainerAllocator> Type;
TwistStamped_()
: header()
, twist() {
}
TwistStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, twist(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Twist_<ContainerAllocator> _twist_type;
_twist_type twist;
typedef boost::shared_ptr< ::geometry_msgs::TwistStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::TwistStamped_<ContainerAllocator> const> ConstPtr;
}; // struct TwistStamped_
typedef ::geometry_msgs::TwistStamped_<std::allocator<void> > TwistStamped;
typedef boost::shared_ptr< ::geometry_msgs::TwistStamped > TwistStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::TwistStamped const> TwistStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::TwistStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::TwistStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::TwistStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::TwistStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::TwistStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::TwistStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::TwistStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::TwistStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::TwistStamped_<ContainerAllocator> >
{
static const char* value()
{
return "98d34b0043a2093cf9d9345ab6eef12e";
}
static const char* value(const ::geometry_msgs::TwistStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x98d34b0043a2093cULL;
static const uint64_t static_value2 = 0xf9d9345ab6eef12eULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::TwistStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/TwistStamped";
}
static const char* value(const ::geometry_msgs::TwistStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::TwistStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# A twist with reference coordinate frame and timestamp\n"
"Header header\n"
"Twist twist\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Twist\n"
"# This expresses velocity 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::TwistStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::TwistStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.twist);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct TwistStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::TwistStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::TwistStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "twist: ";
s << std::endl;
Printer< ::geometry_msgs::Twist_<ContainerAllocator> >::stream(s, indent + " ", v.twist);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H

239
thirdparty/ros/include/geometry_msgs/TwistWithCovariance.h vendored Normal file
View File

@@ -0,0 +1,239 @@
// Generated by gencpp from file geometry_msgs/TwistWithCovariance.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H
#define GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Twist.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct TwistWithCovariance_
{
typedef TwistWithCovariance_<ContainerAllocator> Type;
TwistWithCovariance_()
: twist()
, covariance() {
covariance.assign(0.0);
}
TwistWithCovariance_(const ContainerAllocator& _alloc)
: twist(_alloc)
, covariance() {
(void)_alloc;
covariance.assign(0.0);
}
typedef ::geometry_msgs::Twist_<ContainerAllocator> _twist_type;
_twist_type twist;
typedef boost::array<double, 36> _covariance_type;
_covariance_type covariance;
typedef boost::shared_ptr< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> const> ConstPtr;
}; // struct TwistWithCovariance_
typedef ::geometry_msgs::TwistWithCovariance_<std::allocator<void> > TwistWithCovariance;
typedef boost::shared_ptr< ::geometry_msgs::TwistWithCovariance > TwistWithCovariancePtr;
typedef boost::shared_ptr< ::geometry_msgs::TwistWithCovariance const> TwistWithCovarianceConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "1fe8a28e6890a4cc3ae4c3ca5c7d82e6";
}
static const char* value(const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x1fe8a28e6890a4ccULL;
static const uint64_t static_value2 = 0x3ae4c3ca5c7d82e6ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/TwistWithCovariance";
}
static const char* value(const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >
{
static const char* value()
{
return "# This expresses velocity in free space with uncertainty.\n"
"\n"
"Twist twist\n"
"\n"
"# Row-major representation of the 6x6 covariance matrix\n"
"# The orientation parameters use a fixed-axis representation.\n"
"# In order, the parameters are:\n"
"# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n"
"float64[36] covariance\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Twist\n"
"# This expresses velocity 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::TwistWithCovariance_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.twist);
stream.next(m.covariance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct TwistWithCovariance_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::TwistWithCovariance_<ContainerAllocator>& v)
{
s << indent << "twist: ";
s << std::endl;
Printer< ::geometry_msgs::Twist_<ContainerAllocator> >::stream(s, indent + " ", v.twist);
s << indent << "covariance[]" << std::endl;
for (size_t i = 0; i < v.covariance.size(); ++i)
{
s << indent << " covariance[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.covariance[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H

257
thirdparty/ros/include/geometry_msgs/TwistWithCovarianceStamped.h vendored Normal file
View File

@@ -0,0 +1,257 @@
// Generated by gencpp from file geometry_msgs/TwistWithCovarianceStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/TwistWithCovariance.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct TwistWithCovarianceStamped_
{
typedef TwistWithCovarianceStamped_<ContainerAllocator> Type;
TwistWithCovarianceStamped_()
: header()
, twist() {
}
TwistWithCovarianceStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, twist(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> _twist_type;
_twist_type twist;
typedef boost::shared_ptr< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
}; // struct TwistWithCovarianceStamped_
typedef ::geometry_msgs::TwistWithCovarianceStamped_<std::allocator<void> > TwistWithCovarianceStamped;
typedef boost::shared_ptr< ::geometry_msgs::TwistWithCovarianceStamped > TwistWithCovarianceStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::TwistWithCovarianceStamped const> TwistWithCovarianceStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "8927a1a12fb2607ceea095b2dc440a96";
}
static const char* value(const ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8927a1a12fb2607cULL;
static const uint64_t static_value2 = 0xeea095b2dc440a96ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/TwistWithCovarianceStamped";
}
static const char* value(const ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents an estimated twist with reference coordinate frame and timestamp.\n"
"Header header\n"
"TwistWithCovariance twist\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/TwistWithCovariance\n"
"# This expresses velocity in free space with uncertainty.\n"
"\n"
"Twist twist\n"
"\n"
"# Row-major representation of the 6x6 covariance matrix\n"
"# The orientation parameters use a fixed-axis representation.\n"
"# In order, the parameters are:\n"
"# (x, y, z, rotation about X axis, rotation about Y axis, rotation about Z axis)\n"
"float64[36] covariance\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Twist\n"
"# This expresses velocity 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::TwistWithCovarianceStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.twist);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct TwistWithCovarianceStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "twist: ";
s << std::endl;
Printer< ::geometry_msgs::TwistWithCovariance_<ContainerAllocator> >::stream(s, indent + " ", v.twist);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H

222
thirdparty/ros/include/geometry_msgs/Vector3.h vendored Normal file
View File

@@ -0,0 +1,222 @@
// Generated by gencpp from file geometry_msgs/Vector3.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_VECTOR3_H
#define GEOMETRY_MSGS_MESSAGE_VECTOR3_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Vector3_
{
typedef Vector3_<ContainerAllocator> Type;
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;
}
typedef double _x_type;
_x_type x;
typedef double _y_type;
_y_type y;
typedef double _z_type;
_z_type z;
typedef boost::shared_ptr< ::geometry_msgs::Vector3_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Vector3_<ContainerAllocator> const> ConstPtr;
}; // struct Vector3_
typedef ::geometry_msgs::Vector3_<std::allocator<void> > Vector3;
typedef boost::shared_ptr< ::geometry_msgs::Vector3 > Vector3Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Vector3 const> Vector3ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Vector3_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Vector3_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Vector3_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Vector3_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Vector3_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Vector3_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Vector3_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Vector3_<ContainerAllocator> >
{
static const char* value()
{
return "4a842b65f413084dc2b10fb484ea7f17";
}
static const char* value(const ::geometry_msgs::Vector3_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x4a842b65f413084dULL;
static const uint64_t static_value2 = 0xc2b10fb484ea7f17ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Vector3_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Vector3";
}
static const char* value(const ::geometry_msgs::Vector3_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Vector3_<ContainerAllocator> >
{
static const char* value()
{
return "# 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::Vector3_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Vector3_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.x);
stream.next(m.y);
stream.next(m.z);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Vector3_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Vector3_<ContainerAllocator>& v)
{
s << indent << "x: ";
Printer<double>::stream(s, indent + " ", v.x);
s << indent << "y: ";
Printer<double>::stream(s, indent + " ", v.y);
s << indent << "z: ";
Printer<double>::stream(s, indent + " ", v.z);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3_H

239
thirdparty/ros/include/geometry_msgs/Vector3Stamped.h vendored Normal file
View File

@@ -0,0 +1,239 @@
// Generated by gencpp from file geometry_msgs/Vector3Stamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H
#define GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Vector3.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Vector3Stamped_
{
typedef Vector3Stamped_<ContainerAllocator> Type;
Vector3Stamped_()
: header()
, vector() {
}
Vector3Stamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, vector(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _vector_type;
_vector_type vector;
typedef boost::shared_ptr< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> const> ConstPtr;
}; // struct Vector3Stamped_
typedef ::geometry_msgs::Vector3Stamped_<std::allocator<void> > Vector3Stamped;
typedef boost::shared_ptr< ::geometry_msgs::Vector3Stamped > Vector3StampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::Vector3Stamped const> Vector3StampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Vector3Stamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >
{
static const char* value()
{
return "7b324c7325e683bf02a9b14b01090ec7";
}
static const char* value(const ::geometry_msgs::Vector3Stamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x7b324c7325e683bfULL;
static const uint64_t static_value2 = 0x02a9b14b01090ec7ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Vector3Stamped";
}
static const char* value(const ::geometry_msgs::Vector3Stamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents a Vector3 with reference coordinate frame and timestamp\n"
"Header header\n"
"Vector3 vector\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\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::Vector3Stamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.vector);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Vector3Stamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Vector3Stamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Vector3Stamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "vector: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.vector);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H

224
thirdparty/ros/include/geometry_msgs/Wrench.h vendored Normal file
View File

@@ -0,0 +1,224 @@
// Generated by gencpp from file geometry_msgs/Wrench.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_WRENCH_H
#define GEOMETRY_MSGS_MESSAGE_WRENCH_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <geometry_msgs/Vector3.h>
#include <geometry_msgs/Vector3.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct Wrench_
{
typedef Wrench_<ContainerAllocator> Type;
Wrench_()
: force()
, torque() {
}
Wrench_(const ContainerAllocator& _alloc)
: force(_alloc)
, torque(_alloc) {
(void)_alloc;
}
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _force_type;
_force_type force;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _torque_type;
_torque_type torque;
typedef boost::shared_ptr< ::geometry_msgs::Wrench_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::Wrench_<ContainerAllocator> const> ConstPtr;
}; // struct Wrench_
typedef ::geometry_msgs::Wrench_<std::allocator<void> > Wrench;
typedef boost::shared_ptr< ::geometry_msgs::Wrench > WrenchPtr;
typedef boost::shared_ptr< ::geometry_msgs::Wrench const> WrenchConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::Wrench_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::Wrench_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Wrench_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::Wrench_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Wrench_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::Wrench_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Wrench_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::Wrench_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::Wrench_<ContainerAllocator> >
{
static const char* value()
{
return "4f539cf138b23283b520fd271b567936";
}
static const char* value(const ::geometry_msgs::Wrench_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x4f539cf138b23283ULL;
static const uint64_t static_value2 = 0xb520fd271b567936ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::Wrench_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/Wrench";
}
static const char* value(const ::geometry_msgs::Wrench_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::Wrench_<ContainerAllocator> >
{
static const char* value()
{
return "# This represents force in free space, separated into\n"
"# its linear and angular parts.\n"
"Vector3 force\n"
"Vector3 torque\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::Wrench_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::Wrench_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.force);
stream.next(m.torque);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Wrench_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::Wrench_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::Wrench_<ContainerAllocator>& v)
{
s << indent << "force: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.force);
s << indent << "torque: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.torque);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_WRENCH_H

246
thirdparty/ros/include/geometry_msgs/WrenchStamped.h vendored Normal file
View File

@@ -0,0 +1,246 @@
// Generated by gencpp from file geometry_msgs/WrenchStamped.msg
// DO NOT EDIT!
#ifndef GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H
#define GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
#include <geometry_msgs/Wrench.h>
namespace geometry_msgs
{
template <class ContainerAllocator>
struct WrenchStamped_
{
typedef WrenchStamped_<ContainerAllocator> Type;
WrenchStamped_()
: header()
, wrench() {
}
WrenchStamped_(const ContainerAllocator& _alloc)
: header(_alloc)
, wrench(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Wrench_<ContainerAllocator> _wrench_type;
_wrench_type wrench;
typedef boost::shared_ptr< ::geometry_msgs::WrenchStamped_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::geometry_msgs::WrenchStamped_<ContainerAllocator> const> ConstPtr;
}; // struct WrenchStamped_
typedef ::geometry_msgs::WrenchStamped_<std::allocator<void> > WrenchStamped;
typedef boost::shared_ptr< ::geometry_msgs::WrenchStamped > WrenchStampedPtr;
typedef boost::shared_ptr< ::geometry_msgs::WrenchStamped const> WrenchStampedConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::geometry_msgs::WrenchStamped_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >::stream(s, "", v);
return s;
}
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 ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::geometry_msgs::WrenchStamped_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::geometry_msgs::WrenchStamped_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::geometry_msgs::WrenchStamped_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >
{
static const char* value()
{
return "d78d3cb249ce23087ade7e7d0c40cfa7";
}
static const char* value(const ::geometry_msgs::WrenchStamped_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xd78d3cb249ce2308ULL;
static const uint64_t static_value2 = 0x7ade7e7d0c40cfa7ULL;
};
template<class ContainerAllocator>
struct DataType< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >
{
static const char* value()
{
return "geometry_msgs/WrenchStamped";
}
static const char* value(const ::geometry_msgs::WrenchStamped_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >
{
static const char* value()
{
return "# A wrench with reference coordinate frame and timestamp\n"
"Header header\n"
"Wrench wrench\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/Header\n"
"# Standard metadata for higher-level stamped data types.\n"
"# This is generally used to communicate timestamped data \n"
"# in a particular coordinate frame.\n"
"# \n"
"# sequence ID: consecutively increasing ID \n"
"uint32 seq\n"
"#Two-integer timestamp that is expressed as:\n"
"# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n"
"# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n"
"# time-handling sugar is provided by the client library\n"
"time stamp\n"
"#Frame this data is associated with\n"
"string frame_id\n"
"\n"
"================================================================================\n"
"MSG: geometry_msgs/Wrench\n"
"# This represents force in free space, separated into\n"
"# its linear and angular parts.\n"
"Vector3 force\n"
"Vector3 torque\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::WrenchStamped_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.wrench);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct WrenchStamped_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::geometry_msgs::WrenchStamped_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::geometry_msgs::WrenchStamped_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "wrench: ";
s << std::endl;
Printer< ::geometry_msgs::Wrench_<ContainerAllocator> >::stream(s, indent + " ", v.wrench);
}
};
} // namespace message_operations
} // namespace ros
#endif // GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H