ml/ar_basalt
Archived
1
0
Fork 0
Code Issues Pull Requests 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

41
thirdparty/ros/include/console_bridge_export.h vendored Normal file
View File

@@ -0,0 +1,41 @@
#ifndef CONSOLE_BRIDGE_DLLAPI_H
#define CONSOLE_BRIDGE_DLLAPI_H
#ifdef CONSOLE_BRIDGE_STATIC_DEFINE
# define CONSOLE_BRIDGE_DLLAPI
# define CONSOLE_BRIDGE_NO_EXPORT
#else
# ifndef CONSOLE_BRIDGE_DLLAPI
# ifdef console_bridge_EXPORTS
/* We are building this library */
# define CONSOLE_BRIDGE_DLLAPI __attribute__((visibility("default")))
# else
/* We are using this library */
# define CONSOLE_BRIDGE_DLLAPI __attribute__((visibility("default")))
# endif
# endif
# ifndef CONSOLE_BRIDGE_NO_EXPORT
# define CONSOLE_BRIDGE_NO_EXPORT __attribute__((visibility("hidden")))
# endif
#endif
#ifndef CONSOLE_BRIDGE_DEPRECATED
# define CONSOLE_BRIDGE_DEPRECATED __attribute__ ((__deprecated__))
#endif
#ifndef CONSOLE_BRIDGE_DEPRECATED_EXPORT
# define CONSOLE_BRIDGE_DEPRECATED_EXPORT CONSOLE_BRIDGE_DLLAPI CONSOLE_BRIDGE_DEPRECATED
#endif
#ifndef CONSOLE_BRIDGE_DEPRECATED_NO_EXPORT
# define CONSOLE_BRIDGE_DEPRECATED_NO_EXPORT CONSOLE_BRIDGE_NO_EXPORT CONSOLE_BRIDGE_DEPRECATED
#endif
#define DEFINE_NO_DEPRECATED 0
#if DEFINE_NO_DEPRECATED
# define CONSOLE_BRIDGE_NO_DEPRECATED
#endif
#endif

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

537
thirdparty/ros/include/sensor_msgs/BatteryState.h vendored Normal file
View File

@@ -0,0 +1,537 @@
// Generated by gencpp from file sensor_msgs/BatteryState.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_BATTERYSTATE_H
#define SENSOR_MSGS_MESSAGE_BATTERYSTATE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct BatteryState_
{
typedef BatteryState_<ContainerAllocator> Type;
BatteryState_()
: header()
, voltage(0.0)
, temperature(0.0)
, current(0.0)
, charge(0.0)
, capacity(0.0)
, design_capacity(0.0)
, percentage(0.0)
, power_supply_status(0)
, power_supply_health(0)
, power_supply_technology(0)
, present(false)
, cell_voltage()
, cell_temperature()
, location()
, serial_number() {
}
BatteryState_(const ContainerAllocator& _alloc)
: header(_alloc)
, voltage(0.0)
, temperature(0.0)
, current(0.0)
, charge(0.0)
, capacity(0.0)
, design_capacity(0.0)
, percentage(0.0)
, power_supply_status(0)
, power_supply_health(0)
, power_supply_technology(0)
, present(false)
, cell_voltage(_alloc)
, cell_temperature(_alloc)
, location(_alloc)
, serial_number(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef float _voltage_type;
_voltage_type voltage;
typedef float _temperature_type;
_temperature_type temperature;
typedef float _current_type;
_current_type current;
typedef float _charge_type;
_charge_type charge;
typedef float _capacity_type;
_capacity_type capacity;
typedef float _design_capacity_type;
_design_capacity_type design_capacity;
typedef float _percentage_type;
_percentage_type percentage;
typedef uint8_t _power_supply_status_type;
_power_supply_status_type power_supply_status;
typedef uint8_t _power_supply_health_type;
_power_supply_health_type power_supply_health;
typedef uint8_t _power_supply_technology_type;
_power_supply_technology_type power_supply_technology;
typedef uint8_t _present_type;
_present_type present;
typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _cell_voltage_type;
_cell_voltage_type cell_voltage;
typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _cell_temperature_type;
_cell_temperature_type cell_temperature;
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _location_type;
_location_type location;
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _serial_number_type;
_serial_number_type serial_number;
// reducing the odds to have name collisions with Windows.h
#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_UNKNOWN)
#undef POWER_SUPPLY_STATUS_UNKNOWN
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_CHARGING)
#undef POWER_SUPPLY_STATUS_CHARGING
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_DISCHARGING)
#undef POWER_SUPPLY_STATUS_DISCHARGING
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_NOT_CHARGING)
#undef POWER_SUPPLY_STATUS_NOT_CHARGING
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_STATUS_FULL)
#undef POWER_SUPPLY_STATUS_FULL
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_UNKNOWN)
#undef POWER_SUPPLY_HEALTH_UNKNOWN
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_GOOD)
#undef POWER_SUPPLY_HEALTH_GOOD
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_OVERHEAT)
#undef POWER_SUPPLY_HEALTH_OVERHEAT
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_DEAD)
#undef POWER_SUPPLY_HEALTH_DEAD
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_OVERVOLTAGE)
#undef POWER_SUPPLY_HEALTH_OVERVOLTAGE
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_UNSPEC_FAILURE)
#undef POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_COLD)
#undef POWER_SUPPLY_HEALTH_COLD
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE)
#undef POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE)
#undef POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_UNKNOWN)
#undef POWER_SUPPLY_TECHNOLOGY_UNKNOWN
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_NIMH)
#undef POWER_SUPPLY_TECHNOLOGY_NIMH
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_LION)
#undef POWER_SUPPLY_TECHNOLOGY_LION
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_LIPO)
#undef POWER_SUPPLY_TECHNOLOGY_LIPO
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_LIFE)
#undef POWER_SUPPLY_TECHNOLOGY_LIFE
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_NICD)
#undef POWER_SUPPLY_TECHNOLOGY_NICD
#endif
#if defined(_WIN32) && defined(POWER_SUPPLY_TECHNOLOGY_LIMN)
#undef POWER_SUPPLY_TECHNOLOGY_LIMN
#endif
enum {
POWER_SUPPLY_STATUS_UNKNOWN = 0u,
POWER_SUPPLY_STATUS_CHARGING = 1u,
POWER_SUPPLY_STATUS_DISCHARGING = 2u,
POWER_SUPPLY_STATUS_NOT_CHARGING = 3u,
POWER_SUPPLY_STATUS_FULL = 4u,
POWER_SUPPLY_HEALTH_UNKNOWN = 0u,
POWER_SUPPLY_HEALTH_GOOD = 1u,
POWER_SUPPLY_HEALTH_OVERHEAT = 2u,
POWER_SUPPLY_HEALTH_DEAD = 3u,
POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4u,
POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5u,
POWER_SUPPLY_HEALTH_COLD = 6u,
POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7u,
POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8u,
POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0u,
POWER_SUPPLY_TECHNOLOGY_NIMH = 1u,
POWER_SUPPLY_TECHNOLOGY_LION = 2u,
POWER_SUPPLY_TECHNOLOGY_LIPO = 3u,
POWER_SUPPLY_TECHNOLOGY_LIFE = 4u,
POWER_SUPPLY_TECHNOLOGY_NICD = 5u,
POWER_SUPPLY_TECHNOLOGY_LIMN = 6u,
};
typedef boost::shared_ptr< ::sensor_msgs::BatteryState_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::BatteryState_<ContainerAllocator> const> ConstPtr;
}; // struct BatteryState_
typedef ::sensor_msgs::BatteryState_<std::allocator<void> > BatteryState;
typedef boost::shared_ptr< ::sensor_msgs::BatteryState > BatteryStatePtr;
typedef boost::shared_ptr< ::sensor_msgs::BatteryState const> BatteryStateConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::BatteryState_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::BatteryState_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::BatteryState_<ContainerAllocator1> & lhs, const ::sensor_msgs::BatteryState_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.voltage == rhs.voltage &&
lhs.temperature == rhs.temperature &&
lhs.current == rhs.current &&
lhs.charge == rhs.charge &&
lhs.capacity == rhs.capacity &&
lhs.design_capacity == rhs.design_capacity &&
lhs.percentage == rhs.percentage &&
lhs.power_supply_status == rhs.power_supply_status &&
lhs.power_supply_health == rhs.power_supply_health &&
lhs.power_supply_technology == rhs.power_supply_technology &&
lhs.present == rhs.present &&
lhs.cell_voltage == rhs.cell_voltage &&
lhs.cell_temperature == rhs.cell_temperature &&
lhs.location == rhs.location &&
lhs.serial_number == rhs.serial_number;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::BatteryState_<ContainerAllocator1> & lhs, const ::sensor_msgs::BatteryState_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::BatteryState_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::BatteryState_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::BatteryState_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::BatteryState_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::BatteryState_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::BatteryState_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::BatteryState_<ContainerAllocator> >
{
static const char* value()
{
return "4ddae7f048e32fda22cac764685e3974";
}
static const char* value(const ::sensor_msgs::BatteryState_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x4ddae7f048e32fdaULL;
static const uint64_t static_value2 = 0x22cac764685e3974ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::BatteryState_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/BatteryState";
}
static const char* value(const ::sensor_msgs::BatteryState_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::BatteryState_<ContainerAllocator> >
{
static const char* value()
{
return "\n"
"# Constants are chosen to match the enums in the linux kernel\n"
"# defined in include/linux/power_supply.h as of version 3.7\n"
"# The one difference is for style reasons the constants are\n"
"# all uppercase not mixed case.\n"
"\n"
"# Power supply status constants\n"
"uint8 POWER_SUPPLY_STATUS_UNKNOWN = 0\n"
"uint8 POWER_SUPPLY_STATUS_CHARGING = 1\n"
"uint8 POWER_SUPPLY_STATUS_DISCHARGING = 2\n"
"uint8 POWER_SUPPLY_STATUS_NOT_CHARGING = 3\n"
"uint8 POWER_SUPPLY_STATUS_FULL = 4\n"
"\n"
"# Power supply health constants\n"
"uint8 POWER_SUPPLY_HEALTH_UNKNOWN = 0\n"
"uint8 POWER_SUPPLY_HEALTH_GOOD = 1\n"
"uint8 POWER_SUPPLY_HEALTH_OVERHEAT = 2\n"
"uint8 POWER_SUPPLY_HEALTH_DEAD = 3\n"
"uint8 POWER_SUPPLY_HEALTH_OVERVOLTAGE = 4\n"
"uint8 POWER_SUPPLY_HEALTH_UNSPEC_FAILURE = 5\n"
"uint8 POWER_SUPPLY_HEALTH_COLD = 6\n"
"uint8 POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE = 7\n"
"uint8 POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE = 8\n"
"\n"
"# Power supply technology (chemistry) constants\n"
"uint8 POWER_SUPPLY_TECHNOLOGY_UNKNOWN = 0\n"
"uint8 POWER_SUPPLY_TECHNOLOGY_NIMH = 1\n"
"uint8 POWER_SUPPLY_TECHNOLOGY_LION = 2\n"
"uint8 POWER_SUPPLY_TECHNOLOGY_LIPO = 3\n"
"uint8 POWER_SUPPLY_TECHNOLOGY_LIFE = 4\n"
"uint8 POWER_SUPPLY_TECHNOLOGY_NICD = 5\n"
"uint8 POWER_SUPPLY_TECHNOLOGY_LIMN = 6\n"
"\n"
"Header header\n"
"float32 voltage # Voltage in Volts (Mandatory)\n"
"float32 temperature # Temperature in Degrees Celsius (If unmeasured NaN)\n"
"float32 current # Negative when discharging (A) (If unmeasured NaN)\n"
"float32 charge # Current charge in Ah (If unmeasured NaN)\n"
"float32 capacity # Capacity in Ah (last full capacity) (If unmeasured NaN)\n"
"float32 design_capacity # Capacity in Ah (design capacity) (If unmeasured NaN)\n"
"float32 percentage # Charge percentage on 0 to 1 range (If unmeasured NaN)\n"
"uint8 power_supply_status # The charging status as reported. Values defined above\n"
"uint8 power_supply_health # The battery health metric. Values defined above\n"
"uint8 power_supply_technology # The battery chemistry. Values defined above\n"
"bool present # True if the battery is present\n"
"\n"
"float32[] cell_voltage # An array of individual cell voltages for each cell in the pack\n"
" # If individual voltages unknown but number of cells known set each to NaN\n"
"float32[] cell_temperature # An array of individual cell temperatures for each cell in the pack\n"
" # If individual temperatures unknown but number of cells known set each to NaN\n"
"string location # The location into which the battery is inserted. (slot number or plug)\n"
"string serial_number # The best approximation of the battery serial number\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"
;
}
static const char* value(const ::sensor_msgs::BatteryState_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::BatteryState_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.voltage);
stream.next(m.temperature);
stream.next(m.current);
stream.next(m.charge);
stream.next(m.capacity);
stream.next(m.design_capacity);
stream.next(m.percentage);
stream.next(m.power_supply_status);
stream.next(m.power_supply_health);
stream.next(m.power_supply_technology);
stream.next(m.present);
stream.next(m.cell_voltage);
stream.next(m.cell_temperature);
stream.next(m.location);
stream.next(m.serial_number);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct BatteryState_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::BatteryState_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::BatteryState_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "voltage: ";
Printer<float>::stream(s, indent + " ", v.voltage);
s << indent << "temperature: ";
Printer<float>::stream(s, indent + " ", v.temperature);
s << indent << "current: ";
Printer<float>::stream(s, indent + " ", v.current);
s << indent << "charge: ";
Printer<float>::stream(s, indent + " ", v.charge);
s << indent << "capacity: ";
Printer<float>::stream(s, indent + " ", v.capacity);
s << indent << "design_capacity: ";
Printer<float>::stream(s, indent + " ", v.design_capacity);
s << indent << "percentage: ";
Printer<float>::stream(s, indent + " ", v.percentage);
s << indent << "power_supply_status: ";
Printer<uint8_t>::stream(s, indent + " ", v.power_supply_status);
s << indent << "power_supply_health: ";
Printer<uint8_t>::stream(s, indent + " ", v.power_supply_health);
s << indent << "power_supply_technology: ";
Printer<uint8_t>::stream(s, indent + " ", v.power_supply_technology);
s << indent << "present: ";
Printer<uint8_t>::stream(s, indent + " ", v.present);
s << indent << "cell_voltage[]" << std::endl;
for (size_t i = 0; i < v.cell_voltage.size(); ++i)
{
s << indent << " cell_voltage[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.cell_voltage[i]);
}
s << indent << "cell_temperature[]" << std::endl;
for (size_t i = 0; i < v.cell_temperature.size(); ++i)
{
s << indent << " cell_temperature[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.cell_temperature[i]);
}
s << indent << "location: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.location);
s << indent << "serial_number: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.serial_number);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_BATTERYSTATE_H

483
thirdparty/ros/include/sensor_msgs/CameraInfo.h vendored Normal file
View File

@@ -0,0 +1,483 @@
// Generated by gencpp from file sensor_msgs/CameraInfo.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_CAMERAINFO_H
#define SENSOR_MSGS_MESSAGE_CAMERAINFO_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 <sensor_msgs/RegionOfInterest.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct CameraInfo_
{
typedef CameraInfo_<ContainerAllocator> Type;
CameraInfo_()
: header()
, height(0)
, width(0)
, distortion_model()
, D()
, K()
, R()
, P()
, binning_x(0)
, binning_y(0)
, roi() {
K.assign(0.0);
R.assign(0.0);
P.assign(0.0);
}
CameraInfo_(const ContainerAllocator& _alloc)
: header(_alloc)
, height(0)
, width(0)
, distortion_model(_alloc)
, D(_alloc)
, K()
, R()
, P()
, binning_x(0)
, binning_y(0)
, roi(_alloc) {
(void)_alloc;
K.assign(0.0);
R.assign(0.0);
P.assign(0.0);
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef uint32_t _height_type;
_height_type height;
typedef uint32_t _width_type;
_width_type width;
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _distortion_model_type;
_distortion_model_type distortion_model;
typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _D_type;
_D_type D;
typedef boost::array<double, 9> _K_type;
_K_type K;
typedef boost::array<double, 9> _R_type;
_R_type R;
typedef boost::array<double, 12> _P_type;
_P_type P;
typedef uint32_t _binning_x_type;
_binning_x_type binning_x;
typedef uint32_t _binning_y_type;
_binning_y_type binning_y;
typedef ::sensor_msgs::RegionOfInterest_<ContainerAllocator> _roi_type;
_roi_type roi;
typedef boost::shared_ptr< ::sensor_msgs::CameraInfo_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::CameraInfo_<ContainerAllocator> const> ConstPtr;
}; // struct CameraInfo_
typedef ::sensor_msgs::CameraInfo_<std::allocator<void> > CameraInfo;
typedef boost::shared_ptr< ::sensor_msgs::CameraInfo > CameraInfoPtr;
typedef boost::shared_ptr< ::sensor_msgs::CameraInfo const> CameraInfoConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::CameraInfo_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::CameraInfo_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::CameraInfo_<ContainerAllocator1> & lhs, const ::sensor_msgs::CameraInfo_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.height == rhs.height &&
lhs.width == rhs.width &&
lhs.distortion_model == rhs.distortion_model &&
lhs.D == rhs.D &&
lhs.K == rhs.K &&
lhs.R == rhs.R &&
lhs.P == rhs.P &&
lhs.binning_x == rhs.binning_x &&
lhs.binning_y == rhs.binning_y &&
lhs.roi == rhs.roi;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::CameraInfo_<ContainerAllocator1> & lhs, const ::sensor_msgs::CameraInfo_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::CameraInfo_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::CameraInfo_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::CameraInfo_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
{
static const char* value()
{
return "c9a58c1b0b154e0e6da7578cb991d214";
}
static const char* value(const ::sensor_msgs::CameraInfo_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xc9a58c1b0b154e0eULL;
static const uint64_t static_value2 = 0x6da7578cb991d214ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/CameraInfo";
}
static const char* value(const ::sensor_msgs::CameraInfo_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
{
static const char* value()
{
return "# This message defines meta information for a camera. It should be in a\n"
"# camera namespace on topic \"camera_info\" and accompanied by up to five\n"
"# image topics named:\n"
"#\n"
"# image_raw - raw data from the camera driver, possibly Bayer encoded\n"
"# image - monochrome, distorted\n"
"# image_color - color, distorted\n"
"# image_rect - monochrome, rectified\n"
"# image_rect_color - color, rectified\n"
"#\n"
"# The image_pipeline contains packages (image_proc, stereo_image_proc)\n"
"# for producing the four processed image topics from image_raw and\n"
"# camera_info. The meaning of the camera parameters are described in\n"
"# detail at http://www.ros.org/wiki/image_pipeline/CameraInfo.\n"
"#\n"
"# The image_geometry package provides a user-friendly interface to\n"
"# common operations using this meta information. If you want to, e.g.,\n"
"# project a 3d point into image coordinates, we strongly recommend\n"
"# using image_geometry.\n"
"#\n"
"# If the camera is uncalibrated, the matrices D, K, R, P should be left\n"
"# zeroed out. In particular, clients may assume that K[0] == 0.0\n"
"# indicates an uncalibrated camera.\n"
"\n"
"#######################################################################\n"
"# Image acquisition info #\n"
"#######################################################################\n"
"\n"
"# Time of image acquisition, camera coordinate frame ID\n"
"Header header # Header timestamp should be acquisition time of image\n"
" # Header frame_id should be optical frame of camera\n"
" # origin of frame should be optical center of camera\n"
" # +x should point to the right in the image\n"
" # +y should point down in the image\n"
" # +z should point into the plane of the image\n"
"\n"
"\n"
"#######################################################################\n"
"# Calibration Parameters #\n"
"#######################################################################\n"
"# These are fixed during camera calibration. Their values will be the #\n"
"# same in all messages until the camera is recalibrated. Note that #\n"
"# self-calibrating systems may \"recalibrate\" frequently. #\n"
"# #\n"
"# The internal parameters can be used to warp a raw (distorted) image #\n"
"# to: #\n"
"# 1. An undistorted image (requires D and K) #\n"
"# 2. A rectified image (requires D, K, R) #\n"
"# The projection matrix P projects 3D points into the rectified image.#\n"
"#######################################################################\n"
"\n"
"# The image dimensions with which the camera was calibrated. Normally\n"
"# this will be the full camera resolution in pixels.\n"
"uint32 height\n"
"uint32 width\n"
"\n"
"# The distortion model used. Supported models are listed in\n"
"# sensor_msgs/distortion_models.h. For most cameras, \"plumb_bob\" - a\n"
"# simple model of radial and tangential distortion - is sufficient.\n"
"string distortion_model\n"
"\n"
"# The distortion parameters, size depending on the distortion model.\n"
"# For \"plumb_bob\", the 5 parameters are: (k1, k2, t1, t2, k3).\n"
"float64[] D\n"
"\n"
"# Intrinsic camera matrix for the raw (distorted) images.\n"
"# [fx 0 cx]\n"
"# K = [ 0 fy cy]\n"
"# [ 0 0 1]\n"
"# Projects 3D points in the camera coordinate frame to 2D pixel\n"
"# coordinates using the focal lengths (fx, fy) and principal point\n"
"# (cx, cy).\n"
"float64[9] K # 3x3 row-major matrix\n"
"\n"
"# Rectification matrix (stereo cameras only)\n"
"# A rotation matrix aligning the camera coordinate system to the ideal\n"
"# stereo image plane so that epipolar lines in both stereo images are\n"
"# parallel.\n"
"float64[9] R # 3x3 row-major matrix\n"
"\n"
"# Projection/camera matrix\n"
"# [fx' 0 cx' Tx]\n"
"# P = [ 0 fy' cy' Ty]\n"
"# [ 0 0 1 0]\n"
"# By convention, this matrix specifies the intrinsic (camera) matrix\n"
"# of the processed (rectified) image. That is, the left 3x3 portion\n"
"# is the normal camera intrinsic matrix for the rectified image.\n"
"# It projects 3D points in the camera coordinate frame to 2D pixel\n"
"# coordinates using the focal lengths (fx', fy') and principal point\n"
"# (cx', cy') - these may differ from the values in K.\n"
"# For monocular cameras, Tx = Ty = 0. Normally, monocular cameras will\n"
"# also have R = the identity and P[1:3,1:3] = K.\n"
"# For a stereo pair, the fourth column [Tx Ty 0]' is related to the\n"
"# position of the optical center of the second camera in the first\n"
"# camera's frame. We assume Tz = 0 so both cameras are in the same\n"
"# stereo image plane. The first camera always has Tx = Ty = 0. For\n"
"# the right (second) camera of a horizontal stereo pair, Ty = 0 and\n"
"# Tx = -fx' * B, where B is the baseline between the cameras.\n"
"# Given a 3D point [X Y Z]', the projection (x, y) of the point onto\n"
"# the rectified image is given by:\n"
"# [u v w]' = P * [X Y Z 1]'\n"
"# x = u / w\n"
"# y = v / w\n"
"# This holds for both images of a stereo pair.\n"
"float64[12] P # 3x4 row-major matrix\n"
"\n"
"\n"
"#######################################################################\n"
"# Operational Parameters #\n"
"#######################################################################\n"
"# These define the image region actually captured by the camera #\n"
"# driver. Although they affect the geometry of the output image, they #\n"
"# may be changed freely without recalibrating the camera. #\n"
"#######################################################################\n"
"\n"
"# Binning refers here to any camera setting which combines rectangular\n"
"# neighborhoods of pixels into larger \"super-pixels.\" It reduces the\n"
"# resolution of the output image to\n"
"# (width / binning_x) x (height / binning_y).\n"
"# The default values binning_x = binning_y = 0 is considered the same\n"
"# as binning_x = binning_y = 1 (no subsampling).\n"
"uint32 binning_x\n"
"uint32 binning_y\n"
"\n"
"# Region of interest (subwindow of full camera resolution), given in\n"
"# full resolution (unbinned) image coordinates. A particular ROI\n"
"# always denotes the same window of pixels on the camera sensor,\n"
"# regardless of binning settings.\n"
"# The default setting of roi (all values 0) is considered the same as\n"
"# full resolution (roi.width = width, roi.height = height).\n"
"RegionOfInterest roi\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: sensor_msgs/RegionOfInterest\n"
"# This message is used to specify a region of interest within an image.\n"
"#\n"
"# When used to specify the ROI setting of the camera when the image was\n"
"# taken, the height and width fields should either match the height and\n"
"# width fields for the associated image; or height = width = 0\n"
"# indicates that the full resolution image was captured.\n"
"\n"
"uint32 x_offset # Leftmost pixel of the ROI\n"
" # (0 if the ROI includes the left edge of the image)\n"
"uint32 y_offset # Topmost pixel of the ROI\n"
" # (0 if the ROI includes the top edge of the image)\n"
"uint32 height # Height of ROI\n"
"uint32 width # Width of ROI\n"
"\n"
"# True if a distinct rectified ROI should be calculated from the \"raw\"\n"
"# ROI in this message. Typically this should be False if the full image\n"
"# is captured (ROI not used), and True if a subwindow is captured (ROI\n"
"# used).\n"
"bool do_rectify\n"
;
}
static const char* value(const ::sensor_msgs::CameraInfo_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.height);
stream.next(m.width);
stream.next(m.distortion_model);
stream.next(m.D);
stream.next(m.K);
stream.next(m.R);
stream.next(m.P);
stream.next(m.binning_x);
stream.next(m.binning_y);
stream.next(m.roi);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct CameraInfo_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::CameraInfo_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::CameraInfo_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "height: ";
Printer<uint32_t>::stream(s, indent + " ", v.height);
s << indent << "width: ";
Printer<uint32_t>::stream(s, indent + " ", v.width);
s << indent << "distortion_model: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.distortion_model);
s << indent << "D[]" << std::endl;
for (size_t i = 0; i < v.D.size(); ++i)
{
s << indent << " D[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.D[i]);
}
s << indent << "K[]" << std::endl;
for (size_t i = 0; i < v.K.size(); ++i)
{
s << indent << " K[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.K[i]);
}
s << indent << "R[]" << std::endl;
for (size_t i = 0; i < v.R.size(); ++i)
{
s << indent << " R[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.R[i]);
}
s << indent << "P[]" << std::endl;
for (size_t i = 0; i < v.P.size(); ++i)
{
s << indent << " P[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.P[i]);
}
s << indent << "binning_x: ";
Printer<uint32_t>::stream(s, indent + " ", v.binning_x);
s << indent << "binning_y: ";
Printer<uint32_t>::stream(s, indent + " ", v.binning_y);
s << indent << "roi: ";
s << std::endl;
Printer< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >::stream(s, indent + " ", v.roi);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_CAMERAINFO_H

231
thirdparty/ros/include/sensor_msgs/ChannelFloat32.h vendored Normal file
View File

@@ -0,0 +1,231 @@
// Generated by gencpp from file sensor_msgs/ChannelFloat32.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_H
#define SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_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 sensor_msgs
{
template <class ContainerAllocator>
struct ChannelFloat32_
{
typedef ChannelFloat32_<ContainerAllocator> Type;
ChannelFloat32_()
: name()
, values() {
}
ChannelFloat32_(const ContainerAllocator& _alloc)
: name(_alloc)
, values(_alloc) {
(void)_alloc;
}
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _name_type;
_name_type name;
typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _values_type;
_values_type values;
typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> const> ConstPtr;
}; // struct ChannelFloat32_
typedef ::sensor_msgs::ChannelFloat32_<std::allocator<void> > ChannelFloat32;
typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32 > ChannelFloat32Ptr;
typedef boost::shared_ptr< ::sensor_msgs::ChannelFloat32 const> ChannelFloat32ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::ChannelFloat32_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator1> & lhs, const ::sensor_msgs::ChannelFloat32_<ContainerAllocator2> & rhs)
{
return lhs.name == rhs.name &&
lhs.values == rhs.values;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator1> & lhs, const ::sensor_msgs::ChannelFloat32_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
{
static const char* value()
{
return "3d40139cdd33dfedcb71ffeeeb42ae7f";
}
static const char* value(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x3d40139cdd33dfedULL;
static const uint64_t static_value2 = 0xcb71ffeeeb42ae7fULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/ChannelFloat32";
}
static const char* value(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
{
static const char* value()
{
return "# This message is used by the PointCloud message to hold optional data\n"
"# associated with each point in the cloud. The length of the values\n"
"# array should be the same as the length of the points array in the\n"
"# PointCloud, and each value should be associated with the corresponding\n"
"# point.\n"
"\n"
"# Channel names in existing practice include:\n"
"# \"u\", \"v\" - row and column (respectively) in the left stereo image.\n"
"# This is opposite to usual conventions but remains for\n"
"# historical reasons. The newer PointCloud2 message has no\n"
"# such problem.\n"
"# \"rgb\" - For point clouds produced by color stereo cameras. uint8\n"
"# (R,G,B) values packed into the least significant 24 bits,\n"
"# in order.\n"
"# \"intensity\" - laser or pixel intensity.\n"
"# \"distance\"\n"
"\n"
"# The channel name should give semantics of the channel (e.g.\n"
"# \"intensity\" instead of \"value\").\n"
"string name\n"
"\n"
"# The values array should be 1-1 with the elements of the associated\n"
"# PointCloud.\n"
"float32[] values\n"
;
}
static const char* value(const ::sensor_msgs::ChannelFloat32_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.name);
stream.next(m.values);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct ChannelFloat32_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::ChannelFloat32_<ContainerAllocator>& v)
{
s << indent << "name: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.name);
s << indent << "values[]" << std::endl;
for (size_t i = 0; i < v.values.size(); ++i)
{
s << indent << " values[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.values[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_CHANNELFLOAT32_H

247
thirdparty/ros/include/sensor_msgs/CompressedImage.h vendored Normal file
View File

@@ -0,0 +1,247 @@
// Generated by gencpp from file sensor_msgs/CompressedImage.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_H
#define SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct CompressedImage_
{
typedef CompressedImage_<ContainerAllocator> Type;
CompressedImage_()
: header()
, format()
, data() {
}
CompressedImage_(const ContainerAllocator& _alloc)
: header(_alloc)
, format(_alloc)
, data(_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>> _format_type;
_format_type format;
typedef std::vector<uint8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::sensor_msgs::CompressedImage_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::CompressedImage_<ContainerAllocator> const> ConstPtr;
}; // struct CompressedImage_
typedef ::sensor_msgs::CompressedImage_<std::allocator<void> > CompressedImage;
typedef boost::shared_ptr< ::sensor_msgs::CompressedImage > CompressedImagePtr;
typedef boost::shared_ptr< ::sensor_msgs::CompressedImage const> CompressedImageConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::CompressedImage_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::CompressedImage_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::CompressedImage_<ContainerAllocator1> & lhs, const ::sensor_msgs::CompressedImage_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.format == rhs.format &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::CompressedImage_<ContainerAllocator1> & lhs, const ::sensor_msgs::CompressedImage_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::CompressedImage_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::CompressedImage_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::CompressedImage_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
{
static const char* value()
{
return "8f7a12909da2c9d3332d540a0977563f";
}
static const char* value(const ::sensor_msgs::CompressedImage_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8f7a12909da2c9d3ULL;
static const uint64_t static_value2 = 0x332d540a0977563fULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/CompressedImage";
}
static const char* value(const ::sensor_msgs::CompressedImage_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
{
static const char* value()
{
return "# This message contains a compressed image\n"
"\n"
"Header header # Header timestamp should be acquisition time of image\n"
" # Header frame_id should be optical frame of camera\n"
" # origin of frame should be optical center of camera\n"
" # +x should point to the right in the image\n"
" # +y should point down in the image\n"
" # +z should point into to plane of the image\n"
"\n"
"string format # Specifies the format of the data\n"
" # Acceptable values:\n"
" # jpeg, png\n"
"uint8[] data # Compressed image buffer\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"
;
}
static const char* value(const ::sensor_msgs::CompressedImage_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.format);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct CompressedImage_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::CompressedImage_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::CompressedImage_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "format: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.format);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<uint8_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_COMPRESSEDIMAGE_H

241
thirdparty/ros/include/sensor_msgs/FluidPressure.h vendored Normal file
View File

@@ -0,0 +1,241 @@
// Generated by gencpp from file sensor_msgs/FluidPressure.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_H
#define SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct FluidPressure_
{
typedef FluidPressure_<ContainerAllocator> Type;
FluidPressure_()
: header()
, fluid_pressure(0.0)
, variance(0.0) {
}
FluidPressure_(const ContainerAllocator& _alloc)
: header(_alloc)
, fluid_pressure(0.0)
, variance(0.0) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef double _fluid_pressure_type;
_fluid_pressure_type fluid_pressure;
typedef double _variance_type;
_variance_type variance;
typedef boost::shared_ptr< ::sensor_msgs::FluidPressure_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::FluidPressure_<ContainerAllocator> const> ConstPtr;
}; // struct FluidPressure_
typedef ::sensor_msgs::FluidPressure_<std::allocator<void> > FluidPressure;
typedef boost::shared_ptr< ::sensor_msgs::FluidPressure > FluidPressurePtr;
typedef boost::shared_ptr< ::sensor_msgs::FluidPressure const> FluidPressureConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::FluidPressure_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::FluidPressure_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::FluidPressure_<ContainerAllocator1> & lhs, const ::sensor_msgs::FluidPressure_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.fluid_pressure == rhs.fluid_pressure &&
lhs.variance == rhs.variance;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::FluidPressure_<ContainerAllocator1> & lhs, const ::sensor_msgs::FluidPressure_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::FluidPressure_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::FluidPressure_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::FluidPressure_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
{
static const char* value()
{
return "804dc5cea1c5306d6a2eb80b9833befe";
}
static const char* value(const ::sensor_msgs::FluidPressure_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x804dc5cea1c5306dULL;
static const uint64_t static_value2 = 0x6a2eb80b9833befeULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/FluidPressure";
}
static const char* value(const ::sensor_msgs::FluidPressure_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
{
static const char* value()
{
return " # Single pressure reading. This message is appropriate for measuring the\n"
" # pressure inside of a fluid (air, water, etc). This also includes\n"
" # atmospheric or barometric pressure.\n"
"\n"
" # This message is not appropriate for force/pressure contact sensors.\n"
"\n"
" Header header # timestamp of the measurement\n"
" # frame_id is the location of the pressure sensor\n"
"\n"
" float64 fluid_pressure # Absolute pressure reading in Pascals.\n"
"\n"
" float64 variance # 0 is interpreted as variance unknown\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"
;
}
static const char* value(const ::sensor_msgs::FluidPressure_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.fluid_pressure);
stream.next(m.variance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct FluidPressure_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::FluidPressure_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::FluidPressure_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "fluid_pressure: ";
Printer<double>::stream(s, indent + " ", v.fluid_pressure);
s << indent << "variance: ";
Printer<double>::stream(s, indent + " ", v.variance);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_FLUIDPRESSURE_H

250
thirdparty/ros/include/sensor_msgs/Illuminance.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file sensor_msgs/Illuminance.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_ILLUMINANCE_H
#define SENSOR_MSGS_MESSAGE_ILLUMINANCE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct Illuminance_
{
typedef Illuminance_<ContainerAllocator> Type;
Illuminance_()
: header()
, illuminance(0.0)
, variance(0.0) {
}
Illuminance_(const ContainerAllocator& _alloc)
: header(_alloc)
, illuminance(0.0)
, variance(0.0) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef double _illuminance_type;
_illuminance_type illuminance;
typedef double _variance_type;
_variance_type variance;
typedef boost::shared_ptr< ::sensor_msgs::Illuminance_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::Illuminance_<ContainerAllocator> const> ConstPtr;
}; // struct Illuminance_
typedef ::sensor_msgs::Illuminance_<std::allocator<void> > Illuminance;
typedef boost::shared_ptr< ::sensor_msgs::Illuminance > IlluminancePtr;
typedef boost::shared_ptr< ::sensor_msgs::Illuminance const> IlluminanceConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Illuminance_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::Illuminance_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::Illuminance_<ContainerAllocator1> & lhs, const ::sensor_msgs::Illuminance_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.illuminance == rhs.illuminance &&
lhs.variance == rhs.variance;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::Illuminance_<ContainerAllocator1> & lhs, const ::sensor_msgs::Illuminance_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Illuminance_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Illuminance_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Illuminance_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Illuminance_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Illuminance_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Illuminance_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::Illuminance_<ContainerAllocator> >
{
static const char* value()
{
return "8cf5febb0952fca9d650c3d11a81a188";
}
static const char* value(const ::sensor_msgs::Illuminance_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8cf5febb0952fca9ULL;
static const uint64_t static_value2 = 0xd650c3d11a81a188ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::Illuminance_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/Illuminance";
}
static const char* value(const ::sensor_msgs::Illuminance_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::Illuminance_<ContainerAllocator> >
{
static const char* value()
{
return " # Single photometric illuminance measurement. Light should be assumed to be\n"
" # measured along the sensor's x-axis (the area of detection is the y-z plane).\n"
" # The illuminance should have a 0 or positive value and be received with\n"
" # the sensor's +X axis pointing toward the light source.\n"
"\n"
" # Photometric illuminance is the measure of the human eye's sensitivity of the\n"
" # intensity of light encountering or passing through a surface.\n"
"\n"
" # All other Photometric and Radiometric measurements should\n"
" # not use this message.\n"
" # This message cannot represent:\n"
" # Luminous intensity (candela/light source output)\n"
" # Luminance (nits/light output per area)\n"
" # Irradiance (watt/area), etc.\n"
"\n"
" Header header # timestamp is the time the illuminance was measured\n"
" # frame_id is the location and direction of the reading\n"
"\n"
" float64 illuminance # Measurement of the Photometric Illuminance in Lux.\n"
"\n"
" float64 variance # 0 is interpreted as variance unknown\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"
;
}
static const char* value(const ::sensor_msgs::Illuminance_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Illuminance_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.illuminance);
stream.next(m.variance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Illuminance_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::Illuminance_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Illuminance_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "illuminance: ";
Printer<double>::stream(s, indent + " ", v.illuminance);
s << indent << "variance: ";
Printer<double>::stream(s, indent + " ", v.variance);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_ILLUMINANCE_H

297
thirdparty/ros/include/sensor_msgs/Image.h vendored Normal file
View File

@@ -0,0 +1,297 @@
// Generated by gencpp from file sensor_msgs/Image.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_IMAGE_H
#define SENSOR_MSGS_MESSAGE_IMAGE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct Image_
{
typedef Image_<ContainerAllocator> Type;
Image_()
: header()
, height(0)
, width(0)
, encoding()
, is_bigendian(0)
, step(0)
, data() {
}
Image_(const ContainerAllocator& _alloc)
: header(_alloc)
, height(0)
, width(0)
, encoding(_alloc)
, is_bigendian(0)
, step(0)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef uint32_t _height_type;
_height_type height;
typedef uint32_t _width_type;
_width_type width;
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _encoding_type;
_encoding_type encoding;
typedef uint8_t _is_bigendian_type;
_is_bigendian_type is_bigendian;
typedef uint32_t _step_type;
_step_type step;
typedef std::vector<uint8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::sensor_msgs::Image_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::Image_<ContainerAllocator> const> ConstPtr;
}; // struct Image_
typedef ::sensor_msgs::Image_<std::allocator<void> > Image;
typedef boost::shared_ptr< ::sensor_msgs::Image > ImagePtr;
typedef boost::shared_ptr< ::sensor_msgs::Image const> ImageConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Image_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::Image_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::Image_<ContainerAllocator1> & lhs, const ::sensor_msgs::Image_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.height == rhs.height &&
lhs.width == rhs.width &&
lhs.encoding == rhs.encoding &&
lhs.is_bigendian == rhs.is_bigendian &&
lhs.step == rhs.step &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::Image_<ContainerAllocator1> & lhs, const ::sensor_msgs::Image_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Image_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Image_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Image_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Image_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Image_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Image_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::Image_<ContainerAllocator> >
{
static const char* value()
{
return "060021388200f6f0f447d0fcd9c64743";
}
static const char* value(const ::sensor_msgs::Image_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x060021388200f6f0ULL;
static const uint64_t static_value2 = 0xf447d0fcd9c64743ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::Image_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/Image";
}
static const char* value(const ::sensor_msgs::Image_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::Image_<ContainerAllocator> >
{
static const char* value()
{
return "# This message contains an uncompressed image\n"
"# (0, 0) is at top-left corner of image\n"
"#\n"
"\n"
"Header header # Header timestamp should be acquisition time of image\n"
" # Header frame_id should be optical frame of camera\n"
" # origin of frame should be optical center of camera\n"
" # +x should point to the right in the image\n"
" # +y should point down in the image\n"
" # +z should point into to plane of the image\n"
" # If the frame_id here and the frame_id of the CameraInfo\n"
" # message associated with the image conflict\n"
" # the behavior is undefined\n"
"\n"
"uint32 height # image height, that is, number of rows\n"
"uint32 width # image width, that is, number of columns\n"
"\n"
"# The legal values for encoding are in file src/image_encodings.cpp\n"
"# If you want to standardize a new string format, join\n"
"# ros-users@lists.sourceforge.net and send an email proposing a new encoding.\n"
"\n"
"string encoding # Encoding of pixels -- channel meaning, ordering, size\n"
" # taken from the list of strings in include/sensor_msgs/image_encodings.h\n"
"\n"
"uint8 is_bigendian # is this data bigendian?\n"
"uint32 step # Full row length in bytes\n"
"uint8[] data # actual matrix data, size is (step * rows)\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"
;
}
static const char* value(const ::sensor_msgs::Image_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Image_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.height);
stream.next(m.width);
stream.next(m.encoding);
stream.next(m.is_bigendian);
stream.next(m.step);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Image_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::Image_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Image_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "height: ";
Printer<uint32_t>::stream(s, indent + " ", v.height);
s << indent << "width: ";
Printer<uint32_t>::stream(s, indent + " ", v.width);
s << indent << "encoding: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.encoding);
s << indent << "is_bigendian: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_bigendian);
s << indent << "step: ";
Printer<uint32_t>::stream(s, indent + " ", v.step);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<uint8_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_IMAGE_H

340
thirdparty/ros/include/sensor_msgs/Imu.h vendored Normal file
View File

@@ -0,0 +1,340 @@
// Generated by gencpp from file sensor_msgs/Imu.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_IMU_H
#define SENSOR_MSGS_MESSAGE_IMU_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>
#include <geometry_msgs/Vector3.h>
#include <geometry_msgs/Vector3.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct Imu_
{
typedef Imu_<ContainerAllocator> Type;
Imu_()
: header()
, orientation()
, orientation_covariance()
, angular_velocity()
, angular_velocity_covariance()
, linear_acceleration()
, linear_acceleration_covariance() {
orientation_covariance.assign(0.0);
angular_velocity_covariance.assign(0.0);
linear_acceleration_covariance.assign(0.0);
}
Imu_(const ContainerAllocator& _alloc)
: header(_alloc)
, orientation(_alloc)
, orientation_covariance()
, angular_velocity(_alloc)
, angular_velocity_covariance()
, linear_acceleration(_alloc)
, linear_acceleration_covariance() {
(void)_alloc;
orientation_covariance.assign(0.0);
angular_velocity_covariance.assign(0.0);
linear_acceleration_covariance.assign(0.0);
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Quaternion_<ContainerAllocator> _orientation_type;
_orientation_type orientation;
typedef boost::array<double, 9> _orientation_covariance_type;
_orientation_covariance_type orientation_covariance;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _angular_velocity_type;
_angular_velocity_type angular_velocity;
typedef boost::array<double, 9> _angular_velocity_covariance_type;
_angular_velocity_covariance_type angular_velocity_covariance;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _linear_acceleration_type;
_linear_acceleration_type linear_acceleration;
typedef boost::array<double, 9> _linear_acceleration_covariance_type;
_linear_acceleration_covariance_type linear_acceleration_covariance;
typedef boost::shared_ptr< ::sensor_msgs::Imu_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::Imu_<ContainerAllocator> const> ConstPtr;
}; // struct Imu_
typedef ::sensor_msgs::Imu_<std::allocator<void> > Imu;
typedef boost::shared_ptr< ::sensor_msgs::Imu > ImuPtr;
typedef boost::shared_ptr< ::sensor_msgs::Imu const> ImuConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Imu_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::Imu_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::Imu_<ContainerAllocator1> & lhs, const ::sensor_msgs::Imu_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.orientation == rhs.orientation &&
lhs.orientation_covariance == rhs.orientation_covariance &&
lhs.angular_velocity == rhs.angular_velocity &&
lhs.angular_velocity_covariance == rhs.angular_velocity_covariance &&
lhs.linear_acceleration == rhs.linear_acceleration &&
lhs.linear_acceleration_covariance == rhs.linear_acceleration_covariance;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::Imu_<ContainerAllocator1> & lhs, const ::sensor_msgs::Imu_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Imu_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Imu_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Imu_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Imu_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Imu_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Imu_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::Imu_<ContainerAllocator> >
{
static const char* value()
{
return "6a62c6daae103f4ff57a132d6f95cec2";
}
static const char* value(const ::sensor_msgs::Imu_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x6a62c6daae103f4fULL;
static const uint64_t static_value2 = 0xf57a132d6f95cec2ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::Imu_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/Imu";
}
static const char* value(const ::sensor_msgs::Imu_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::Imu_<ContainerAllocator> >
{
static const char* value()
{
return "# This is a message to hold data from an IMU (Inertial Measurement Unit)\n"
"#\n"
"# Accelerations should be in m/s^2 (not in g's), and rotational velocity should be in rad/sec\n"
"#\n"
"# If the covariance of the measurement is known, it should be filled in (if all you know is the \n"
"# variance of each measurement, e.g. from the datasheet, just put those along the diagonal)\n"
"# A covariance matrix of all zeros will be interpreted as \"covariance unknown\", and to use the\n"
"# data a covariance will have to be assumed or gotten from some other source\n"
"#\n"
"# If you have no estimate for one of the data elements (e.g. your IMU doesn't produce an orientation \n"
"# estimate), please set element 0 of the associated covariance matrix to -1\n"
"# If you are interpreting this message, please check for a value of -1 in the first element of each \n"
"# covariance matrix, and disregard the associated estimate.\n"
"\n"
"Header header\n"
"\n"
"geometry_msgs/Quaternion orientation\n"
"float64[9] orientation_covariance # Row major about x, y, z axes\n"
"\n"
"geometry_msgs/Vector3 angular_velocity\n"
"float64[9] angular_velocity_covariance # Row major about x, y, z axes\n"
"\n"
"geometry_msgs/Vector3 linear_acceleration\n"
"float64[9] linear_acceleration_covariance # Row major x, y z \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"
"\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 ::sensor_msgs::Imu_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Imu_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.orientation);
stream.next(m.orientation_covariance);
stream.next(m.angular_velocity);
stream.next(m.angular_velocity_covariance);
stream.next(m.linear_acceleration);
stream.next(m.linear_acceleration_covariance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Imu_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::Imu_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Imu_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "orientation: ";
s << std::endl;
Printer< ::geometry_msgs::Quaternion_<ContainerAllocator> >::stream(s, indent + " ", v.orientation);
s << indent << "orientation_covariance[]" << std::endl;
for (size_t i = 0; i < v.orientation_covariance.size(); ++i)
{
s << indent << " orientation_covariance[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.orientation_covariance[i]);
}
s << indent << "angular_velocity: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.angular_velocity);
s << indent << "angular_velocity_covariance[]" << std::endl;
for (size_t i = 0; i < v.angular_velocity_covariance.size(); ++i)
{
s << indent << " angular_velocity_covariance[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.angular_velocity_covariance[i]);
}
s << indent << "linear_acceleration: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.linear_acceleration);
s << indent << "linear_acceleration_covariance[]" << std::endl;
for (size_t i = 0; i < v.linear_acceleration_covariance.size(); ++i)
{
s << indent << " linear_acceleration_covariance[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.linear_acceleration_covariance[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_IMU_H

290
thirdparty/ros/include/sensor_msgs/JointState.h vendored Normal file
View File

@@ -0,0 +1,290 @@
// Generated by gencpp from file sensor_msgs/JointState.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_JOINTSTATE_H
#define SENSOR_MSGS_MESSAGE_JOINTSTATE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct JointState_
{
typedef JointState_<ContainerAllocator> Type;
JointState_()
: header()
, name()
, position()
, velocity()
, effort() {
}
JointState_(const ContainerAllocator& _alloc)
: header(_alloc)
, name(_alloc)
, position(_alloc)
, velocity(_alloc)
, effort(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::vector<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>> _name_type;
_name_type name;
typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _position_type;
_position_type position;
typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _velocity_type;
_velocity_type velocity;
typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _effort_type;
_effort_type effort;
typedef boost::shared_ptr< ::sensor_msgs::JointState_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::JointState_<ContainerAllocator> const> ConstPtr;
}; // struct JointState_
typedef ::sensor_msgs::JointState_<std::allocator<void> > JointState;
typedef boost::shared_ptr< ::sensor_msgs::JointState > JointStatePtr;
typedef boost::shared_ptr< ::sensor_msgs::JointState const> JointStateConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JointState_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::JointState_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::JointState_<ContainerAllocator1> & lhs, const ::sensor_msgs::JointState_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.name == rhs.name &&
lhs.position == rhs.position &&
lhs.velocity == rhs.velocity &&
lhs.effort == rhs.effort;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::JointState_<ContainerAllocator1> & lhs, const ::sensor_msgs::JointState_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::JointState_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::JointState_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::JointState_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::JointState_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::JointState_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::JointState_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::JointState_<ContainerAllocator> >
{
static const char* value()
{
return "3066dcd76a6cfaef579bd0f34173e9fd";
}
static const char* value(const ::sensor_msgs::JointState_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x3066dcd76a6cfaefULL;
static const uint64_t static_value2 = 0x579bd0f34173e9fdULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::JointState_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/JointState";
}
static const char* value(const ::sensor_msgs::JointState_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::JointState_<ContainerAllocator> >
{
static const char* value()
{
return "# This is a message that holds data to describe the state of a set of torque controlled joints. \n"
"#\n"
"# The state of each joint (revolute or prismatic) is defined by:\n"
"# * the position of the joint (rad or m),\n"
"# * the velocity of the joint (rad/s or m/s) and \n"
"# * the effort that is applied in the joint (Nm or N).\n"
"#\n"
"# Each joint is uniquely identified by its name\n"
"# The header specifies the time at which the joint states were recorded. All the joint states\n"
"# in one message have to be recorded at the same time.\n"
"#\n"
"# This message consists of a multiple arrays, one for each part of the joint state. \n"
"# The goal is to make each of the fields optional. When e.g. your joints have no\n"
"# effort associated with them, you can leave the effort array empty. \n"
"#\n"
"# All arrays in this message should have the same size, or be empty.\n"
"# This is the only way to uniquely associate the joint name with the correct\n"
"# states.\n"
"\n"
"\n"
"Header header\n"
"\n"
"string[] name\n"
"float64[] position\n"
"float64[] velocity\n"
"float64[] effort\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"
;
}
static const char* value(const ::sensor_msgs::JointState_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::JointState_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.name);
stream.next(m.position);
stream.next(m.velocity);
stream.next(m.effort);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct JointState_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::JointState_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JointState_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "name[]" << std::endl;
for (size_t i = 0; i < v.name.size(); ++i)
{
s << indent << " name[" << i << "]: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.name[i]);
}
s << indent << "position[]" << std::endl;
for (size_t i = 0; i < v.position.size(); ++i)
{
s << indent << " position[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.position[i]);
}
s << indent << "velocity[]" << std::endl;
for (size_t i = 0; i < v.velocity.size(); ++i)
{
s << indent << " velocity[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.velocity[i]);
}
s << indent << "effort[]" << std::endl;
for (size_t i = 0; i < v.effort.size(); ++i)
{
s << indent << " effort[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.effort[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_JOINTSTATE_H

242
thirdparty/ros/include/sensor_msgs/Joy.h vendored Normal file
View File

@@ -0,0 +1,242 @@
// Generated by gencpp from file sensor_msgs/Joy.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_JOY_H
#define SENSOR_MSGS_MESSAGE_JOY_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct Joy_
{
typedef Joy_<ContainerAllocator> Type;
Joy_()
: header()
, axes()
, buttons() {
}
Joy_(const ContainerAllocator& _alloc)
: header(_alloc)
, axes(_alloc)
, buttons(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _axes_type;
_axes_type axes;
typedef std::vector<int32_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int32_t>> _buttons_type;
_buttons_type buttons;
typedef boost::shared_ptr< ::sensor_msgs::Joy_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::Joy_<ContainerAllocator> const> ConstPtr;
}; // struct Joy_
typedef ::sensor_msgs::Joy_<std::allocator<void> > Joy;
typedef boost::shared_ptr< ::sensor_msgs::Joy > JoyPtr;
typedef boost::shared_ptr< ::sensor_msgs::Joy const> JoyConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Joy_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::Joy_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::Joy_<ContainerAllocator1> & lhs, const ::sensor_msgs::Joy_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.axes == rhs.axes &&
lhs.buttons == rhs.buttons;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::Joy_<ContainerAllocator1> & lhs, const ::sensor_msgs::Joy_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Joy_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Joy_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Joy_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Joy_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Joy_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Joy_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::Joy_<ContainerAllocator> >
{
static const char* value()
{
return "5a9ea5f83505693b71e785041e67a8bb";
}
static const char* value(const ::sensor_msgs::Joy_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x5a9ea5f83505693bULL;
static const uint64_t static_value2 = 0x71e785041e67a8bbULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::Joy_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/Joy";
}
static const char* value(const ::sensor_msgs::Joy_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::Joy_<ContainerAllocator> >
{
static const char* value()
{
return "# Reports the state of a joysticks axes and buttons.\n"
"Header header # timestamp in the header is the time the data is received from the joystick\n"
"float32[] axes # the axes measurements from a joystick\n"
"int32[] buttons # the buttons measurements from a joystick \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"
;
}
static const char* value(const ::sensor_msgs::Joy_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Joy_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.axes);
stream.next(m.buttons);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Joy_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::Joy_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Joy_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "axes[]" << std::endl;
for (size_t i = 0; i < v.axes.size(); ++i)
{
s << indent << " axes[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.axes[i]);
}
s << indent << "buttons[]" << std::endl;
for (size_t i = 0; i < v.buttons.size(); ++i)
{
s << indent << " buttons[" << i << "]: ";
Printer<int32_t>::stream(s, indent + " ", v.buttons[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_JOY_H

249
thirdparty/ros/include/sensor_msgs/JoyFeedback.h vendored Normal file
View File

@@ -0,0 +1,249 @@
// Generated by gencpp from file sensor_msgs/JoyFeedback.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_JOYFEEDBACK_H
#define SENSOR_MSGS_MESSAGE_JOYFEEDBACK_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 sensor_msgs
{
template <class ContainerAllocator>
struct JoyFeedback_
{
typedef JoyFeedback_<ContainerAllocator> Type;
JoyFeedback_()
: type(0)
, id(0)
, intensity(0.0) {
}
JoyFeedback_(const ContainerAllocator& _alloc)
: type(0)
, id(0)
, intensity(0.0) {
(void)_alloc;
}
typedef uint8_t _type_type;
_type_type type;
typedef uint8_t _id_type;
_id_type id;
typedef float _intensity_type;
_intensity_type intensity;
// reducing the odds to have name collisions with Windows.h
#if defined(_WIN32) && defined(TYPE_LED)
#undef TYPE_LED
#endif
#if defined(_WIN32) && defined(TYPE_RUMBLE)
#undef TYPE_RUMBLE
#endif
#if defined(_WIN32) && defined(TYPE_BUZZER)
#undef TYPE_BUZZER
#endif
enum {
TYPE_LED = 0u,
TYPE_RUMBLE = 1u,
TYPE_BUZZER = 2u,
};
typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback_<ContainerAllocator> const> ConstPtr;
}; // struct JoyFeedback_
typedef ::sensor_msgs::JoyFeedback_<std::allocator<void> > JoyFeedback;
typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback > JoyFeedbackPtr;
typedef boost::shared_ptr< ::sensor_msgs::JoyFeedback const> JoyFeedbackConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JoyFeedback_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::JoyFeedback_<ContainerAllocator1> & lhs, const ::sensor_msgs::JoyFeedback_<ContainerAllocator2> & rhs)
{
return lhs.type == rhs.type &&
lhs.id == rhs.id &&
lhs.intensity == rhs.intensity;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::JoyFeedback_<ContainerAllocator1> & lhs, const ::sensor_msgs::JoyFeedback_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::JoyFeedback_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::JoyFeedback_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::JoyFeedback_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
{
static const char* value()
{
return "f4dcd73460360d98f36e55ee7f2e46f1";
}
static const char* value(const ::sensor_msgs::JoyFeedback_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xf4dcd73460360d98ULL;
static const uint64_t static_value2 = 0xf36e55ee7f2e46f1ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/JoyFeedback";
}
static const char* value(const ::sensor_msgs::JoyFeedback_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
{
static const char* value()
{
return "# Declare of the type of feedback\n"
"uint8 TYPE_LED = 0\n"
"uint8 TYPE_RUMBLE = 1\n"
"uint8 TYPE_BUZZER = 2\n"
"\n"
"uint8 type\n"
"\n"
"# This will hold an id number for each type of each feedback.\n"
"# Example, the first led would be id=0, the second would be id=1\n"
"uint8 id\n"
"\n"
"# Intensity of the feedback, from 0.0 to 1.0, inclusive. If device is\n"
"# actually binary, driver should treat 0<=x<0.5 as off, 0.5<=x<=1 as on.\n"
"float32 intensity\n"
"\n"
;
}
static const char* value(const ::sensor_msgs::JoyFeedback_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.type);
stream.next(m.id);
stream.next(m.intensity);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct JoyFeedback_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JoyFeedback_<ContainerAllocator>& v)
{
s << indent << "type: ";
Printer<uint8_t>::stream(s, indent + " ", v.type);
s << indent << "id: ";
Printer<uint8_t>::stream(s, indent + " ", v.id);
s << indent << "intensity: ";
Printer<float>::stream(s, indent + " ", v.intensity);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_JOYFEEDBACK_H

220
thirdparty/ros/include/sensor_msgs/JoyFeedbackArray.h vendored Normal file
View File

@@ -0,0 +1,220 @@
// Generated by gencpp from file sensor_msgs/JoyFeedbackArray.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_H
#define SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_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 <sensor_msgs/JoyFeedback.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct JoyFeedbackArray_
{
typedef JoyFeedbackArray_<ContainerAllocator> Type;
JoyFeedbackArray_()
: array() {
}
JoyFeedbackArray_(const ContainerAllocator& _alloc)
: array(_alloc) {
(void)_alloc;
}
typedef std::vector< ::sensor_msgs::JoyFeedback_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >> _array_type;
_array_type array;
typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> const> ConstPtr;
}; // struct JoyFeedbackArray_
typedef ::sensor_msgs::JoyFeedbackArray_<std::allocator<void> > JoyFeedbackArray;
typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray > JoyFeedbackArrayPtr;
typedef boost::shared_ptr< ::sensor_msgs::JoyFeedbackArray const> JoyFeedbackArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator1> & lhs, const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator2> & rhs)
{
return lhs.array == rhs.array;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator1> & lhs, const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
{
static const char* value()
{
return "cde5730a895b1fc4dee6f91b754b213d";
}
static const char* value(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xcde5730a895b1fc4ULL;
static const uint64_t static_value2 = 0xdee6f91b754b213dULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/JoyFeedbackArray";
}
static const char* value(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
{
static const char* value()
{
return "# This message publishes values for multiple feedback at once. \n"
"JoyFeedback[] array\n"
"================================================================================\n"
"MSG: sensor_msgs/JoyFeedback\n"
"# Declare of the type of feedback\n"
"uint8 TYPE_LED = 0\n"
"uint8 TYPE_RUMBLE = 1\n"
"uint8 TYPE_BUZZER = 2\n"
"\n"
"uint8 type\n"
"\n"
"# This will hold an id number for each type of each feedback.\n"
"# Example, the first led would be id=0, the second would be id=1\n"
"uint8 id\n"
"\n"
"# Intensity of the feedback, from 0.0 to 1.0, inclusive. If device is\n"
"# actually binary, driver should treat 0<=x<0.5 as off, 0.5<=x<=1 as on.\n"
"float32 intensity\n"
"\n"
;
}
static const char* value(const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.array);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct JoyFeedbackArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::JoyFeedbackArray_<ContainerAllocator>& v)
{
s << indent << "array[]" << std::endl;
for (size_t i = 0; i < v.array.size(); ++i)
{
s << indent << " array[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::sensor_msgs::JoyFeedback_<ContainerAllocator> >::stream(s, indent + " ", v.array[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_JOYFEEDBACKARRAY_H

203
thirdparty/ros/include/sensor_msgs/LaserEcho.h vendored Normal file
View File

@@ -0,0 +1,203 @@
// Generated by gencpp from file sensor_msgs/LaserEcho.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_LASERECHO_H
#define SENSOR_MSGS_MESSAGE_LASERECHO_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 sensor_msgs
{
template <class ContainerAllocator>
struct LaserEcho_
{
typedef LaserEcho_<ContainerAllocator> Type;
LaserEcho_()
: echoes() {
}
LaserEcho_(const ContainerAllocator& _alloc)
: echoes(_alloc) {
(void)_alloc;
}
typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _echoes_type;
_echoes_type echoes;
typedef boost::shared_ptr< ::sensor_msgs::LaserEcho_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::LaserEcho_<ContainerAllocator> const> ConstPtr;
}; // struct LaserEcho_
typedef ::sensor_msgs::LaserEcho_<std::allocator<void> > LaserEcho;
typedef boost::shared_ptr< ::sensor_msgs::LaserEcho > LaserEchoPtr;
typedef boost::shared_ptr< ::sensor_msgs::LaserEcho const> LaserEchoConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::LaserEcho_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::LaserEcho_<ContainerAllocator1> & lhs, const ::sensor_msgs::LaserEcho_<ContainerAllocator2> & rhs)
{
return lhs.echoes == rhs.echoes;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::LaserEcho_<ContainerAllocator1> & lhs, const ::sensor_msgs::LaserEcho_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::LaserEcho_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::LaserEcho_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::LaserEcho_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
{
static const char* value()
{
return "8bc5ae449b200fba4d552b4225586696";
}
static const char* value(const ::sensor_msgs::LaserEcho_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8bc5ae449b200fbaULL;
static const uint64_t static_value2 = 0x4d552b4225586696ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/LaserEcho";
}
static const char* value(const ::sensor_msgs::LaserEcho_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
{
static const char* value()
{
return "# This message is a submessage of MultiEchoLaserScan and is not intended\n"
"# to be used separately.\n"
"\n"
"float32[] echoes # Multiple values of ranges or intensities.\n"
" # Each array represents data from the same angle increment.\n"
;
}
static const char* value(const ::sensor_msgs::LaserEcho_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.echoes);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct LaserEcho_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::LaserEcho_<ContainerAllocator>& v)
{
s << indent << "echoes[]" << std::endl;
for (size_t i = 0; i < v.echoes.size(); ++i)
{
s << indent << " echoes[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.echoes[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_LASERECHO_H

330
thirdparty/ros/include/sensor_msgs/LaserScan.h vendored Normal file
View File

@@ -0,0 +1,330 @@
// Generated by gencpp from file sensor_msgs/LaserScan.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_LASERSCAN_H
#define SENSOR_MSGS_MESSAGE_LASERSCAN_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct LaserScan_
{
typedef LaserScan_<ContainerAllocator> Type;
LaserScan_()
: header()
, angle_min(0.0)
, angle_max(0.0)
, angle_increment(0.0)
, time_increment(0.0)
, scan_time(0.0)
, range_min(0.0)
, range_max(0.0)
, ranges()
, intensities() {
}
LaserScan_(const ContainerAllocator& _alloc)
: header(_alloc)
, angle_min(0.0)
, angle_max(0.0)
, angle_increment(0.0)
, time_increment(0.0)
, scan_time(0.0)
, range_min(0.0)
, range_max(0.0)
, ranges(_alloc)
, intensities(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef float _angle_min_type;
_angle_min_type angle_min;
typedef float _angle_max_type;
_angle_max_type angle_max;
typedef float _angle_increment_type;
_angle_increment_type angle_increment;
typedef float _time_increment_type;
_time_increment_type time_increment;
typedef float _scan_time_type;
_scan_time_type scan_time;
typedef float _range_min_type;
_range_min_type range_min;
typedef float _range_max_type;
_range_max_type range_max;
typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _ranges_type;
_ranges_type ranges;
typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _intensities_type;
_intensities_type intensities;
typedef boost::shared_ptr< ::sensor_msgs::LaserScan_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::LaserScan_<ContainerAllocator> const> ConstPtr;
}; // struct LaserScan_
typedef ::sensor_msgs::LaserScan_<std::allocator<void> > LaserScan;
typedef boost::shared_ptr< ::sensor_msgs::LaserScan > LaserScanPtr;
typedef boost::shared_ptr< ::sensor_msgs::LaserScan const> LaserScanConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::LaserScan_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::LaserScan_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::LaserScan_<ContainerAllocator1> & lhs, const ::sensor_msgs::LaserScan_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.angle_min == rhs.angle_min &&
lhs.angle_max == rhs.angle_max &&
lhs.angle_increment == rhs.angle_increment &&
lhs.time_increment == rhs.time_increment &&
lhs.scan_time == rhs.scan_time &&
lhs.range_min == rhs.range_min &&
lhs.range_max == rhs.range_max &&
lhs.ranges == rhs.ranges &&
lhs.intensities == rhs.intensities;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::LaserScan_<ContainerAllocator1> & lhs, const ::sensor_msgs::LaserScan_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::LaserScan_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::LaserScan_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::LaserScan_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::LaserScan_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::LaserScan_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::LaserScan_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::LaserScan_<ContainerAllocator> >
{
static const char* value()
{
return "90c7ef2dc6895d81024acba2ac42f369";
}
static const char* value(const ::sensor_msgs::LaserScan_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x90c7ef2dc6895d81ULL;
static const uint64_t static_value2 = 0x024acba2ac42f369ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::LaserScan_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/LaserScan";
}
static const char* value(const ::sensor_msgs::LaserScan_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::LaserScan_<ContainerAllocator> >
{
static const char* value()
{
return "# Single scan from a planar laser range-finder\n"
"#\n"
"# If you have another ranging device with different behavior (e.g. a sonar\n"
"# array), please find or create a different message, since applications\n"
"# will make fairly laser-specific assumptions about this data\n"
"\n"
"Header header # timestamp in the header is the acquisition time of \n"
" # the first ray in the scan.\n"
" #\n"
" # in frame frame_id, angles are measured around \n"
" # the positive Z axis (counterclockwise, if Z is up)\n"
" # with zero angle being forward along the x axis\n"
" \n"
"float32 angle_min # start angle of the scan [rad]\n"
"float32 angle_max # end angle of the scan [rad]\n"
"float32 angle_increment # angular distance between measurements [rad]\n"
"\n"
"float32 time_increment # time between measurements [seconds] - if your scanner\n"
" # is moving, this will be used in interpolating position\n"
" # of 3d points\n"
"float32 scan_time # time between scans [seconds]\n"
"\n"
"float32 range_min # minimum range value [m]\n"
"float32 range_max # maximum range value [m]\n"
"\n"
"float32[] ranges # range data [m] (Note: values < range_min or > range_max should be discarded)\n"
"float32[] intensities # intensity data [device-specific units]. If your\n"
" # device does not provide intensities, please leave\n"
" # the array empty.\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"
;
}
static const char* value(const ::sensor_msgs::LaserScan_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::LaserScan_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.angle_min);
stream.next(m.angle_max);
stream.next(m.angle_increment);
stream.next(m.time_increment);
stream.next(m.scan_time);
stream.next(m.range_min);
stream.next(m.range_max);
stream.next(m.ranges);
stream.next(m.intensities);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct LaserScan_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::LaserScan_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::LaserScan_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "angle_min: ";
Printer<float>::stream(s, indent + " ", v.angle_min);
s << indent << "angle_max: ";
Printer<float>::stream(s, indent + " ", v.angle_max);
s << indent << "angle_increment: ";
Printer<float>::stream(s, indent + " ", v.angle_increment);
s << indent << "time_increment: ";
Printer<float>::stream(s, indent + " ", v.time_increment);
s << indent << "scan_time: ";
Printer<float>::stream(s, indent + " ", v.scan_time);
s << indent << "range_min: ";
Printer<float>::stream(s, indent + " ", v.range_min);
s << indent << "range_max: ";
Printer<float>::stream(s, indent + " ", v.range_max);
s << indent << "ranges[]" << std::endl;
for (size_t i = 0; i < v.ranges.size(); ++i)
{
s << indent << " ranges[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.ranges[i]);
}
s << indent << "intensities[]" << std::endl;
for (size_t i = 0; i < v.intensities.size(); ++i)
{
s << indent << " intensities[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.intensities[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_LASERSCAN_H

272
thirdparty/ros/include/sensor_msgs/MagneticField.h vendored Normal file
View File

@@ -0,0 +1,272 @@
// Generated by gencpp from file sensor_msgs/MagneticField.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_MAGNETICFIELD_H
#define SENSOR_MSGS_MESSAGE_MAGNETICFIELD_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 sensor_msgs
{
template <class ContainerAllocator>
struct MagneticField_
{
typedef MagneticField_<ContainerAllocator> Type;
MagneticField_()
: header()
, magnetic_field()
, magnetic_field_covariance() {
magnetic_field_covariance.assign(0.0);
}
MagneticField_(const ContainerAllocator& _alloc)
: header(_alloc)
, magnetic_field(_alloc)
, magnetic_field_covariance() {
(void)_alloc;
magnetic_field_covariance.assign(0.0);
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::geometry_msgs::Vector3_<ContainerAllocator> _magnetic_field_type;
_magnetic_field_type magnetic_field;
typedef boost::array<double, 9> _magnetic_field_covariance_type;
_magnetic_field_covariance_type magnetic_field_covariance;
typedef boost::shared_ptr< ::sensor_msgs::MagneticField_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::MagneticField_<ContainerAllocator> const> ConstPtr;
}; // struct MagneticField_
typedef ::sensor_msgs::MagneticField_<std::allocator<void> > MagneticField;
typedef boost::shared_ptr< ::sensor_msgs::MagneticField > MagneticFieldPtr;
typedef boost::shared_ptr< ::sensor_msgs::MagneticField const> MagneticFieldConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MagneticField_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::MagneticField_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::MagneticField_<ContainerAllocator1> & lhs, const ::sensor_msgs::MagneticField_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.magnetic_field == rhs.magnetic_field &&
lhs.magnetic_field_covariance == rhs.magnetic_field_covariance;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::MagneticField_<ContainerAllocator1> & lhs, const ::sensor_msgs::MagneticField_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::MagneticField_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::MagneticField_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::MagneticField_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::MagneticField_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::MagneticField_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::MagneticField_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::MagneticField_<ContainerAllocator> >
{
static const char* value()
{
return "2f3b0b43eed0c9501de0fa3ff89a45aa";
}
static const char* value(const ::sensor_msgs::MagneticField_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x2f3b0b43eed0c950ULL;
static const uint64_t static_value2 = 0x1de0fa3ff89a45aaULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::MagneticField_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/MagneticField";
}
static const char* value(const ::sensor_msgs::MagneticField_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::MagneticField_<ContainerAllocator> >
{
static const char* value()
{
return " # Measurement of the Magnetic Field vector at a specific location.\n"
"\n"
" # If the covariance of the measurement is known, it should be filled in\n"
" # (if all you know is the variance of each measurement, e.g. from the datasheet,\n"
" #just put those along the diagonal)\n"
" # A covariance matrix of all zeros will be interpreted as \"covariance unknown\",\n"
" # and to use the data a covariance will have to be assumed or gotten from some\n"
" # other source\n"
"\n"
"\n"
" Header header # timestamp is the time the\n"
" # field was measured\n"
" # frame_id is the location and orientation\n"
" # of the field measurement\n"
"\n"
" geometry_msgs/Vector3 magnetic_field # x, y, and z components of the\n"
" # field vector in Tesla\n"
" # If your sensor does not output 3 axes,\n"
" # put NaNs in the components not reported.\n"
"\n"
" float64[9] magnetic_field_covariance # Row major about x, y, z axes\n"
" # 0 is interpreted as variance unknown\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 ::sensor_msgs::MagneticField_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::MagneticField_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.magnetic_field);
stream.next(m.magnetic_field_covariance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct MagneticField_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::MagneticField_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MagneticField_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "magnetic_field: ";
s << std::endl;
Printer< ::geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + " ", v.magnetic_field);
s << indent << "magnetic_field_covariance[]" << std::endl;
for (size_t i = 0; i < v.magnetic_field_covariance.size(); ++i)
{
s << indent << " magnetic_field_covariance[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.magnetic_field_covariance[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_MAGNETICFIELD_H

340
thirdparty/ros/include/sensor_msgs/MultiDOFJointState.h vendored Normal file
View File

@@ -0,0 +1,340 @@
// Generated by gencpp from file sensor_msgs/MultiDOFJointState.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_H
#define SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_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>
#include <geometry_msgs/Twist.h>
#include <geometry_msgs/Wrench.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct MultiDOFJointState_
{
typedef MultiDOFJointState_<ContainerAllocator> Type;
MultiDOFJointState_()
: header()
, joint_names()
, transforms()
, twist()
, wrench() {
}
MultiDOFJointState_(const ContainerAllocator& _alloc)
: header(_alloc)
, joint_names(_alloc)
, transforms(_alloc)
, twist(_alloc)
, wrench(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::vector<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>> _joint_names_type;
_joint_names_type joint_names;
typedef std::vector< ::geometry_msgs::Transform_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::geometry_msgs::Transform_<ContainerAllocator> >> _transforms_type;
_transforms_type transforms;
typedef std::vector< ::geometry_msgs::Twist_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::geometry_msgs::Twist_<ContainerAllocator> >> _twist_type;
_twist_type twist;
typedef std::vector< ::geometry_msgs::Wrench_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::geometry_msgs::Wrench_<ContainerAllocator> >> _wrench_type;
_wrench_type wrench;
typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> const> ConstPtr;
}; // struct MultiDOFJointState_
typedef ::sensor_msgs::MultiDOFJointState_<std::allocator<void> > MultiDOFJointState;
typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState > MultiDOFJointStatePtr;
typedef boost::shared_ptr< ::sensor_msgs::MultiDOFJointState const> MultiDOFJointStateConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator1> & lhs, const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.joint_names == rhs.joint_names &&
lhs.transforms == rhs.transforms &&
lhs.twist == rhs.twist &&
lhs.wrench == rhs.wrench;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator1> & lhs, const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
{
static const char* value()
{
return "690f272f0640d2631c305eeb8301e59d";
}
static const char* value(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x690f272f0640d263ULL;
static const uint64_t static_value2 = 0x1c305eeb8301e59dULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/MultiDOFJointState";
}
static const char* value(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
{
static const char* value()
{
return "# Representation of state for joints with multiple degrees of freedom, \n"
"# following the structure of JointState.\n"
"#\n"
"# It is assumed that a joint in a system corresponds to a transform that gets applied \n"
"# along the kinematic chain. For example, a planar joint (as in URDF) is 3DOF (x, y, yaw)\n"
"# and those 3DOF can be expressed as a transformation matrix, and that transformation\n"
"# matrix can be converted back to (x, y, yaw)\n"
"#\n"
"# Each joint is uniquely identified by its name\n"
"# The header specifies the time at which the joint states were recorded. All the joint states\n"
"# in one message have to be recorded at the same time.\n"
"#\n"
"# This message consists of a multiple arrays, one for each part of the joint state. \n"
"# The goal is to make each of the fields optional. When e.g. your joints have no\n"
"# wrench associated with them, you can leave the wrench array empty. \n"
"#\n"
"# All arrays in this message should have the same size, or be empty.\n"
"# This is the only way to uniquely associate the joint name with the correct\n"
"# states.\n"
"\n"
"Header header\n"
"\n"
"string[] joint_names\n"
"geometry_msgs/Transform[] transforms\n"
"geometry_msgs/Twist[] twist\n"
"geometry_msgs/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/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"
"\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/Wrench\n"
"# This represents force in free space, separated into\n"
"# its linear and angular parts.\n"
"Vector3 force\n"
"Vector3 torque\n"
;
}
static const char* value(const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.joint_names);
stream.next(m.transforms);
stream.next(m.twist);
stream.next(m.wrench);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct MultiDOFJointState_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::MultiDOFJointState_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MultiDOFJointState_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "joint_names[]" << std::endl;
for (size_t i = 0; i < v.joint_names.size(); ++i)
{
s << indent << " joint_names[" << i << "]: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.joint_names[i]);
}
s << indent << "transforms[]" << std::endl;
for (size_t i = 0; i < v.transforms.size(); ++i)
{
s << indent << " transforms[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::geometry_msgs::Transform_<ContainerAllocator> >::stream(s, indent + " ", v.transforms[i]);
}
s << indent << "twist[]" << std::endl;
for (size_t i = 0; i < v.twist.size(); ++i)
{
s << indent << " twist[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::geometry_msgs::Twist_<ContainerAllocator> >::stream(s, indent + " ", v.twist[i]);
}
s << indent << "wrench[]" << std::endl;
for (size_t i = 0; i < v.wrench.size(); ++i)
{
s << indent << " wrench[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::geometry_msgs::Wrench_<ContainerAllocator> >::stream(s, indent + " ", v.wrench[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_MULTIDOFJOINTSTATE_H

345
thirdparty/ros/include/sensor_msgs/MultiEchoLaserScan.h vendored Normal file
View File

@@ -0,0 +1,345 @@
// Generated by gencpp from file sensor_msgs/MultiEchoLaserScan.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_H
#define SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_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 <sensor_msgs/LaserEcho.h>
#include <sensor_msgs/LaserEcho.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct MultiEchoLaserScan_
{
typedef MultiEchoLaserScan_<ContainerAllocator> Type;
MultiEchoLaserScan_()
: header()
, angle_min(0.0)
, angle_max(0.0)
, angle_increment(0.0)
, time_increment(0.0)
, scan_time(0.0)
, range_min(0.0)
, range_max(0.0)
, ranges()
, intensities() {
}
MultiEchoLaserScan_(const ContainerAllocator& _alloc)
: header(_alloc)
, angle_min(0.0)
, angle_max(0.0)
, angle_increment(0.0)
, time_increment(0.0)
, scan_time(0.0)
, range_min(0.0)
, range_max(0.0)
, ranges(_alloc)
, intensities(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef float _angle_min_type;
_angle_min_type angle_min;
typedef float _angle_max_type;
_angle_max_type angle_max;
typedef float _angle_increment_type;
_angle_increment_type angle_increment;
typedef float _time_increment_type;
_time_increment_type time_increment;
typedef float _scan_time_type;
_scan_time_type scan_time;
typedef float _range_min_type;
_range_min_type range_min;
typedef float _range_max_type;
_range_max_type range_max;
typedef std::vector< ::sensor_msgs::LaserEcho_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::LaserEcho_<ContainerAllocator> >> _ranges_type;
_ranges_type ranges;
typedef std::vector< ::sensor_msgs::LaserEcho_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::LaserEcho_<ContainerAllocator> >> _intensities_type;
_intensities_type intensities;
typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> const> ConstPtr;
}; // struct MultiEchoLaserScan_
typedef ::sensor_msgs::MultiEchoLaserScan_<std::allocator<void> > MultiEchoLaserScan;
typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan > MultiEchoLaserScanPtr;
typedef boost::shared_ptr< ::sensor_msgs::MultiEchoLaserScan const> MultiEchoLaserScanConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator1> & lhs, const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.angle_min == rhs.angle_min &&
lhs.angle_max == rhs.angle_max &&
lhs.angle_increment == rhs.angle_increment &&
lhs.time_increment == rhs.time_increment &&
lhs.scan_time == rhs.scan_time &&
lhs.range_min == rhs.range_min &&
lhs.range_max == rhs.range_max &&
lhs.ranges == rhs.ranges &&
lhs.intensities == rhs.intensities;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator1> & lhs, const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
{
static const char* value()
{
return "6fefb0c6da89d7c8abe4b339f5c2f8fb";
}
static const char* value(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x6fefb0c6da89d7c8ULL;
static const uint64_t static_value2 = 0xabe4b339f5c2f8fbULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/MultiEchoLaserScan";
}
static const char* value(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
{
static const char* value()
{
return "# Single scan from a multi-echo planar laser range-finder\n"
"#\n"
"# If you have another ranging device with different behavior (e.g. a sonar\n"
"# array), please find or create a different message, since applications\n"
"# will make fairly laser-specific assumptions about this data\n"
"\n"
"Header header # timestamp in the header is the acquisition time of \n"
" # the first ray in the scan.\n"
" #\n"
" # in frame frame_id, angles are measured around \n"
" # the positive Z axis (counterclockwise, if Z is up)\n"
" # with zero angle being forward along the x axis\n"
" \n"
"float32 angle_min # start angle of the scan [rad]\n"
"float32 angle_max # end angle of the scan [rad]\n"
"float32 angle_increment # angular distance between measurements [rad]\n"
"\n"
"float32 time_increment # time between measurements [seconds] - if your scanner\n"
" # is moving, this will be used in interpolating position\n"
" # of 3d points\n"
"float32 scan_time # time between scans [seconds]\n"
"\n"
"float32 range_min # minimum range value [m]\n"
"float32 range_max # maximum range value [m]\n"
"\n"
"LaserEcho[] ranges # range data [m] (Note: NaNs, values < range_min or > range_max should be discarded)\n"
" # +Inf measurements are out of range\n"
" # -Inf measurements are too close to determine exact distance.\n"
"LaserEcho[] intensities # intensity data [device-specific units]. If your\n"
" # device does not provide intensities, please leave\n"
" # the array empty.\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: sensor_msgs/LaserEcho\n"
"# This message is a submessage of MultiEchoLaserScan and is not intended\n"
"# to be used separately.\n"
"\n"
"float32[] echoes # Multiple values of ranges or intensities.\n"
" # Each array represents data from the same angle increment.\n"
;
}
static const char* value(const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.angle_min);
stream.next(m.angle_max);
stream.next(m.angle_increment);
stream.next(m.time_increment);
stream.next(m.scan_time);
stream.next(m.range_min);
stream.next(m.range_max);
stream.next(m.ranges);
stream.next(m.intensities);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct MultiEchoLaserScan_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::MultiEchoLaserScan_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "angle_min: ";
Printer<float>::stream(s, indent + " ", v.angle_min);
s << indent << "angle_max: ";
Printer<float>::stream(s, indent + " ", v.angle_max);
s << indent << "angle_increment: ";
Printer<float>::stream(s, indent + " ", v.angle_increment);
s << indent << "time_increment: ";
Printer<float>::stream(s, indent + " ", v.time_increment);
s << indent << "scan_time: ";
Printer<float>::stream(s, indent + " ", v.scan_time);
s << indent << "range_min: ";
Printer<float>::stream(s, indent + " ", v.range_min);
s << indent << "range_max: ";
Printer<float>::stream(s, indent + " ", v.range_max);
s << indent << "ranges[]" << std::endl;
for (size_t i = 0; i < v.ranges.size(); ++i)
{
s << indent << " ranges[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >::stream(s, indent + " ", v.ranges[i]);
}
s << indent << "intensities[]" << std::endl;
for (size_t i = 0; i < v.intensities.size(); ++i)
{
s << indent << " intensities[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::sensor_msgs::LaserEcho_<ContainerAllocator> >::stream(s, indent + " ", v.intensities[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_MULTIECHOLASERSCAN_H

373
thirdparty/ros/include/sensor_msgs/NavSatFix.h vendored Normal file
View File

@@ -0,0 +1,373 @@
// Generated by gencpp from file sensor_msgs/NavSatFix.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_NAVSATFIX_H
#define SENSOR_MSGS_MESSAGE_NAVSATFIX_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 <sensor_msgs/NavSatStatus.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct NavSatFix_
{
typedef NavSatFix_<ContainerAllocator> Type;
NavSatFix_()
: header()
, status()
, latitude(0.0)
, longitude(0.0)
, altitude(0.0)
, position_covariance()
, position_covariance_type(0) {
position_covariance.assign(0.0);
}
NavSatFix_(const ContainerAllocator& _alloc)
: header(_alloc)
, status(_alloc)
, latitude(0.0)
, longitude(0.0)
, altitude(0.0)
, position_covariance()
, position_covariance_type(0) {
(void)_alloc;
position_covariance.assign(0.0);
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ::sensor_msgs::NavSatStatus_<ContainerAllocator> _status_type;
_status_type status;
typedef double _latitude_type;
_latitude_type latitude;
typedef double _longitude_type;
_longitude_type longitude;
typedef double _altitude_type;
_altitude_type altitude;
typedef boost::array<double, 9> _position_covariance_type;
_position_covariance_type position_covariance;
typedef uint8_t _position_covariance_type_type;
_position_covariance_type_type position_covariance_type;
// reducing the odds to have name collisions with Windows.h
#if defined(_WIN32) && defined(COVARIANCE_TYPE_UNKNOWN)
#undef COVARIANCE_TYPE_UNKNOWN
#endif
#if defined(_WIN32) && defined(COVARIANCE_TYPE_APPROXIMATED)
#undef COVARIANCE_TYPE_APPROXIMATED
#endif
#if defined(_WIN32) && defined(COVARIANCE_TYPE_DIAGONAL_KNOWN)
#undef COVARIANCE_TYPE_DIAGONAL_KNOWN
#endif
#if defined(_WIN32) && defined(COVARIANCE_TYPE_KNOWN)
#undef COVARIANCE_TYPE_KNOWN
#endif
enum {
COVARIANCE_TYPE_UNKNOWN = 0u,
COVARIANCE_TYPE_APPROXIMATED = 1u,
COVARIANCE_TYPE_DIAGONAL_KNOWN = 2u,
COVARIANCE_TYPE_KNOWN = 3u,
};
typedef boost::shared_ptr< ::sensor_msgs::NavSatFix_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::NavSatFix_<ContainerAllocator> const> ConstPtr;
}; // struct NavSatFix_
typedef ::sensor_msgs::NavSatFix_<std::allocator<void> > NavSatFix;
typedef boost::shared_ptr< ::sensor_msgs::NavSatFix > NavSatFixPtr;
typedef boost::shared_ptr< ::sensor_msgs::NavSatFix const> NavSatFixConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::NavSatFix_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::NavSatFix_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::NavSatFix_<ContainerAllocator1> & lhs, const ::sensor_msgs::NavSatFix_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.status == rhs.status &&
lhs.latitude == rhs.latitude &&
lhs.longitude == rhs.longitude &&
lhs.altitude == rhs.altitude &&
lhs.position_covariance == rhs.position_covariance &&
lhs.position_covariance_type == rhs.position_covariance_type;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::NavSatFix_<ContainerAllocator1> & lhs, const ::sensor_msgs::NavSatFix_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::NavSatFix_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::NavSatFix_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::NavSatFix_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
{
static const char* value()
{
return "2d3a8cd499b9b4a0249fb98fd05cfa48";
}
static const char* value(const ::sensor_msgs::NavSatFix_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x2d3a8cd499b9b4a0ULL;
static const uint64_t static_value2 = 0x249fb98fd05cfa48ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/NavSatFix";
}
static const char* value(const ::sensor_msgs::NavSatFix_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
{
static const char* value()
{
return "# Navigation Satellite fix for any Global Navigation Satellite System\n"
"#\n"
"# Specified using the WGS 84 reference ellipsoid\n"
"\n"
"# header.stamp specifies the ROS time for this measurement (the\n"
"# corresponding satellite time may be reported using the\n"
"# sensor_msgs/TimeReference message).\n"
"#\n"
"# header.frame_id is the frame of reference reported by the satellite\n"
"# receiver, usually the location of the antenna. This is a\n"
"# Euclidean frame relative to the vehicle, not a reference\n"
"# ellipsoid.\n"
"Header header\n"
"\n"
"# satellite fix status information\n"
"NavSatStatus status\n"
"\n"
"# Latitude [degrees]. Positive is north of equator; negative is south.\n"
"float64 latitude\n"
"\n"
"# Longitude [degrees]. Positive is east of prime meridian; negative is west.\n"
"float64 longitude\n"
"\n"
"# Altitude [m]. Positive is above the WGS 84 ellipsoid\n"
"# (quiet NaN if no altitude is available).\n"
"float64 altitude\n"
"\n"
"# Position covariance [m^2] defined relative to a tangential plane\n"
"# through the reported position. The components are East, North, and\n"
"# Up (ENU), in row-major order.\n"
"#\n"
"# Beware: this coordinate system exhibits singularities at the poles.\n"
"\n"
"float64[9] position_covariance\n"
"\n"
"# If the covariance of the fix is known, fill it in completely. If the\n"
"# GPS receiver provides the variance of each measurement, put them\n"
"# along the diagonal. If only Dilution of Precision is available,\n"
"# estimate an approximate covariance from that.\n"
"\n"
"uint8 COVARIANCE_TYPE_UNKNOWN = 0\n"
"uint8 COVARIANCE_TYPE_APPROXIMATED = 1\n"
"uint8 COVARIANCE_TYPE_DIAGONAL_KNOWN = 2\n"
"uint8 COVARIANCE_TYPE_KNOWN = 3\n"
"\n"
"uint8 position_covariance_type\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: sensor_msgs/NavSatStatus\n"
"# Navigation Satellite fix status for any Global Navigation Satellite System\n"
"\n"
"# Whether to output an augmented fix is determined by both the fix\n"
"# type and the last time differential corrections were received. A\n"
"# fix is valid when status >= STATUS_FIX.\n"
"\n"
"int8 STATUS_NO_FIX = -1 # unable to fix position\n"
"int8 STATUS_FIX = 0 # unaugmented fix\n"
"int8 STATUS_SBAS_FIX = 1 # with satellite-based augmentation\n"
"int8 STATUS_GBAS_FIX = 2 # with ground-based augmentation\n"
"\n"
"int8 status\n"
"\n"
"# Bits defining which Global Navigation Satellite System signals were\n"
"# used by the receiver.\n"
"\n"
"uint16 SERVICE_GPS = 1\n"
"uint16 SERVICE_GLONASS = 2\n"
"uint16 SERVICE_COMPASS = 4 # includes BeiDou.\n"
"uint16 SERVICE_GALILEO = 8\n"
"\n"
"uint16 service\n"
;
}
static const char* value(const ::sensor_msgs::NavSatFix_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.status);
stream.next(m.latitude);
stream.next(m.longitude);
stream.next(m.altitude);
stream.next(m.position_covariance);
stream.next(m.position_covariance_type);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct NavSatFix_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::NavSatFix_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::NavSatFix_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "status: ";
s << std::endl;
Printer< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >::stream(s, indent + " ", v.status);
s << indent << "latitude: ";
Printer<double>::stream(s, indent + " ", v.latitude);
s << indent << "longitude: ";
Printer<double>::stream(s, indent + " ", v.longitude);
s << indent << "altitude: ";
Printer<double>::stream(s, indent + " ", v.altitude);
s << indent << "position_covariance[]" << std::endl;
for (size_t i = 0; i < v.position_covariance.size(); ++i)
{
s << indent << " position_covariance[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.position_covariance[i]);
}
s << indent << "position_covariance_type: ";
Printer<uint8_t>::stream(s, indent + " ", v.position_covariance_type);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_NAVSATFIX_H

277
thirdparty/ros/include/sensor_msgs/NavSatStatus.h vendored Normal file
View File

@@ -0,0 +1,277 @@
// Generated by gencpp from file sensor_msgs/NavSatStatus.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_NAVSATSTATUS_H
#define SENSOR_MSGS_MESSAGE_NAVSATSTATUS_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 sensor_msgs
{
template <class ContainerAllocator>
struct NavSatStatus_
{
typedef NavSatStatus_<ContainerAllocator> Type;
NavSatStatus_()
: status(0)
, service(0) {
}
NavSatStatus_(const ContainerAllocator& _alloc)
: status(0)
, service(0) {
(void)_alloc;
}
typedef int8_t _status_type;
_status_type status;
typedef uint16_t _service_type;
_service_type service;
// reducing the odds to have name collisions with Windows.h
#if defined(_WIN32) && defined(STATUS_NO_FIX)
#undef STATUS_NO_FIX
#endif
#if defined(_WIN32) && defined(STATUS_FIX)
#undef STATUS_FIX
#endif
#if defined(_WIN32) && defined(STATUS_SBAS_FIX)
#undef STATUS_SBAS_FIX
#endif
#if defined(_WIN32) && defined(STATUS_GBAS_FIX)
#undef STATUS_GBAS_FIX
#endif
#if defined(_WIN32) && defined(SERVICE_GPS)
#undef SERVICE_GPS
#endif
#if defined(_WIN32) && defined(SERVICE_GLONASS)
#undef SERVICE_GLONASS
#endif
#if defined(_WIN32) && defined(SERVICE_COMPASS)
#undef SERVICE_COMPASS
#endif
#if defined(_WIN32) && defined(SERVICE_GALILEO)
#undef SERVICE_GALILEO
#endif
enum {
STATUS_NO_FIX = -1,
STATUS_FIX = 0,
STATUS_SBAS_FIX = 1,
STATUS_GBAS_FIX = 2,
SERVICE_GPS = 1u,
SERVICE_GLONASS = 2u,
SERVICE_COMPASS = 4u,
SERVICE_GALILEO = 8u,
};
typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus_<ContainerAllocator> const> ConstPtr;
}; // struct NavSatStatus_
typedef ::sensor_msgs::NavSatStatus_<std::allocator<void> > NavSatStatus;
typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus > NavSatStatusPtr;
typedef boost::shared_ptr< ::sensor_msgs::NavSatStatus const> NavSatStatusConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::NavSatStatus_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::NavSatStatus_<ContainerAllocator1> & lhs, const ::sensor_msgs::NavSatStatus_<ContainerAllocator2> & rhs)
{
return lhs.status == rhs.status &&
lhs.service == rhs.service;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::NavSatStatus_<ContainerAllocator1> & lhs, const ::sensor_msgs::NavSatStatus_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::NavSatStatus_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::NavSatStatus_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::NavSatStatus_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
{
static const char* value()
{
return "331cdbddfa4bc96ffc3b9ad98900a54c";
}
static const char* value(const ::sensor_msgs::NavSatStatus_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x331cdbddfa4bc96fULL;
static const uint64_t static_value2 = 0xfc3b9ad98900a54cULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/NavSatStatus";
}
static const char* value(const ::sensor_msgs::NavSatStatus_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
{
static const char* value()
{
return "# Navigation Satellite fix status for any Global Navigation Satellite System\n"
"\n"
"# Whether to output an augmented fix is determined by both the fix\n"
"# type and the last time differential corrections were received. A\n"
"# fix is valid when status >= STATUS_FIX.\n"
"\n"
"int8 STATUS_NO_FIX = -1 # unable to fix position\n"
"int8 STATUS_FIX = 0 # unaugmented fix\n"
"int8 STATUS_SBAS_FIX = 1 # with satellite-based augmentation\n"
"int8 STATUS_GBAS_FIX = 2 # with ground-based augmentation\n"
"\n"
"int8 status\n"
"\n"
"# Bits defining which Global Navigation Satellite System signals were\n"
"# used by the receiver.\n"
"\n"
"uint16 SERVICE_GPS = 1\n"
"uint16 SERVICE_GLONASS = 2\n"
"uint16 SERVICE_COMPASS = 4 # includes BeiDou.\n"
"uint16 SERVICE_GALILEO = 8\n"
"\n"
"uint16 service\n"
;
}
static const char* value(const ::sensor_msgs::NavSatStatus_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.status);
stream.next(m.service);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct NavSatStatus_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::NavSatStatus_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::NavSatStatus_<ContainerAllocator>& v)
{
s << indent << "status: ";
Printer<int8_t>::stream(s, indent + " ", v.status);
s << indent << "service: ";
Printer<uint16_t>::stream(s, indent + " ", v.service);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_NAVSATSTATUS_H

298
thirdparty/ros/include/sensor_msgs/PointCloud.h vendored Normal file
View File

@@ -0,0 +1,298 @@
// Generated by gencpp from file sensor_msgs/PointCloud.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_POINTCLOUD_H
#define SENSOR_MSGS_MESSAGE_POINTCLOUD_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/Point32.h>
#include <sensor_msgs/ChannelFloat32.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct PointCloud_
{
typedef PointCloud_<ContainerAllocator> Type;
PointCloud_()
: header()
, points()
, channels() {
}
PointCloud_(const ContainerAllocator& _alloc)
: header(_alloc)
, points(_alloc)
, channels(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
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 std::vector< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >> _channels_type;
_channels_type channels;
typedef boost::shared_ptr< ::sensor_msgs::PointCloud_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::PointCloud_<ContainerAllocator> const> ConstPtr;
}; // struct PointCloud_
typedef ::sensor_msgs::PointCloud_<std::allocator<void> > PointCloud;
typedef boost::shared_ptr< ::sensor_msgs::PointCloud > PointCloudPtr;
typedef boost::shared_ptr< ::sensor_msgs::PointCloud const> PointCloudConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointCloud_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::PointCloud_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::PointCloud_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointCloud_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.points == rhs.points &&
lhs.channels == rhs.channels;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::PointCloud_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointCloud_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::PointCloud_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::PointCloud_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::PointCloud_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::PointCloud_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::PointCloud_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::PointCloud_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::PointCloud_<ContainerAllocator> >
{
static const char* value()
{
return "d8e9c3f5afbdd8a130fd1d2763945fca";
}
static const char* value(const ::sensor_msgs::PointCloud_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xd8e9c3f5afbdd8a1ULL;
static const uint64_t static_value2 = 0x30fd1d2763945fcaULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::PointCloud_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/PointCloud";
}
static const char* value(const ::sensor_msgs::PointCloud_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::PointCloud_<ContainerAllocator> >
{
static const char* value()
{
return "# This message holds a collection of 3d points, plus optional additional\n"
"# information about each point.\n"
"\n"
"# Time of sensor data acquisition, coordinate frame ID.\n"
"Header header\n"
"\n"
"# Array of 3d points. Each Point32 should be interpreted as a 3d point\n"
"# in the frame given in the header.\n"
"geometry_msgs/Point32[] points\n"
"\n"
"# Each channel should have the same number of elements as points array,\n"
"# and the data in each channel should correspond 1:1 with each point.\n"
"# Channel names in common practice are listed in ChannelFloat32.msg.\n"
"ChannelFloat32[] channels\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/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"
"================================================================================\n"
"MSG: sensor_msgs/ChannelFloat32\n"
"# This message is used by the PointCloud message to hold optional data\n"
"# associated with each point in the cloud. The length of the values\n"
"# array should be the same as the length of the points array in the\n"
"# PointCloud, and each value should be associated with the corresponding\n"
"# point.\n"
"\n"
"# Channel names in existing practice include:\n"
"# \"u\", \"v\" - row and column (respectively) in the left stereo image.\n"
"# This is opposite to usual conventions but remains for\n"
"# historical reasons. The newer PointCloud2 message has no\n"
"# such problem.\n"
"# \"rgb\" - For point clouds produced by color stereo cameras. uint8\n"
"# (R,G,B) values packed into the least significant 24 bits,\n"
"# in order.\n"
"# \"intensity\" - laser or pixel intensity.\n"
"# \"distance\"\n"
"\n"
"# The channel name should give semantics of the channel (e.g.\n"
"# \"intensity\" instead of \"value\").\n"
"string name\n"
"\n"
"# The values array should be 1-1 with the elements of the associated\n"
"# PointCloud.\n"
"float32[] values\n"
;
}
static const char* value(const ::sensor_msgs::PointCloud_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::PointCloud_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.points);
stream.next(m.channels);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PointCloud_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::PointCloud_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointCloud_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
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]);
}
s << indent << "channels[]" << std::endl;
for (size_t i = 0; i < v.channels.size(); ++i)
{
s << indent << " channels[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::sensor_msgs::ChannelFloat32_<ContainerAllocator> >::stream(s, indent + " ", v.channels[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_POINTCLOUD_H

340
thirdparty/ros/include/sensor_msgs/PointCloud2.h vendored Normal file
View File

@@ -0,0 +1,340 @@
// Generated by gencpp from file sensor_msgs/PointCloud2.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_POINTCLOUD2_H
#define SENSOR_MSGS_MESSAGE_POINTCLOUD2_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 <sensor_msgs/PointField.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct PointCloud2_
{
typedef PointCloud2_<ContainerAllocator> Type;
PointCloud2_()
: header()
, height(0)
, width(0)
, fields()
, is_bigendian(false)
, point_step(0)
, row_step(0)
, data()
, is_dense(false) {
}
PointCloud2_(const ContainerAllocator& _alloc)
: header(_alloc)
, height(0)
, width(0)
, fields(_alloc)
, is_bigendian(false)
, point_step(0)
, row_step(0)
, data(_alloc)
, is_dense(false) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef uint32_t _height_type;
_height_type height;
typedef uint32_t _width_type;
_width_type width;
typedef std::vector< ::sensor_msgs::PointField_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::sensor_msgs::PointField_<ContainerAllocator> >> _fields_type;
_fields_type fields;
typedef uint8_t _is_bigendian_type;
_is_bigendian_type is_bigendian;
typedef uint32_t _point_step_type;
_point_step_type point_step;
typedef uint32_t _row_step_type;
_row_step_type row_step;
typedef std::vector<uint8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>> _data_type;
_data_type data;
typedef uint8_t _is_dense_type;
_is_dense_type is_dense;
typedef boost::shared_ptr< ::sensor_msgs::PointCloud2_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::PointCloud2_<ContainerAllocator> const> ConstPtr;
}; // struct PointCloud2_
typedef ::sensor_msgs::PointCloud2_<std::allocator<void> > PointCloud2;
typedef boost::shared_ptr< ::sensor_msgs::PointCloud2 > PointCloud2Ptr;
typedef boost::shared_ptr< ::sensor_msgs::PointCloud2 const> PointCloud2ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointCloud2_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::PointCloud2_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::PointCloud2_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointCloud2_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.height == rhs.height &&
lhs.width == rhs.width &&
lhs.fields == rhs.fields &&
lhs.is_bigendian == rhs.is_bigendian &&
lhs.point_step == rhs.point_step &&
lhs.row_step == rhs.row_step &&
lhs.data == rhs.data &&
lhs.is_dense == rhs.is_dense;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::PointCloud2_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointCloud2_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::PointCloud2_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::PointCloud2_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::PointCloud2_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
{
static const char* value()
{
return "1158d486dd51d683ce2f1be655c3c181";
}
static const char* value(const ::sensor_msgs::PointCloud2_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x1158d486dd51d683ULL;
static const uint64_t static_value2 = 0xce2f1be655c3c181ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/PointCloud2";
}
static const char* value(const ::sensor_msgs::PointCloud2_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
{
static const char* value()
{
return "# This message holds a collection of N-dimensional points, which may\n"
"# contain additional information such as normals, intensity, etc. The\n"
"# point data is stored as a binary blob, its layout described by the\n"
"# contents of the \"fields\" array.\n"
"\n"
"# The point cloud data may be organized 2d (image-like) or 1d\n"
"# (unordered). Point clouds organized as 2d images may be produced by\n"
"# camera depth sensors such as stereo or time-of-flight.\n"
"\n"
"# Time of sensor data acquisition, and the coordinate frame ID (for 3d\n"
"# points).\n"
"Header header\n"
"\n"
"# 2D structure of the point cloud. If the cloud is unordered, height is\n"
"# 1 and width is the length of the point cloud.\n"
"uint32 height\n"
"uint32 width\n"
"\n"
"# Describes the channels and their layout in the binary data blob.\n"
"PointField[] fields\n"
"\n"
"bool is_bigendian # Is this data bigendian?\n"
"uint32 point_step # Length of a point in bytes\n"
"uint32 row_step # Length of a row in bytes\n"
"uint8[] data # Actual point data, size is (row_step*height)\n"
"\n"
"bool is_dense # True if there are no invalid points\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: sensor_msgs/PointField\n"
"# This message holds the description of one point entry in the\n"
"# PointCloud2 message format.\n"
"uint8 INT8 = 1\n"
"uint8 UINT8 = 2\n"
"uint8 INT16 = 3\n"
"uint8 UINT16 = 4\n"
"uint8 INT32 = 5\n"
"uint8 UINT32 = 6\n"
"uint8 FLOAT32 = 7\n"
"uint8 FLOAT64 = 8\n"
"\n"
"string name # Name of field\n"
"uint32 offset # Offset from start of point struct\n"
"uint8 datatype # Datatype enumeration, see above\n"
"uint32 count # How many elements in the field\n"
;
}
static const char* value(const ::sensor_msgs::PointCloud2_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.height);
stream.next(m.width);
stream.next(m.fields);
stream.next(m.is_bigendian);
stream.next(m.point_step);
stream.next(m.row_step);
stream.next(m.data);
stream.next(m.is_dense);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PointCloud2_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::PointCloud2_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointCloud2_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "height: ";
Printer<uint32_t>::stream(s, indent + " ", v.height);
s << indent << "width: ";
Printer<uint32_t>::stream(s, indent + " ", v.width);
s << indent << "fields[]" << std::endl;
for (size_t i = 0; i < v.fields.size(); ++i)
{
s << indent << " fields[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::sensor_msgs::PointField_<ContainerAllocator> >::stream(s, indent + " ", v.fields[i]);
}
s << indent << "is_bigendian: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_bigendian);
s << indent << "point_step: ";
Printer<uint32_t>::stream(s, indent + " ", v.point_step);
s << indent << "row_step: ";
Printer<uint32_t>::stream(s, indent + " ", v.row_step);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<uint8_t>::stream(s, indent + " ", v.data[i]);
}
s << indent << "is_dense: ";
Printer<uint8_t>::stream(s, indent + " ", v.is_dense);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_POINTCLOUD2_H

288
thirdparty/ros/include/sensor_msgs/PointField.h vendored Normal file
View File

@@ -0,0 +1,288 @@
// Generated by gencpp from file sensor_msgs/PointField.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_POINTFIELD_H
#define SENSOR_MSGS_MESSAGE_POINTFIELD_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 sensor_msgs
{
template <class ContainerAllocator>
struct PointField_
{
typedef PointField_<ContainerAllocator> Type;
PointField_()
: name()
, offset(0)
, datatype(0)
, count(0) {
}
PointField_(const ContainerAllocator& _alloc)
: name(_alloc)
, offset(0)
, datatype(0)
, count(0) {
(void)_alloc;
}
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _name_type;
_name_type name;
typedef uint32_t _offset_type;
_offset_type offset;
typedef uint8_t _datatype_type;
_datatype_type datatype;
typedef uint32_t _count_type;
_count_type count;
// reducing the odds to have name collisions with Windows.h
#if defined(_WIN32) && defined(INT8)
#undef INT8
#endif
#if defined(_WIN32) && defined(UINT8)
#undef UINT8
#endif
#if defined(_WIN32) && defined(INT16)
#undef INT16
#endif
#if defined(_WIN32) && defined(UINT16)
#undef UINT16
#endif
#if defined(_WIN32) && defined(INT32)
#undef INT32
#endif
#if defined(_WIN32) && defined(UINT32)
#undef UINT32
#endif
#if defined(_WIN32) && defined(FLOAT32)
#undef FLOAT32
#endif
#if defined(_WIN32) && defined(FLOAT64)
#undef FLOAT64
#endif
enum {
INT8 = 1u,
UINT8 = 2u,
INT16 = 3u,
UINT16 = 4u,
INT32 = 5u,
UINT32 = 6u,
FLOAT32 = 7u,
FLOAT64 = 8u,
};
typedef boost::shared_ptr< ::sensor_msgs::PointField_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::PointField_<ContainerAllocator> const> ConstPtr;
}; // struct PointField_
typedef ::sensor_msgs::PointField_<std::allocator<void> > PointField;
typedef boost::shared_ptr< ::sensor_msgs::PointField > PointFieldPtr;
typedef boost::shared_ptr< ::sensor_msgs::PointField const> PointFieldConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::PointField_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::PointField_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::PointField_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointField_<ContainerAllocator2> & rhs)
{
return lhs.name == rhs.name &&
lhs.offset == rhs.offset &&
lhs.datatype == rhs.datatype &&
lhs.count == rhs.count;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::PointField_<ContainerAllocator1> & lhs, const ::sensor_msgs::PointField_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::PointField_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::PointField_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::PointField_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::PointField_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::PointField_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::PointField_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::PointField_<ContainerAllocator> >
{
static const char* value()
{
return "268eacb2962780ceac86cbd17e328150";
}
static const char* value(const ::sensor_msgs::PointField_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x268eacb2962780ceULL;
static const uint64_t static_value2 = 0xac86cbd17e328150ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::PointField_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/PointField";
}
static const char* value(const ::sensor_msgs::PointField_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::PointField_<ContainerAllocator> >
{
static const char* value()
{
return "# This message holds the description of one point entry in the\n"
"# PointCloud2 message format.\n"
"uint8 INT8 = 1\n"
"uint8 UINT8 = 2\n"
"uint8 INT16 = 3\n"
"uint8 UINT16 = 4\n"
"uint8 INT32 = 5\n"
"uint8 UINT32 = 6\n"
"uint8 FLOAT32 = 7\n"
"uint8 FLOAT64 = 8\n"
"\n"
"string name # Name of field\n"
"uint32 offset # Offset from start of point struct\n"
"uint8 datatype # Datatype enumeration, see above\n"
"uint32 count # How many elements in the field\n"
;
}
static const char* value(const ::sensor_msgs::PointField_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::PointField_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.name);
stream.next(m.offset);
stream.next(m.datatype);
stream.next(m.count);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct PointField_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::PointField_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::PointField_<ContainerAllocator>& v)
{
s << indent << "name: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.name);
s << indent << "offset: ";
Printer<uint32_t>::stream(s, indent + " ", v.offset);
s << indent << "datatype: ";
Printer<uint8_t>::stream(s, indent + " ", v.datatype);
s << indent << "count: ";
Printer<uint32_t>::stream(s, indent + " ", v.count);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_POINTFIELD_H

312
thirdparty/ros/include/sensor_msgs/Range.h vendored Normal file
View File

@@ -0,0 +1,312 @@
// Generated by gencpp from file sensor_msgs/Range.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_RANGE_H
#define SENSOR_MSGS_MESSAGE_RANGE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct Range_
{
typedef Range_<ContainerAllocator> Type;
Range_()
: header()
, radiation_type(0)
, field_of_view(0.0)
, min_range(0.0)
, max_range(0.0)
, range(0.0) {
}
Range_(const ContainerAllocator& _alloc)
: header(_alloc)
, radiation_type(0)
, field_of_view(0.0)
, min_range(0.0)
, max_range(0.0)
, range(0.0) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef uint8_t _radiation_type_type;
_radiation_type_type radiation_type;
typedef float _field_of_view_type;
_field_of_view_type field_of_view;
typedef float _min_range_type;
_min_range_type min_range;
typedef float _max_range_type;
_max_range_type max_range;
typedef float _range_type;
_range_type range;
// reducing the odds to have name collisions with Windows.h
#if defined(_WIN32) && defined(ULTRASOUND)
#undef ULTRASOUND
#endif
#if defined(_WIN32) && defined(INFRARED)
#undef INFRARED
#endif
enum {
ULTRASOUND = 0u,
INFRARED = 1u,
};
typedef boost::shared_ptr< ::sensor_msgs::Range_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::Range_<ContainerAllocator> const> ConstPtr;
}; // struct Range_
typedef ::sensor_msgs::Range_<std::allocator<void> > Range;
typedef boost::shared_ptr< ::sensor_msgs::Range > RangePtr;
typedef boost::shared_ptr< ::sensor_msgs::Range const> RangeConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Range_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::Range_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::Range_<ContainerAllocator1> & lhs, const ::sensor_msgs::Range_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.radiation_type == rhs.radiation_type &&
lhs.field_of_view == rhs.field_of_view &&
lhs.min_range == rhs.min_range &&
lhs.max_range == rhs.max_range &&
lhs.range == rhs.range;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::Range_<ContainerAllocator1> & lhs, const ::sensor_msgs::Range_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Range_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Range_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Range_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Range_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Range_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Range_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::Range_<ContainerAllocator> >
{
static const char* value()
{
return "c005c34273dc426c67a020a87bc24148";
}
static const char* value(const ::sensor_msgs::Range_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xc005c34273dc426cULL;
static const uint64_t static_value2 = 0x67a020a87bc24148ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::Range_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/Range";
}
static const char* value(const ::sensor_msgs::Range_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::Range_<ContainerAllocator> >
{
static const char* value()
{
return "# Single range reading from an active ranger that emits energy and reports\n"
"# one range reading that is valid along an arc at the distance measured. \n"
"# This message is not appropriate for laser scanners. See the LaserScan\n"
"# message if you are working with a laser scanner.\n"
"\n"
"# This message also can represent a fixed-distance (binary) ranger. This\n"
"# sensor will have min_range===max_range===distance of detection.\n"
"# These sensors follow REP 117 and will output -Inf if the object is detected\n"
"# and +Inf if the object is outside of the detection range.\n"
"\n"
"Header header # timestamp in the header is the time the ranger\n"
" # returned the distance reading\n"
"\n"
"# Radiation type enums\n"
"# If you want a value added to this list, send an email to the ros-users list\n"
"uint8 ULTRASOUND=0\n"
"uint8 INFRARED=1\n"
"\n"
"uint8 radiation_type # the type of radiation used by the sensor\n"
" # (sound, IR, etc) [enum]\n"
"\n"
"float32 field_of_view # the size of the arc that the distance reading is\n"
" # valid for [rad]\n"
" # the object causing the range reading may have\n"
" # been anywhere within -field_of_view/2 and\n"
" # field_of_view/2 at the measured range. \n"
" # 0 angle corresponds to the x-axis of the sensor.\n"
"\n"
"float32 min_range # minimum range value [m]\n"
"float32 max_range # maximum range value [m]\n"
" # Fixed distance rangers require min_range==max_range\n"
"\n"
"float32 range # range data [m]\n"
" # (Note: values < range_min or > range_max\n"
" # should be discarded)\n"
" # Fixed distance rangers only output -Inf or +Inf.\n"
" # -Inf represents a detection within fixed distance.\n"
" # (Detection too close to the sensor to quantify)\n"
" # +Inf represents no detection within the fixed distance.\n"
" # (Object out of range)\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"
;
}
static const char* value(const ::sensor_msgs::Range_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Range_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.radiation_type);
stream.next(m.field_of_view);
stream.next(m.min_range);
stream.next(m.max_range);
stream.next(m.range);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Range_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::Range_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Range_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "radiation_type: ";
Printer<uint8_t>::stream(s, indent + " ", v.radiation_type);
s << indent << "field_of_view: ";
Printer<float>::stream(s, indent + " ", v.field_of_view);
s << indent << "min_range: ";
Printer<float>::stream(s, indent + " ", v.min_range);
s << indent << "max_range: ";
Printer<float>::stream(s, indent + " ", v.max_range);
s << indent << "range: ";
Printer<float>::stream(s, indent + " ", v.range);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_RANGE_H

249
thirdparty/ros/include/sensor_msgs/RegionOfInterest.h vendored Normal file
View File

@@ -0,0 +1,249 @@
// Generated by gencpp from file sensor_msgs/RegionOfInterest.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_H
#define SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_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 sensor_msgs
{
template <class ContainerAllocator>
struct RegionOfInterest_
{
typedef RegionOfInterest_<ContainerAllocator> Type;
RegionOfInterest_()
: x_offset(0)
, y_offset(0)
, height(0)
, width(0)
, do_rectify(false) {
}
RegionOfInterest_(const ContainerAllocator& _alloc)
: x_offset(0)
, y_offset(0)
, height(0)
, width(0)
, do_rectify(false) {
(void)_alloc;
}
typedef uint32_t _x_offset_type;
_x_offset_type x_offset;
typedef uint32_t _y_offset_type;
_y_offset_type y_offset;
typedef uint32_t _height_type;
_height_type height;
typedef uint32_t _width_type;
_width_type width;
typedef uint8_t _do_rectify_type;
_do_rectify_type do_rectify;
typedef boost::shared_ptr< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> const> ConstPtr;
}; // struct RegionOfInterest_
typedef ::sensor_msgs::RegionOfInterest_<std::allocator<void> > RegionOfInterest;
typedef boost::shared_ptr< ::sensor_msgs::RegionOfInterest > RegionOfInterestPtr;
typedef boost::shared_ptr< ::sensor_msgs::RegionOfInterest const> RegionOfInterestConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::RegionOfInterest_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator1> & lhs, const ::sensor_msgs::RegionOfInterest_<ContainerAllocator2> & rhs)
{
return lhs.x_offset == rhs.x_offset &&
lhs.y_offset == rhs.y_offset &&
lhs.height == rhs.height &&
lhs.width == rhs.width &&
lhs.do_rectify == rhs.do_rectify;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator1> & lhs, const ::sensor_msgs::RegionOfInterest_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
{
static const char* value()
{
return "bdb633039d588fcccb441a4d43ccfe09";
}
static const char* value(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xbdb633039d588fccULL;
static const uint64_t static_value2 = 0xcb441a4d43ccfe09ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/RegionOfInterest";
}
static const char* value(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
{
static const char* value()
{
return "# This message is used to specify a region of interest within an image.\n"
"#\n"
"# When used to specify the ROI setting of the camera when the image was\n"
"# taken, the height and width fields should either match the height and\n"
"# width fields for the associated image; or height = width = 0\n"
"# indicates that the full resolution image was captured.\n"
"\n"
"uint32 x_offset # Leftmost pixel of the ROI\n"
" # (0 if the ROI includes the left edge of the image)\n"
"uint32 y_offset # Topmost pixel of the ROI\n"
" # (0 if the ROI includes the top edge of the image)\n"
"uint32 height # Height of ROI\n"
"uint32 width # Width of ROI\n"
"\n"
"# True if a distinct rectified ROI should be calculated from the \"raw\"\n"
"# ROI in this message. Typically this should be False if the full image\n"
"# is captured (ROI not used), and True if a subwindow is captured (ROI\n"
"# used).\n"
"bool do_rectify\n"
;
}
static const char* value(const ::sensor_msgs::RegionOfInterest_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.x_offset);
stream.next(m.y_offset);
stream.next(m.height);
stream.next(m.width);
stream.next(m.do_rectify);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct RegionOfInterest_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::RegionOfInterest_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::RegionOfInterest_<ContainerAllocator>& v)
{
s << indent << "x_offset: ";
Printer<uint32_t>::stream(s, indent + " ", v.x_offset);
s << indent << "y_offset: ";
Printer<uint32_t>::stream(s, indent + " ", v.y_offset);
s << indent << "height: ";
Printer<uint32_t>::stream(s, indent + " ", v.height);
s << indent << "width: ";
Printer<uint32_t>::stream(s, indent + " ", v.width);
s << indent << "do_rectify: ";
Printer<uint8_t>::stream(s, indent + " ", v.do_rectify);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_REGIONOFINTEREST_H

241
thirdparty/ros/include/sensor_msgs/RelativeHumidity.h vendored Normal file
View File

@@ -0,0 +1,241 @@
// Generated by gencpp from file sensor_msgs/RelativeHumidity.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_H
#define SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct RelativeHumidity_
{
typedef RelativeHumidity_<ContainerAllocator> Type;
RelativeHumidity_()
: header()
, relative_humidity(0.0)
, variance(0.0) {
}
RelativeHumidity_(const ContainerAllocator& _alloc)
: header(_alloc)
, relative_humidity(0.0)
, variance(0.0) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef double _relative_humidity_type;
_relative_humidity_type relative_humidity;
typedef double _variance_type;
_variance_type variance;
typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> const> ConstPtr;
}; // struct RelativeHumidity_
typedef ::sensor_msgs::RelativeHumidity_<std::allocator<void> > RelativeHumidity;
typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity > RelativeHumidityPtr;
typedef boost::shared_ptr< ::sensor_msgs::RelativeHumidity const> RelativeHumidityConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::RelativeHumidity_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator1> & lhs, const ::sensor_msgs::RelativeHumidity_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.relative_humidity == rhs.relative_humidity &&
lhs.variance == rhs.variance;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator1> & lhs, const ::sensor_msgs::RelativeHumidity_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
{
static const char* value()
{
return "8730015b05955b7e992ce29a2678d90f";
}
static const char* value(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8730015b05955b7eULL;
static const uint64_t static_value2 = 0x992ce29a2678d90fULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/RelativeHumidity";
}
static const char* value(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
{
static const char* value()
{
return " # Single reading from a relative humidity sensor. Defines the ratio of partial\n"
" # pressure of water vapor to the saturated vapor pressure at a temperature.\n"
"\n"
" Header header # timestamp of the measurement\n"
" # frame_id is the location of the humidity sensor\n"
"\n"
" float64 relative_humidity # Expression of the relative humidity\n"
" # from 0.0 to 1.0.\n"
" # 0.0 is no partial pressure of water vapor\n"
" # 1.0 represents partial pressure of saturation\n"
"\n"
" float64 variance # 0 is interpreted as variance unknown\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"
;
}
static const char* value(const ::sensor_msgs::RelativeHumidity_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.relative_humidity);
stream.next(m.variance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct RelativeHumidity_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::RelativeHumidity_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::RelativeHumidity_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "relative_humidity: ";
Printer<double>::stream(s, indent + " ", v.relative_humidity);
s << indent << "variance: ";
Printer<double>::stream(s, indent + " ", v.variance);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_RELATIVEHUMIDITY_H

123
thirdparty/ros/include/sensor_msgs/SetCameraInfo.h vendored Normal file
View File

@@ -0,0 +1,123 @@
// Generated by gencpp from file sensor_msgs/SetCameraInfo.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H
#define SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H
#include <ros/service_traits.h>
#include <sensor_msgs/SetCameraInfoRequest.h>
#include <sensor_msgs/SetCameraInfoResponse.h>
namespace sensor_msgs
{
struct SetCameraInfo
{
typedef SetCameraInfoRequest Request;
typedef SetCameraInfoResponse Response;
Request request;
Response response;
typedef Request RequestType;
typedef Response ResponseType;
}; // struct SetCameraInfo
} // namespace sensor_msgs
namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum< ::sensor_msgs::SetCameraInfo > {
static const char* value()
{
return "bef1df590ed75ed1f393692395e15482";
}
static const char* value(const ::sensor_msgs::SetCameraInfo&) { return value(); }
};
template<>
struct DataType< ::sensor_msgs::SetCameraInfo > {
static const char* value()
{
return "sensor_msgs/SetCameraInfo";
}
static const char* value(const ::sensor_msgs::SetCameraInfo&) { return value(); }
};
// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfoRequest> should match
// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfo >
template<>
struct MD5Sum< ::sensor_msgs::SetCameraInfoRequest>
{
static const char* value()
{
return MD5Sum< ::sensor_msgs::SetCameraInfo >::value();
}
static const char* value(const ::sensor_msgs::SetCameraInfoRequest&)
{
return value();
}
};
// service_traits::DataType< ::sensor_msgs::SetCameraInfoRequest> should match
// service_traits::DataType< ::sensor_msgs::SetCameraInfo >
template<>
struct DataType< ::sensor_msgs::SetCameraInfoRequest>
{
static const char* value()
{
return DataType< ::sensor_msgs::SetCameraInfo >::value();
}
static const char* value(const ::sensor_msgs::SetCameraInfoRequest&)
{
return value();
}
};
// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfoResponse> should match
// service_traits::MD5Sum< ::sensor_msgs::SetCameraInfo >
template<>
struct MD5Sum< ::sensor_msgs::SetCameraInfoResponse>
{
static const char* value()
{
return MD5Sum< ::sensor_msgs::SetCameraInfo >::value();
}
static const char* value(const ::sensor_msgs::SetCameraInfoResponse&)
{
return value();
}
};
// service_traits::DataType< ::sensor_msgs::SetCameraInfoResponse> should match
// service_traits::DataType< ::sensor_msgs::SetCameraInfo >
template<>
struct DataType< ::sensor_msgs::SetCameraInfoResponse>
{
static const char* value()
{
return DataType< ::sensor_msgs::SetCameraInfo >::value();
}
static const char* value(const ::sensor_msgs::SetCameraInfoResponse&)
{
return value();
}
};
} // namespace service_traits
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFO_H

377
thirdparty/ros/include/sensor_msgs/SetCameraInfoRequest.h vendored Normal file
View File

@@ -0,0 +1,377 @@
// Generated by gencpp from file sensor_msgs/SetCameraInfoRequest.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_H
#define SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_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 <sensor_msgs/CameraInfo.h>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct SetCameraInfoRequest_
{
typedef SetCameraInfoRequest_<ContainerAllocator> Type;
SetCameraInfoRequest_()
: camera_info() {
}
SetCameraInfoRequest_(const ContainerAllocator& _alloc)
: camera_info(_alloc) {
(void)_alloc;
}
typedef ::sensor_msgs::CameraInfo_<ContainerAllocator> _camera_info_type;
_camera_info_type camera_info;
typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> const> ConstPtr;
}; // struct SetCameraInfoRequest_
typedef ::sensor_msgs::SetCameraInfoRequest_<std::allocator<void> > SetCameraInfoRequest;
typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest > SetCameraInfoRequestPtr;
typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoRequest const> SetCameraInfoRequestConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator1> & lhs, const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator2> & rhs)
{
return lhs.camera_info == rhs.camera_info;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator1> & lhs, const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
{
static const char* value()
{
return "ee34be01fdeee563d0d99cd594d5581d";
}
static const char* value(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xee34be01fdeee563ULL;
static const uint64_t static_value2 = 0xd0d99cd594d5581dULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/SetCameraInfoRequest";
}
static const char* value(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
{
static const char* value()
{
return "# This service requests that a camera stores the given CameraInfo \n"
"# as that camera's calibration information.\n"
"#\n"
"# The width and height in the camera_info field should match what the\n"
"# camera is currently outputting on its camera_info topic, and the camera\n"
"# will assume that the region of the imager that is being referred to is\n"
"# the region that the camera is currently capturing.\n"
"\n"
"sensor_msgs/CameraInfo camera_info # The camera_info to store\n"
"\n"
"================================================================================\n"
"MSG: sensor_msgs/CameraInfo\n"
"# This message defines meta information for a camera. It should be in a\n"
"# camera namespace on topic \"camera_info\" and accompanied by up to five\n"
"# image topics named:\n"
"#\n"
"# image_raw - raw data from the camera driver, possibly Bayer encoded\n"
"# image - monochrome, distorted\n"
"# image_color - color, distorted\n"
"# image_rect - monochrome, rectified\n"
"# image_rect_color - color, rectified\n"
"#\n"
"# The image_pipeline contains packages (image_proc, stereo_image_proc)\n"
"# for producing the four processed image topics from image_raw and\n"
"# camera_info. The meaning of the camera parameters are described in\n"
"# detail at http://www.ros.org/wiki/image_pipeline/CameraInfo.\n"
"#\n"
"# The image_geometry package provides a user-friendly interface to\n"
"# common operations using this meta information. If you want to, e.g.,\n"
"# project a 3d point into image coordinates, we strongly recommend\n"
"# using image_geometry.\n"
"#\n"
"# If the camera is uncalibrated, the matrices D, K, R, P should be left\n"
"# zeroed out. In particular, clients may assume that K[0] == 0.0\n"
"# indicates an uncalibrated camera.\n"
"\n"
"#######################################################################\n"
"# Image acquisition info #\n"
"#######################################################################\n"
"\n"
"# Time of image acquisition, camera coordinate frame ID\n"
"Header header # Header timestamp should be acquisition time of image\n"
" # Header frame_id should be optical frame of camera\n"
" # origin of frame should be optical center of camera\n"
" # +x should point to the right in the image\n"
" # +y should point down in the image\n"
" # +z should point into the plane of the image\n"
"\n"
"\n"
"#######################################################################\n"
"# Calibration Parameters #\n"
"#######################################################################\n"
"# These are fixed during camera calibration. Their values will be the #\n"
"# same in all messages until the camera is recalibrated. Note that #\n"
"# self-calibrating systems may \"recalibrate\" frequently. #\n"
"# #\n"
"# The internal parameters can be used to warp a raw (distorted) image #\n"
"# to: #\n"
"# 1. An undistorted image (requires D and K) #\n"
"# 2. A rectified image (requires D, K, R) #\n"
"# The projection matrix P projects 3D points into the rectified image.#\n"
"#######################################################################\n"
"\n"
"# The image dimensions with which the camera was calibrated. Normally\n"
"# this will be the full camera resolution in pixels.\n"
"uint32 height\n"
"uint32 width\n"
"\n"
"# The distortion model used. Supported models are listed in\n"
"# sensor_msgs/distortion_models.h. For most cameras, \"plumb_bob\" - a\n"
"# simple model of radial and tangential distortion - is sufficient.\n"
"string distortion_model\n"
"\n"
"# The distortion parameters, size depending on the distortion model.\n"
"# For \"plumb_bob\", the 5 parameters are: (k1, k2, t1, t2, k3).\n"
"float64[] D\n"
"\n"
"# Intrinsic camera matrix for the raw (distorted) images.\n"
"# [fx 0 cx]\n"
"# K = [ 0 fy cy]\n"
"# [ 0 0 1]\n"
"# Projects 3D points in the camera coordinate frame to 2D pixel\n"
"# coordinates using the focal lengths (fx, fy) and principal point\n"
"# (cx, cy).\n"
"float64[9] K # 3x3 row-major matrix\n"
"\n"
"# Rectification matrix (stereo cameras only)\n"
"# A rotation matrix aligning the camera coordinate system to the ideal\n"
"# stereo image plane so that epipolar lines in both stereo images are\n"
"# parallel.\n"
"float64[9] R # 3x3 row-major matrix\n"
"\n"
"# Projection/camera matrix\n"
"# [fx' 0 cx' Tx]\n"
"# P = [ 0 fy' cy' Ty]\n"
"# [ 0 0 1 0]\n"
"# By convention, this matrix specifies the intrinsic (camera) matrix\n"
"# of the processed (rectified) image. That is, the left 3x3 portion\n"
"# is the normal camera intrinsic matrix for the rectified image.\n"
"# It projects 3D points in the camera coordinate frame to 2D pixel\n"
"# coordinates using the focal lengths (fx', fy') and principal point\n"
"# (cx', cy') - these may differ from the values in K.\n"
"# For monocular cameras, Tx = Ty = 0. Normally, monocular cameras will\n"
"# also have R = the identity and P[1:3,1:3] = K.\n"
"# For a stereo pair, the fourth column [Tx Ty 0]' is related to the\n"
"# position of the optical center of the second camera in the first\n"
"# camera's frame. We assume Tz = 0 so both cameras are in the same\n"
"# stereo image plane. The first camera always has Tx = Ty = 0. For\n"
"# the right (second) camera of a horizontal stereo pair, Ty = 0 and\n"
"# Tx = -fx' * B, where B is the baseline between the cameras.\n"
"# Given a 3D point [X Y Z]', the projection (x, y) of the point onto\n"
"# the rectified image is given by:\n"
"# [u v w]' = P * [X Y Z 1]'\n"
"# x = u / w\n"
"# y = v / w\n"
"# This holds for both images of a stereo pair.\n"
"float64[12] P # 3x4 row-major matrix\n"
"\n"
"\n"
"#######################################################################\n"
"# Operational Parameters #\n"
"#######################################################################\n"
"# These define the image region actually captured by the camera #\n"
"# driver. Although they affect the geometry of the output image, they #\n"
"# may be changed freely without recalibrating the camera. #\n"
"#######################################################################\n"
"\n"
"# Binning refers here to any camera setting which combines rectangular\n"
"# neighborhoods of pixels into larger \"super-pixels.\" It reduces the\n"
"# resolution of the output image to\n"
"# (width / binning_x) x (height / binning_y).\n"
"# The default values binning_x = binning_y = 0 is considered the same\n"
"# as binning_x = binning_y = 1 (no subsampling).\n"
"uint32 binning_x\n"
"uint32 binning_y\n"
"\n"
"# Region of interest (subwindow of full camera resolution), given in\n"
"# full resolution (unbinned) image coordinates. A particular ROI\n"
"# always denotes the same window of pixels on the camera sensor,\n"
"# regardless of binning settings.\n"
"# The default setting of roi (all values 0) is considered the same as\n"
"# full resolution (roi.width = width, roi.height = height).\n"
"RegionOfInterest roi\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: sensor_msgs/RegionOfInterest\n"
"# This message is used to specify a region of interest within an image.\n"
"#\n"
"# When used to specify the ROI setting of the camera when the image was\n"
"# taken, the height and width fields should either match the height and\n"
"# width fields for the associated image; or height = width = 0\n"
"# indicates that the full resolution image was captured.\n"
"\n"
"uint32 x_offset # Leftmost pixel of the ROI\n"
" # (0 if the ROI includes the left edge of the image)\n"
"uint32 y_offset # Topmost pixel of the ROI\n"
" # (0 if the ROI includes the top edge of the image)\n"
"uint32 height # Height of ROI\n"
"uint32 width # Width of ROI\n"
"\n"
"# True if a distinct rectified ROI should be calculated from the \"raw\"\n"
"# ROI in this message. Typically this should be False if the full image\n"
"# is captured (ROI not used), and True if a subwindow is captured (ROI\n"
"# used).\n"
"bool do_rectify\n"
;
}
static const char* value(const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.camera_info);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct SetCameraInfoRequest_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::SetCameraInfoRequest_<ContainerAllocator>& v)
{
s << indent << "camera_info: ";
s << std::endl;
Printer< ::sensor_msgs::CameraInfo_<ContainerAllocator> >::stream(s, indent + " ", v.camera_info);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFOREQUEST_H

206
thirdparty/ros/include/sensor_msgs/SetCameraInfoResponse.h vendored Normal file
View File

@@ -0,0 +1,206 @@
// Generated by gencpp from file sensor_msgs/SetCameraInfoResponse.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_H
#define SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_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 sensor_msgs
{
template <class ContainerAllocator>
struct SetCameraInfoResponse_
{
typedef SetCameraInfoResponse_<ContainerAllocator> Type;
SetCameraInfoResponse_()
: success(false)
, status_message() {
}
SetCameraInfoResponse_(const ContainerAllocator& _alloc)
: success(false)
, status_message(_alloc) {
(void)_alloc;
}
typedef uint8_t _success_type;
_success_type success;
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _status_message_type;
_status_message_type status_message;
typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> const> ConstPtr;
}; // struct SetCameraInfoResponse_
typedef ::sensor_msgs::SetCameraInfoResponse_<std::allocator<void> > SetCameraInfoResponse;
typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse > SetCameraInfoResponsePtr;
typedef boost::shared_ptr< ::sensor_msgs::SetCameraInfoResponse const> SetCameraInfoResponseConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator1> & lhs, const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator2> & rhs)
{
return lhs.success == rhs.success &&
lhs.status_message == rhs.status_message;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator1> & lhs, const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
{
static const char* value()
{
return "2ec6f3eff0161f4257b808b12bc830c2";
}
static const char* value(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x2ec6f3eff0161f42ULL;
static const uint64_t static_value2 = 0x57b808b12bc830c2ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/SetCameraInfoResponse";
}
static const char* value(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
{
static const char* value()
{
return "bool success # True if the call succeeded\n"
"string status_message # Used to give details about success\n"
"\n"
;
}
static const char* value(const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.success);
stream.next(m.status_message);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct SetCameraInfoResponse_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::SetCameraInfoResponse_<ContainerAllocator>& v)
{
s << indent << "success: ";
Printer<uint8_t>::stream(s, indent + " ", v.success);
s << indent << "status_message: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.status_message);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_SETCAMERAINFORESPONSE_H

237
thirdparty/ros/include/sensor_msgs/Temperature.h vendored Normal file
View File

@@ -0,0 +1,237 @@
// Generated by gencpp from file sensor_msgs/Temperature.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_TEMPERATURE_H
#define SENSOR_MSGS_MESSAGE_TEMPERATURE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct Temperature_
{
typedef Temperature_<ContainerAllocator> Type;
Temperature_()
: header()
, temperature(0.0)
, variance(0.0) {
}
Temperature_(const ContainerAllocator& _alloc)
: header(_alloc)
, temperature(0.0)
, variance(0.0) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef double _temperature_type;
_temperature_type temperature;
typedef double _variance_type;
_variance_type variance;
typedef boost::shared_ptr< ::sensor_msgs::Temperature_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::Temperature_<ContainerAllocator> const> ConstPtr;
}; // struct Temperature_
typedef ::sensor_msgs::Temperature_<std::allocator<void> > Temperature;
typedef boost::shared_ptr< ::sensor_msgs::Temperature > TemperaturePtr;
typedef boost::shared_ptr< ::sensor_msgs::Temperature const> TemperatureConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::Temperature_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::Temperature_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::Temperature_<ContainerAllocator1> & lhs, const ::sensor_msgs::Temperature_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.temperature == rhs.temperature &&
lhs.variance == rhs.variance;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::Temperature_<ContainerAllocator1> & lhs, const ::sensor_msgs::Temperature_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Temperature_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::Temperature_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Temperature_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::Temperature_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Temperature_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::Temperature_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::Temperature_<ContainerAllocator> >
{
static const char* value()
{
return "ff71b307acdbe7c871a5a6d7ed359100";
}
static const char* value(const ::sensor_msgs::Temperature_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xff71b307acdbe7c8ULL;
static const uint64_t static_value2 = 0x71a5a6d7ed359100ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::Temperature_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/Temperature";
}
static const char* value(const ::sensor_msgs::Temperature_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::Temperature_<ContainerAllocator> >
{
static const char* value()
{
return " # Single temperature reading.\n"
"\n"
" Header header # timestamp is the time the temperature was measured\n"
" # frame_id is the location of the temperature reading\n"
"\n"
" float64 temperature # Measurement of the Temperature in Degrees Celsius\n"
"\n"
" float64 variance # 0 is interpreted as variance unknown\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"
;
}
static const char* value(const ::sensor_msgs::Temperature_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::Temperature_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.temperature);
stream.next(m.variance);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Temperature_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::Temperature_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::Temperature_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "temperature: ";
Printer<double>::stream(s, indent + " ", v.temperature);
s << indent << "variance: ";
Printer<double>::stream(s, indent + " ", v.variance);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_TEMPERATURE_H

237
thirdparty/ros/include/sensor_msgs/TimeReference.h vendored Normal file
View File

@@ -0,0 +1,237 @@
// Generated by gencpp from file sensor_msgs/TimeReference.msg
// DO NOT EDIT!
#ifndef SENSOR_MSGS_MESSAGE_TIMEREFERENCE_H
#define SENSOR_MSGS_MESSAGE_TIMEREFERENCE_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>
namespace sensor_msgs
{
template <class ContainerAllocator>
struct TimeReference_
{
typedef TimeReference_<ContainerAllocator> Type;
TimeReference_()
: header()
, time_ref()
, source() {
}
TimeReference_(const ContainerAllocator& _alloc)
: header(_alloc)
, time_ref()
, source(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef ros::Time _time_ref_type;
_time_ref_type time_ref;
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _source_type;
_source_type source;
typedef boost::shared_ptr< ::sensor_msgs::TimeReference_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::sensor_msgs::TimeReference_<ContainerAllocator> const> ConstPtr;
}; // struct TimeReference_
typedef ::sensor_msgs::TimeReference_<std::allocator<void> > TimeReference;
typedef boost::shared_ptr< ::sensor_msgs::TimeReference > TimeReferencePtr;
typedef boost::shared_ptr< ::sensor_msgs::TimeReference const> TimeReferenceConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::sensor_msgs::TimeReference_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::sensor_msgs::TimeReference_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::sensor_msgs::TimeReference_<ContainerAllocator1> & lhs, const ::sensor_msgs::TimeReference_<ContainerAllocator2> & rhs)
{
return lhs.header == rhs.header &&
lhs.time_ref == rhs.time_ref &&
lhs.source == rhs.source;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::sensor_msgs::TimeReference_<ContainerAllocator1> & lhs, const ::sensor_msgs::TimeReference_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace sensor_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::TimeReference_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::sensor_msgs::TimeReference_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::TimeReference_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::sensor_msgs::TimeReference_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::TimeReference_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::sensor_msgs::TimeReference_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::sensor_msgs::TimeReference_<ContainerAllocator> >
{
static const char* value()
{
return "fded64a0265108ba86c3d38fb11c0c16";
}
static const char* value(const ::sensor_msgs::TimeReference_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xfded64a0265108baULL;
static const uint64_t static_value2 = 0x86c3d38fb11c0c16ULL;
};
template<class ContainerAllocator>
struct DataType< ::sensor_msgs::TimeReference_<ContainerAllocator> >
{
static const char* value()
{
return "sensor_msgs/TimeReference";
}
static const char* value(const ::sensor_msgs::TimeReference_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::sensor_msgs::TimeReference_<ContainerAllocator> >
{
static const char* value()
{
return "# Measurement from an external time source not actively synchronized with the system clock.\n"
"\n"
"Header header # stamp is system time for which measurement was valid\n"
" # frame_id is not used \n"
"\n"
"time time_ref # corresponding time from this external source\n"
"string source # (optional) name of time source\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"
;
}
static const char* value(const ::sensor_msgs::TimeReference_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::sensor_msgs::TimeReference_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.time_ref);
stream.next(m.source);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct TimeReference_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::sensor_msgs::TimeReference_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::sensor_msgs::TimeReference_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "time_ref: ";
Printer<ros::Time>::stream(s, indent + " ", v.time_ref);
s << indent << "source: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.source);
}
};
} // namespace message_operations
} // namespace ros
#endif // SENSOR_MSGS_MESSAGE_TIMEREFERENCE_H

51
thirdparty/ros/include/sensor_msgs/distortion_models.h vendored Normal file
View File

@@ -0,0 +1,51 @@
/*********************************************************************
* Software License Agreement (BSD License)
*
* Copyright (c) 2010, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the Willow Garage nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*********************************************************************/
#ifndef SENSOR_MSGS_DISTORTION_MODELS_H
#define SENSOR_MSGS_DISTORTION_MODELS_H
#include <string>
namespace sensor_msgs
{
namespace distortion_models
{
const std::string PLUMB_BOB = "plumb_bob";
const std::string RATIONAL_POLYNOMIAL = "rational_polynomial";
const std::string EQUIDISTANT = "equidistant";
}
}
#endif

70
thirdparty/ros/include/sensor_msgs/fill_image.h vendored Normal file
View File

@@ -0,0 +1,70 @@
/*********************************************************************
* Software License Agreement (BSD License)
*
* Copyright (c) 2008, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the Willow Garage nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*********************************************************************/
#ifndef FILLIMAGE_HH
#define FILLIMAGE_HH
#include "sensor_msgs/Image.h"
#include "sensor_msgs/image_encodings.h"
namespace sensor_msgs
{
static inline bool fillImage(Image& image,
const std::string& encoding_arg,
uint32_t rows_arg,
uint32_t cols_arg,
uint32_t step_arg,
const void* data_arg)
{
image.encoding = encoding_arg;
image.height = rows_arg;
image.width = cols_arg;
image.step = step_arg;
size_t st0 = (step_arg * rows_arg);
image.data.resize(st0);
memcpy(&image.data[0], data_arg, st0);
image.is_bigendian = 0;
return true;
}
static inline void clearImage(Image& image)
{
image.data.resize(0);
}
}
#endif

233
thirdparty/ros/include/sensor_msgs/image_encodings.h vendored Normal file
View File

@@ -0,0 +1,233 @@
/*********************************************************************
* Software License Agreement (BSD License)
*
* Copyright (c) 2009, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the Willow Garage nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*********************************************************************/
#ifndef SENSOR_MSGS_IMAGE_ENCODINGS_H
#define SENSOR_MSGS_IMAGE_ENCODINGS_H
#include <cstdlib>
#include <stdexcept>
#include <string>
namespace sensor_msgs
{
namespace image_encodings
{
const std::string RGB8 = "rgb8";
const std::string RGBA8 = "rgba8";
const std::string RGB16 = "rgb16";
const std::string RGBA16 = "rgba16";
const std::string BGR8 = "bgr8";
const std::string BGRA8 = "bgra8";
const std::string BGR16 = "bgr16";
const std::string BGRA16 = "bgra16";
const std::string MONO8="mono8";
const std::string MONO16="mono16";
// OpenCV CvMat types
const std::string TYPE_8UC1="8UC1";
const std::string TYPE_8UC2="8UC2";
const std::string TYPE_8UC3="8UC3";
const std::string TYPE_8UC4="8UC4";
const std::string TYPE_8SC1="8SC1";
const std::string TYPE_8SC2="8SC2";
const std::string TYPE_8SC3="8SC3";
const std::string TYPE_8SC4="8SC4";
const std::string TYPE_16UC1="16UC1";
const std::string TYPE_16UC2="16UC2";
const std::string TYPE_16UC3="16UC3";
const std::string TYPE_16UC4="16UC4";
const std::string TYPE_16SC1="16SC1";
const std::string TYPE_16SC2="16SC2";
const std::string TYPE_16SC3="16SC3";
const std::string TYPE_16SC4="16SC4";
const std::string TYPE_32SC1="32SC1";
const std::string TYPE_32SC2="32SC2";
const std::string TYPE_32SC3="32SC3";
const std::string TYPE_32SC4="32SC4";
const std::string TYPE_32FC1="32FC1";
const std::string TYPE_32FC2="32FC2";
const std::string TYPE_32FC3="32FC3";
const std::string TYPE_32FC4="32FC4";
const std::string TYPE_64FC1="64FC1";
const std::string TYPE_64FC2="64FC2";
const std::string TYPE_64FC3="64FC3";
const std::string TYPE_64FC4="64FC4";
// Bayer encodings
const std::string BAYER_RGGB8="bayer_rggb8";
const std::string BAYER_BGGR8="bayer_bggr8";
const std::string BAYER_GBRG8="bayer_gbrg8";
const std::string BAYER_GRBG8="bayer_grbg8";
const std::string BAYER_RGGB16="bayer_rggb16";
const std::string BAYER_BGGR16="bayer_bggr16";
const std::string BAYER_GBRG16="bayer_gbrg16";
const std::string BAYER_GRBG16="bayer_grbg16";
// Miscellaneous
// This is the UYVY version of YUV422 codec http://www.fourcc.org/yuv.php#UYVY
// with an 8-bit depth
const std::string YUV422="yuv422";
// Prefixes for abstract image encodings
const std::string ABSTRACT_ENCODING_PREFIXES[] = {
"8UC", "8SC", "16UC", "16SC", "32SC", "32FC", "64FC"};
// Utility functions for inspecting an encoding string
static inline bool isColor(const std::string& encoding)
{
return encoding == RGB8 || encoding == BGR8 ||
encoding == RGBA8 || encoding == BGRA8 ||
encoding == RGB16 || encoding == BGR16 ||
encoding == RGBA16 || encoding == BGRA16;
}
static inline bool isMono(const std::string& encoding)
{
return encoding == MONO8 || encoding == MONO16;
}
static inline bool isBayer(const std::string& encoding)
{
return encoding == BAYER_RGGB8 || encoding == BAYER_BGGR8 ||
encoding == BAYER_GBRG8 || encoding == BAYER_GRBG8 ||
encoding == BAYER_RGGB16 || encoding == BAYER_BGGR16 ||
encoding == BAYER_GBRG16 || encoding == BAYER_GRBG16;
}
static inline bool hasAlpha(const std::string& encoding)
{
return encoding == RGBA8 || encoding == BGRA8 ||
encoding == RGBA16 || encoding == BGRA16;
}
static inline int numChannels(const std::string& encoding)
{
// First do the common-case encodings
if (encoding == MONO8 ||
encoding == MONO16)
return 1;
if (encoding == BGR8 ||
encoding == RGB8 ||
encoding == BGR16 ||
encoding == RGB16)
return 3;
if (encoding == BGRA8 ||
encoding == RGBA8 ||
encoding == BGRA16 ||
encoding == RGBA16)
return 4;
if (encoding == BAYER_RGGB8 ||
encoding == BAYER_BGGR8 ||
encoding == BAYER_GBRG8 ||
encoding == BAYER_GRBG8 ||
encoding == BAYER_RGGB16 ||
encoding == BAYER_BGGR16 ||
encoding == BAYER_GBRG16 ||
encoding == BAYER_GRBG16)
return 1;
// Now all the generic content encodings
// TODO: Rewrite with regex when ROS supports C++11
for (size_t i=0; i < sizeof(ABSTRACT_ENCODING_PREFIXES) / sizeof(*ABSTRACT_ENCODING_PREFIXES); i++)
{
std::string prefix = ABSTRACT_ENCODING_PREFIXES[i];
if (encoding.substr(0, prefix.size()) != prefix)
continue;
if (encoding.size() == prefix.size())
return 1; // ex. 8UC -> 1
int n_channel = atoi(encoding.substr(prefix.size(),
encoding.size() - prefix.size()).c_str()); // ex. 8UC5 -> 5
if (n_channel != 0)
return n_channel; // valid encoding string
}
if (encoding == YUV422)
return 2;
throw std::runtime_error("Unknown encoding " + encoding);
return -1;
}
static inline int bitDepth(const std::string& encoding)
{
if (encoding == MONO16)
return 16;
if (encoding == MONO8 ||
encoding == BGR8 ||
encoding == RGB8 ||
encoding == BGRA8 ||
encoding == RGBA8 ||
encoding == BAYER_RGGB8 ||
encoding == BAYER_BGGR8 ||
encoding == BAYER_GBRG8 ||
encoding == BAYER_GRBG8)
return 8;
if (encoding == MONO16 ||
encoding == BGR16 ||
encoding == RGB16 ||
encoding == BGRA16 ||
encoding == RGBA16 ||
encoding == BAYER_RGGB16 ||
encoding == BAYER_BGGR16 ||
encoding == BAYER_GBRG16 ||
encoding == BAYER_GRBG16)
return 16;
// Now all the generic content encodings
// TODO: Rewrite with regex when ROS supports C++11
for (size_t i=0; i < sizeof(ABSTRACT_ENCODING_PREFIXES) / sizeof(*ABSTRACT_ENCODING_PREFIXES); i++)
{
std::string prefix = ABSTRACT_ENCODING_PREFIXES[i];
if (encoding.substr(0, prefix.size()) != prefix)
continue;
if (encoding.size() == prefix.size())
return atoi(prefix.c_str()); // ex. 8UC -> 8
int n_channel = atoi(encoding.substr(prefix.size(),
encoding.size() - prefix.size()).c_str()); // ex. 8UC10 -> 10
if (n_channel != 0)
return atoi(prefix.c_str()); // valid encoding string
}
if (encoding == YUV422)
return 8;
throw std::runtime_error("Unknown encoding " + encoding);
return -1;
}
}
}
#endif

417
thirdparty/ros/include/sensor_msgs/impl/point_cloud2_iterator.h vendored Normal file
View File

@@ -0,0 +1,417 @@
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2013, Open Source Robotics Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Open Source Robotics Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H
#define SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H
#include <sensor_msgs/PointCloud2.h>
#include <cstdarg>
#include <sstream>
#include <string>
#include <vector>
/**
* \brief Private implementation used by PointCloud2Iterator
* \author Vincent Rabaud
*/
namespace
{
/** Return the size of a datatype (which is an enum of sensor_msgs::PointField::) in bytes
* @param datatype one of the enums of sensor_msgs::PointField::
*/
inline int sizeOfPointField(int datatype)
{
if ((datatype == sensor_msgs::PointField::INT8) || (datatype == sensor_msgs::PointField::UINT8))
return 1;
else if ((datatype == sensor_msgs::PointField::INT16) || (datatype == sensor_msgs::PointField::UINT16))
return 2;
else if ((datatype == sensor_msgs::PointField::INT32) || (datatype == sensor_msgs::PointField::UINT32) ||
(datatype == sensor_msgs::PointField::FLOAT32))
return 4;
else if (datatype == sensor_msgs::PointField::FLOAT64)
return 8;
else
{
std::stringstream err;
err << "PointField of type " << datatype << " does not exist";
throw std::runtime_error(err.str());
}
return -1;
}
/** Private function that adds a PointField to the "fields" member of a PointCloud2
* @param cloud_msg the PointCloud2 to add a field to
* @param name the name of the field
* @param count the number of elements in the PointField
* @param datatype the datatype of the elements
* @param offset the offset of that element
* @return the offset of the next PointField that will be added to the PointCLoud2
*/
inline int addPointField(sensor_msgs::PointCloud2 &cloud_msg, const std::string &name, int count, int datatype,
int offset)
{
sensor_msgs::PointField point_field;
point_field.name = name;
point_field.count = count;
point_field.datatype = datatype;
point_field.offset = offset;
cloud_msg.fields.push_back(point_field);
// Update the offset
return offset + point_field.count * sizeOfPointField(datatype);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace sensor_msgs
{
inline PointCloud2Modifier::PointCloud2Modifier(PointCloud2& cloud_msg) : cloud_msg_(cloud_msg)
{
}
inline size_t PointCloud2Modifier::size() const
{
return cloud_msg_.data.size() / cloud_msg_.point_step;
}
inline void PointCloud2Modifier::reserve(size_t size)
{
cloud_msg_.data.reserve(size * cloud_msg_.point_step);
}
inline void PointCloud2Modifier::resize(size_t size)
{
cloud_msg_.data.resize(size * cloud_msg_.point_step);
// Update height/width
if (cloud_msg_.height == 1) {
cloud_msg_.width = size;
cloud_msg_.row_step = size * cloud_msg_.point_step;
} else
if (cloud_msg_.width == 1)
cloud_msg_.height = size;
else {
cloud_msg_.height = 1;
cloud_msg_.width = size;
cloud_msg_.row_step = size * cloud_msg_.point_step;
}
}
inline void PointCloud2Modifier::clear()
{
cloud_msg_.data.clear();
// Update height/width
if (cloud_msg_.height == 1)
cloud_msg_.row_step = cloud_msg_.width = 0;
else
if (cloud_msg_.width == 1)
cloud_msg_.height = 0;
else
cloud_msg_.row_step = cloud_msg_.width = cloud_msg_.height = 0;
}
/**
* @brief Function setting some fields in a PointCloud and adjusting the
* internals of the PointCloud2
* @param n_fields the number of fields to add. The fields are given as
* triplets: name of the field as char*, number of elements in the
* field, the datatype of the elements in the field
*
* E.g, you create your PointCloud2 message with XYZ/RGB as follows:
* <PRE>
* setPointCloud2FieldsByString(cloud_msg, 4, "x", 1, sensor_msgs::PointField::FLOAT32,
* "y", 1, sensor_msgs::PointField::FLOAT32,
* "z", 1, sensor_msgs::PointField::FLOAT32,
* "rgb", 1, sensor_msgs::PointField::FLOAT32);
* </PRE>
* WARNING: THIS DOES NOT TAKE INTO ACCOUNT ANY PADDING AS DONE UNTIL HYDRO
* For simple usual cases, the overloaded setPointCloud2FieldsByString is what you want.
*/
inline void PointCloud2Modifier::setPointCloud2Fields(int n_fields, ...)
{
cloud_msg_.fields.clear();
cloud_msg_.fields.reserve(n_fields);
va_list vl;
va_start(vl, n_fields);
int offset = 0;
for (int i = 0; i < n_fields; ++i) {
// Create the corresponding PointField
std::string name(va_arg(vl, char*));
int count(va_arg(vl, int));
int datatype(va_arg(vl, int));
offset = addPointField(cloud_msg_, name, count, datatype, offset);
}
va_end(vl);
// Resize the point cloud accordingly
cloud_msg_.point_step = offset;
cloud_msg_.row_step = cloud_msg_.width * cloud_msg_.point_step;
cloud_msg_.data.resize(cloud_msg_.height * cloud_msg_.row_step);
}
/**
* @brief Function setting some fields in a PointCloud and adjusting the
* internals of the PointCloud2
* @param n_fields the number of fields to add. The fields are given as
* strings: "xyz" (3 floats), "rgb" (3 uchar stacked in a float),
* "rgba" (4 uchar stacked in a float)
* @return void
*
* WARNING: THIS FUNCTION DOES ADD ANY NECESSARY PADDING TRANSPARENTLY
*/
inline void PointCloud2Modifier::setPointCloud2FieldsByString(int n_fields, ...)
{
cloud_msg_.fields.clear();
cloud_msg_.fields.reserve(n_fields);
va_list vl;
va_start(vl, n_fields);
int offset = 0;
for (int i = 0; i < n_fields; ++i) {
// Create the corresponding PointFields
std::string
field_name = std::string(va_arg(vl, char*));
if (field_name == "xyz") {
sensor_msgs::PointField point_field;
// Do x, y and z
offset = addPointField(cloud_msg_, "x", 1, sensor_msgs::PointField::FLOAT32, offset);
offset = addPointField(cloud_msg_, "y", 1, sensor_msgs::PointField::FLOAT32, offset);
offset = addPointField(cloud_msg_, "z", 1, sensor_msgs::PointField::FLOAT32, offset);
offset += sizeOfPointField(sensor_msgs::PointField::FLOAT32);
} else
if ((field_name == "rgb") || (field_name == "rgba")) {
offset = addPointField(cloud_msg_, field_name, 1, sensor_msgs::PointField::FLOAT32, offset);
offset += 3 * sizeOfPointField(sensor_msgs::PointField::FLOAT32);
} else
throw std::runtime_error("Field " + field_name + " does not exist");
}
va_end(vl);
// Resize the point cloud accordingly
cloud_msg_.point_step = offset;
cloud_msg_.row_step = cloud_msg_.width * cloud_msg_.point_step;
cloud_msg_.data.resize(cloud_msg_.height * cloud_msg_.row_step);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace impl
{
/**
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
PointCloud2IteratorBase<T, TT, U, C, V>::PointCloud2IteratorBase() : data_char_(0), data_(0), data_end_(0)
{
}
/**
* @param cloud_msg_ The PointCloud2 to iterate upon
* @param field_name The field to iterate upon
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
PointCloud2IteratorBase<T, TT, U, C, V>::PointCloud2IteratorBase(C &cloud_msg, const std::string &field_name)
{
int offset = set_field(cloud_msg, field_name);
data_char_ = &(cloud_msg.data.front()) + offset;
data_ = reinterpret_cast<TT*>(data_char_);
data_end_ = reinterpret_cast<TT*>(&(cloud_msg.data.back()) + 1 + offset);
}
/** Assignment operator
* @param iter the iterator to copy data from
* @return a reference to *this
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
V<T>& PointCloud2IteratorBase<T, TT, U, C, V>::operator =(const V<T> &iter)
{
if (this != &iter)
{
point_step_ = iter.point_step_;
data_char_ = iter.data_char_;
data_ = iter.data_;
data_end_ = iter.data_end_;
is_bigendian_ = iter.is_bigendian_;
}
return *this;
}
/** Access the i th element starting at the current pointer (useful when a field has several elements of the same
* type)
* @param i
* @return a reference to the i^th value from the current position
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
TT& PointCloud2IteratorBase<T, TT, U, C, V>::operator [](size_t i) const
{
return *(data_ + i);
}
/** Dereference the iterator. Equivalent to accessing it through [0]
* @return the value to which the iterator is pointing
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
TT& PointCloud2IteratorBase<T, TT, U, C, V>::operator *() const
{
return *data_;
}
/** Increase the iterator to the next element
* @return a reference to the updated iterator
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
V<T>& PointCloud2IteratorBase<T, TT, U, C, V>::operator ++()
{
data_char_ += point_step_;
data_ = reinterpret_cast<TT*>(data_char_);
return *static_cast<V<T>*>(this);
}
/** Basic pointer addition
* @param i the amount to increase the iterator by
* @return an iterator with an increased position
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
V<T> PointCloud2IteratorBase<T, TT, U, C, V>::operator +(int i)
{
V<T> res = *static_cast<V<T>*>(this);
res.data_char_ += i*point_step_;
res.data_ = reinterpret_cast<TT*>(res.data_char_);
return res;
}
/** Increase the iterator by a certain amount
* @return a reference to the updated iterator
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
V<T>& PointCloud2IteratorBase<T, TT, U, C, V>::operator +=(int i)
{
data_char_ += i*point_step_;
data_ = reinterpret_cast<TT*>(data_char_);
return *static_cast<V<T>*>(this);
}
/** Compare to another iterator
* @return whether the current iterator points to a different address than the other one
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
bool PointCloud2IteratorBase<T, TT, U, C, V>::operator !=(const V<T>& iter) const
{
return iter.data_ != data_;
}
/** Return the end iterator
* @return the end iterator (useful when performing normal iterator processing with ++)
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
V<T> PointCloud2IteratorBase<T, TT, U, C, V>::end() const
{
V<T> res = *static_cast<const V<T>*>(this);
res.data_ = data_end_;
return res;
}
/** Common code to set the field of the PointCloud2
* @param cloud_msg the PointCloud2 to modify
* @param field_name the name of the field to iterate upon
* @return the offset at which the field is found
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
int PointCloud2IteratorBase<T, TT, U, C, V>::set_field(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name)
{
is_bigendian_ = cloud_msg.is_bigendian;
point_step_ = cloud_msg.point_step;
// make sure the channel is valid
std::vector<sensor_msgs::PointField>::const_iterator field_iter = cloud_msg.fields.begin(), field_end =
cloud_msg.fields.end();
while ((field_iter != field_end) && (field_iter->name != field_name))
++field_iter;
if (field_iter == field_end) {
// Handle the special case of r,g,b,a (we assume they are understood as the channels of an rgb or rgba field)
if ((field_name == "r") || (field_name == "g") || (field_name == "b") || (field_name == "a"))
{
// Check that rgb or rgba is present
field_iter = cloud_msg.fields.begin();
while ((field_iter != field_end) && (field_iter->name != "rgb") && (field_iter->name != "rgba"))
++field_iter;
if (field_iter == field_end)
throw std::runtime_error("Field " + field_name + " does not exist");
if (field_name == "r")
{
if (is_bigendian_)
return field_iter->offset + 1;
else
return field_iter->offset + 2;
}
if (field_name == "g")
{
if (is_bigendian_)
return field_iter->offset + 2;
else
return field_iter->offset + 1;
}
if (field_name == "b")
{
if (is_bigendian_)
return field_iter->offset + 3;
else
return field_iter->offset + 0;
}
if (field_name == "a")
{
if (is_bigendian_)
return field_iter->offset + 0;
else
return field_iter->offset + 3;
}
} else
throw std::runtime_error("Field " + field_name + " does not exist");
}
return field_iter->offset;
}
}
}
#endif// SENSOR_MSGS_IMPL_POINT_CLOUD_ITERATOR_H

302
thirdparty/ros/include/sensor_msgs/point_cloud2_iterator.h vendored Normal file
View File

@@ -0,0 +1,302 @@
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2013, Open Source Robotics Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Open Source Robotics Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H
#define SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H
#include <sensor_msgs/PointCloud2.h>
#include <cstdarg>
#include <string>
#include <vector>
/**
* \brief Tools for manipulating sensor_msgs
*
* This file provides two sets of utilities to modify and parse PointCloud2
* The first set allows you to conveniently set the fields by hand:
* <PRE>
* #include <sensor_msgs/point_cloud_iterator.h>
* // Create a PointCloud2
* sensor_msgs::PointCloud2 cloud_msg;
* // Fill some internals of the PoinCloud2 like the header/width/height ...
* cloud_msgs.height = 1; cloud_msgs.width = 4;
* // Set the point fields to xyzrgb and resize the vector with the following command
* // 4 is for the number of added fields. Each come in triplet: the name of the PointField,
* // the number of occurrences of the type in the PointField, the type of the PointField
* sensor_msgs::PointCloud2Modifier modifier(cloud_msg);
* modifier.setPointCloud2Fields(4, "x", 1, sensor_msgs::PointField::FLOAT32,
* "y", 1, sensor_msgs::PointField::FLOAT32,
* "z", 1, sensor_msgs::PointField::FLOAT32,
* "rgb", 1, sensor_msgs::PointField::FLOAT32);
* // For convenience and the xyz, rgb, rgba fields, you can also use the following overloaded function.
* // You have to be aware that the following function does add extra padding for backward compatibility though
* // so it is definitely the solution of choice for PointXYZ and PointXYZRGB
* // 2 is for the number of fields to add
* modifier.setPointCloud2FieldsByString(2, "xyz", "rgb");
* // You can then reserve / resize as usual
* modifier.resize(100);
* </PRE>
*
* The second set allow you to traverse your PointCloud using an iterator:
* <PRE>
* // Define some raw data we'll put in the PointCloud2
* float point_data[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0};
* uint8_t color_data[] = {40, 80, 120, 160, 200, 240, 20, 40, 60, 80, 100, 120};
* // Define the iterators. When doing so, you define the Field you would like to iterate upon and
* // the type of you would like returned: it is not necessary the type of the PointField as sometimes
* // you pack data in another type (e.g. 3 uchar + 1 uchar for RGB are packed in a float)
* sensor_msgs::PointCloud2Iterator<float> iter_x(cloud_msg, "x");
* sensor_msgs::PointCloud2Iterator<float> iter_y(cloud_msg, "y");
* sensor_msgs::PointCloud2Iterator<float> iter_z(cloud_msg, "z");
* // Even though the r,g,b,a fields do not exist (it's usually rgb, rgba), you can create iterators for
* // those: they will handle data packing for you (in little endian RGB is packed as *,R,G,B in a float
* // and RGBA as A,R,G,B)
* sensor_msgs::PointCloud2Iterator<uint8_t> iter_r(cloud_msg, "r");
* sensor_msgs::PointCloud2Iterator<uint8_t> iter_g(cloud_msg, "g");
* sensor_msgs::PointCloud2Iterator<uint8_t> iter_b(cloud_msg, "b");
* // Fill the PointCloud2
* for(size_t i=0; i<n_points; ++i, ++iter_x, ++iter_y, ++iter_z, ++iter_r, ++iter_g, ++iter_b) {
* *iter_x = point_data[3*i+0];
* *iter_y = point_data[3*i+1];
* *iter_z = point_data[3*i+2];
* *iter_r = color_data[3*i+0];
* *iter_g = color_data[3*i+1];
* *iter_b = color_data[3*i+2];
* }
* </PRE>
*/
namespace sensor_msgs
{
/**
* @brief Enables modifying a sensor_msgs::PointCloud2 like a container
*/
class PointCloud2Modifier
{
public:
/**
* @brief Default constructor
* @param cloud_msg The sensor_msgs::PointCloud2 to modify
*/
PointCloud2Modifier(PointCloud2& cloud_msg);
/**
* @return the number of T's in the original sensor_msgs::PointCloud2
*/
size_t size() const;
/**
* @param size The number of T's to reserve in the original sensor_msgs::PointCloud2 for
*/
void reserve(size_t size);
/**
* @param size The number of T's to change the size of the original sensor_msgs::PointCloud2 by
*/
void resize(size_t size);
/**
* @brief remove all T's from the original sensor_msgs::PointCloud2
*/
void clear();
/**
* @brief Function setting some fields in a PointCloud and adjusting the
* internals of the PointCloud2
* @param n_fields the number of fields to add. The fields are given as
* triplets: name of the field as char*, number of elements in the
* field, the datatype of the elements in the field
*
* E.g, you create your PointCloud2 message with XYZ/RGB as follows:
* <PRE>
* setPointCloud2Fields(cloud_msg, 4, "x", 1, sensor_msgs::PointField::FLOAT32,
* "y", 1, sensor_msgs::PointField::FLOAT32,
* "z", 1, sensor_msgs::PointField::FLOAT32,
* "rgb", 1, sensor_msgs::PointField::FLOAT32);
* </PRE>
* WARNING: THIS DOES NOT TAKE INTO ACCOUNT ANY PADDING AS DONE UNTIL HYDRO
* For simple usual cases, the overloaded setPointCloud2FieldsByString is what you want.
*/
void setPointCloud2Fields(int n_fields, ...);
/**
* @brief Function setting some fields in a PointCloud and adjusting the
* internals of the PointCloud2
* @param n_fields the number of fields to add. The fields are given as
* strings: "xyz" (3 floats), "rgb" (3 uchar stacked in a float),
* "rgba" (4 uchar stacked in a float)
* @return void
*
* WARNING: THIS FUNCTION DOES ADD ANY NECESSARY PADDING TRANSPARENTLY
*/
void setPointCloud2FieldsByString(int n_fields, ...);
protected:
/** A reference to the original sensor_msgs::PointCloud2 that we read */
PointCloud2& cloud_msg_;
};
namespace impl
{
/** Private base class for PointCloud2Iterator and PointCloud2ConstIterator
* T is the type of the value on which the child class will be templated
* TT is the type of the value to be retrieved (same as T except for constness)
* U is the type of the raw data in PointCloud2 (only uchar and const uchar are supported)
* C is the type of the pointcloud to intialize from (const or not)
* V is the derived class (yop, curiously recurring template pattern)
*/
template<typename T, typename TT, typename U, typename C, template <typename> class V>
class PointCloud2IteratorBase
{
public:
/**
*/
PointCloud2IteratorBase();
/**
* @param cloud_msg The PointCloud2 to iterate upon
* @param field_name The field to iterate upon
*/
PointCloud2IteratorBase(C &cloud_msg, const std::string &field_name);
/** Assignment operator
* @param iter the iterator to copy data from
* @return a reference to *this
*/
V<T>& operator =(const V<T>& iter);
/** Access the i th element starting at the current pointer (useful when a field has several elements of the same
* type)
* @param i
* @return a reference to the i^th value from the current position
*/
TT& operator [](size_t i) const;
/** Dereference the iterator. Equivalent to accessing it through [0]
* @return the value to which the iterator is pointing
*/
TT& operator *() const;
/** Increase the iterator to the next element
* @return a reference to the updated iterator
*/
V<T>& operator ++();
/** Basic pointer addition
* @param i the amount to increase the iterator by
* @return an iterator with an increased position
*/
V<T> operator +(int i);
/** Increase the iterator by a certain amount
* @return a reference to the updated iterator
*/
V<T>& operator +=(int i);
/** Compare to another iterator
* @return whether the current iterator points to a different address than the other one
*/
bool operator !=(const V<T>& iter) const;
/** Return the end iterator
* @return the end iterator (useful when performing normal iterator processing with ++)
*/
V<T> end() const;
private:
/** Common code to set the field of the PointCloud2
* @param cloud_msg the PointCloud2 to modify
* @param field_name the name of the field to iterate upon
* @return the offset at which the field is found
*/
int set_field(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name);
/** The "point_step" of the original cloud */
int point_step_;
/** The raw data in uchar* where the iterator is */
U* data_char_;
/** The cast data where the iterator is */
TT* data_;
/** The end() pointer of the iterator */
TT* data_end_;
/** Whether the fields are stored as bigendian */
bool is_bigendian_;
};
}
/**
* \brief Class that can iterate over a PointCloud2
*
* T type of the element being iterated upon
* E.g, you create your PointClou2 message as follows:
* <PRE>
* setPointCloud2FieldsByString(cloud_msg, 2, "xyz", "rgb");
* </PRE>
*
* For iterating over XYZ, you do :
* <PRE>
* sensor_msgs::PointCloud2Iterator<float> iter_x(cloud_msg, "x");
* </PRE>
* and then access X through iter_x[0] or *iter_x
* You could create an iterator for Y and Z too but as they are consecutive,
* you can just use iter_x[1] and iter_x[2]
*
* For iterating over RGB, you do:
* <PRE>
* sensor_msgs::PointCloud2Iterator<uint8_t> iter_rgb(cloud_msg, "rgb");
* </PRE>
* and then access R,G,B through iter_rgb[0], iter_rgb[1], iter_rgb[2]
*/
template<typename T>
class PointCloud2Iterator : public impl::PointCloud2IteratorBase<T, T, unsigned char, sensor_msgs::PointCloud2, PointCloud2Iterator>
{
public:
PointCloud2Iterator(sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name) :
impl::PointCloud2IteratorBase<T, T, unsigned char, sensor_msgs::PointCloud2, sensor_msgs::PointCloud2Iterator>::PointCloud2IteratorBase(cloud_msg, field_name) {}
};
/**
* \brief Same as a PointCloud2Iterator but for const data
*/
template<typename T>
class PointCloud2ConstIterator : public impl::PointCloud2IteratorBase<T, const T, const unsigned char, const sensor_msgs::PointCloud2, PointCloud2ConstIterator>
{
public:
PointCloud2ConstIterator(const sensor_msgs::PointCloud2 &cloud_msg, const std::string &field_name) :
impl::PointCloud2IteratorBase<T, const T, const unsigned char, const sensor_msgs::PointCloud2, sensor_msgs::PointCloud2ConstIterator>::PointCloud2IteratorBase(cloud_msg, field_name) {}
};
}
#include <sensor_msgs/impl/point_cloud2_iterator.h>
#endif// SENSOR_MSGS_POINT_CLOUD2_ITERATOR_H

169
thirdparty/ros/include/sensor_msgs/point_cloud_conversion.h vendored Normal file
View File

@@ -0,0 +1,169 @@
/*
* Software License Agreement (BSD License)
*
* Copyright (c) 2010, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* $Id$
*
*/
#ifndef SENSOR_MSGS_POINT_CLOUD_CONVERSION_H
#define SENSOR_MSGS_POINT_CLOUD_CONVERSION_H
#include <sensor_msgs/PointCloud.h>
#include <sensor_msgs/PointCloud2.h>
#include <sensor_msgs/point_field_conversion.h>
/**
* \brief Convert between the old (sensor_msgs::PointCloud) and the new (sensor_msgs::PointCloud2) format.
* \author Radu Bogdan Rusu
*/
namespace sensor_msgs
{
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/** \brief Get the index of a specified field (i.e., dimension/channel)
* \param points the the point cloud message
* \param field_name the string defining the field name
*/
static inline int getPointCloud2FieldIndex (const sensor_msgs::PointCloud2 &cloud, const std::string &field_name)
{
// Get the index we need
for (size_t d = 0; d < cloud.fields.size (); ++d)
if (cloud.fields[d].name == field_name)
return (d);
return (-1);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/** \brief Convert a sensor_msgs::PointCloud message to a sensor_msgs::PointCloud2 message.
* \param input the message in the sensor_msgs::PointCloud format
* \param output the resultant message in the sensor_msgs::PointCloud2 format
*/
static inline bool convertPointCloudToPointCloud2 (const sensor_msgs::PointCloud &input, sensor_msgs::PointCloud2 &output)
{
output.header = input.header;
output.width = input.points.size ();
output.height = 1;
output.fields.resize (3 + input.channels.size ());
// Convert x/y/z to fields
output.fields[0].name = "x"; output.fields[1].name = "y"; output.fields[2].name = "z";
int offset = 0;
// All offsets are *4, as all field data types are float32
for (size_t d = 0; d < output.fields.size (); ++d, offset += 4)
{
output.fields[d].offset = offset;
output.fields[d].datatype = sensor_msgs::PointField::FLOAT32;
output.fields[d].count = 1;
}
output.point_step = offset;
output.row_step = output.point_step * output.width;
// Convert the remaining of the channels to fields
for (size_t d = 0; d < input.channels.size (); ++d)
output.fields[3 + d].name = input.channels[d].name;
output.data.resize (input.points.size () * output.point_step);
output.is_bigendian = false; // @todo ?
output.is_dense = false;
// Copy the data points
for (size_t cp = 0; cp < input.points.size (); ++cp)
{
memcpy (&output.data[cp * output.point_step + output.fields[0].offset], &input.points[cp].x, sizeof (float));
memcpy (&output.data[cp * output.point_step + output.fields[1].offset], &input.points[cp].y, sizeof (float));
memcpy (&output.data[cp * output.point_step + output.fields[2].offset], &input.points[cp].z, sizeof (float));
for (size_t d = 0; d < input.channels.size (); ++d)
{
if (input.channels[d].values.size() == input.points.size())
{
memcpy (&output.data[cp * output.point_step + output.fields[3 + d].offset], &input.channels[d].values[cp], sizeof (float));
}
}
}
return (true);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/** \brief Convert a sensor_msgs::PointCloud2 message to a sensor_msgs::PointCloud message.
* \param input the message in the sensor_msgs::PointCloud2 format
* \param output the resultant message in the sensor_msgs::PointCloud format
*/
static inline bool convertPointCloud2ToPointCloud (const sensor_msgs::PointCloud2 &input, sensor_msgs::PointCloud &output)
{
output.header = input.header;
output.points.resize (input.width * input.height);
output.channels.resize (input.fields.size () - 3);
// Get the x/y/z field offsets
int x_idx = getPointCloud2FieldIndex (input, "x");
int y_idx = getPointCloud2FieldIndex (input, "y");
int z_idx = getPointCloud2FieldIndex (input, "z");
if (x_idx == -1 || y_idx == -1 || z_idx == -1)
{
std::cerr << "x/y/z coordinates not found! Cannot convert to sensor_msgs::PointCloud!" << std::endl;
return (false);
}
int x_offset = input.fields[x_idx].offset;
int y_offset = input.fields[y_idx].offset;
int z_offset = input.fields[z_idx].offset;
uint8_t x_datatype = input.fields[x_idx].datatype;
uint8_t y_datatype = input.fields[y_idx].datatype;
uint8_t z_datatype = input.fields[z_idx].datatype;
// Convert the fields to channels
int cur_c = 0;
for (size_t d = 0; d < input.fields.size (); ++d)
{
if ((int)input.fields[d].offset == x_offset || (int)input.fields[d].offset == y_offset || (int)input.fields[d].offset == z_offset)
continue;
output.channels[cur_c].name = input.fields[d].name;
output.channels[cur_c].values.resize (output.points.size ());
cur_c++;
}
// Copy the data points
for (size_t cp = 0; cp < output.points.size (); ++cp)
{
// Copy x/y/z
output.points[cp].x = sensor_msgs::readPointCloud2BufferValue<float>(&input.data[cp * input.point_step + x_offset], x_datatype);
output.points[cp].y = sensor_msgs::readPointCloud2BufferValue<float>(&input.data[cp * input.point_step + y_offset], y_datatype);
output.points[cp].z = sensor_msgs::readPointCloud2BufferValue<float>(&input.data[cp * input.point_step + z_offset], z_datatype);
// Copy the rest of the data
int cur_c = 0;
for (size_t d = 0; d < input.fields.size (); ++d)
{
if ((int)input.fields[d].offset == x_offset || (int)input.fields[d].offset == y_offset || (int)input.fields[d].offset == z_offset)
continue;
output.channels[cur_c++].values[cp] = sensor_msgs::readPointCloud2BufferValue<float>(&input.data[cp * input.point_step + input.fields[d].offset], input.fields[d].datatype);
}
}
return (true);
}
}
#endif// SENSOR_MSGS_POINT_CLOUD_CONVERSION_H

180
thirdparty/ros/include/sensor_msgs/point_field_conversion.h vendored Normal file
View File

@@ -0,0 +1,180 @@
/*
* Software License Agreement (BSD License)
*
* Robot Operating System code by the University of Osnabrück
* Copyright (c) 2015, University of Osnabrück
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above
* copyright notice, this list of conditions and the following
* disclaimer.
*
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
*
* point_field_conversion.h
*
* Created on: 16.07.2015
* Authors: Sebastian Pütz <spuetz@uni-osnabrueck.de>
*/
#ifndef SENSOR_MSGS_POINT_FIELD_CONVERSION_H
#define SENSOR_MSGS_POINT_FIELD_CONVERSION_H
/**
* \brief This file provides a type to enum mapping for the different
* PointField types and methods to read and write in
* a PointCloud2 buffer for the different PointField types.
* \author Sebastian Pütz
*/
namespace sensor_msgs{
/*!
* \Enum to type mapping.
*/
template<int> struct pointFieldTypeAsType {};
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT8> { typedef int8_t type; };
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT8> { typedef uint8_t type; };
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT16> { typedef int16_t type; };
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT16> { typedef uint16_t type; };
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT32> { typedef int32_t type; };
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT32> { typedef uint32_t type; };
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::FLOAT32> { typedef float type; };
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::FLOAT64> { typedef double type; };
/*!
* \Type to enum mapping.
*/
template<typename T> struct typeAsPointFieldType {};
template<> struct typeAsPointFieldType<int8_t> { static const uint8_t value = sensor_msgs::PointField::INT8; };
template<> struct typeAsPointFieldType<uint8_t> { static const uint8_t value = sensor_msgs::PointField::UINT8; };
template<> struct typeAsPointFieldType<int16_t> { static const uint8_t value = sensor_msgs::PointField::INT16; };
template<> struct typeAsPointFieldType<uint16_t> { static const uint8_t value = sensor_msgs::PointField::UINT16; };
template<> struct typeAsPointFieldType<int32_t> { static const uint8_t value = sensor_msgs::PointField::INT32; };
template<> struct typeAsPointFieldType<uint32_t> { static const uint8_t value = sensor_msgs::PointField::UINT32; };
template<> struct typeAsPointFieldType<float> { static const uint8_t value = sensor_msgs::PointField::FLOAT32; };
template<> struct typeAsPointFieldType<double> { static const uint8_t value = sensor_msgs::PointField::FLOAT64; };
/*!
* \Converts a value at the given pointer position, interpreted as the datatype
* specified by the given template argument point_field_type, to the given
* template type T and returns it.
* \param data_ptr pointer into the point cloud 2 buffer
* \tparam point_field_type sensor_msgs::PointField datatype value
* \tparam T return type
*/
template<int point_field_type, typename T>
inline T readPointCloud2BufferValue(const unsigned char* data_ptr){
typedef typename pointFieldTypeAsType<point_field_type>::type type;
return static_cast<T>(*(reinterpret_cast<type const *>(data_ptr)));
}
/*!
* \Converts a value at the given pointer position interpreted as the datatype
* specified by the given datatype parameter to the given template type and returns it.
* \param data_ptr pointer into the point cloud 2 buffer
* \param datatype sensor_msgs::PointField datatype value
* \tparam T return type
*/
template<typename T>
inline T readPointCloud2BufferValue(const unsigned char* data_ptr, const unsigned char datatype){
switch(datatype){
case sensor_msgs::PointField::INT8:
return readPointCloud2BufferValue<sensor_msgs::PointField::INT8, T>(data_ptr);
case sensor_msgs::PointField::UINT8:
return readPointCloud2BufferValue<sensor_msgs::PointField::UINT8, T>(data_ptr);
case sensor_msgs::PointField::INT16:
return readPointCloud2BufferValue<sensor_msgs::PointField::INT16, T>(data_ptr);
case sensor_msgs::PointField::UINT16:
return readPointCloud2BufferValue<sensor_msgs::PointField::UINT16, T>(data_ptr);
case sensor_msgs::PointField::INT32:
return readPointCloud2BufferValue<sensor_msgs::PointField::INT32, T>(data_ptr);
case sensor_msgs::PointField::UINT32:
return readPointCloud2BufferValue<sensor_msgs::PointField::UINT32, T>(data_ptr);
case sensor_msgs::PointField::FLOAT32:
return readPointCloud2BufferValue<sensor_msgs::PointField::FLOAT32, T>(data_ptr);
case sensor_msgs::PointField::FLOAT64:
return readPointCloud2BufferValue<sensor_msgs::PointField::FLOAT64, T>(data_ptr);
}
// This should never be reached, but return statement added to avoid compiler warning. (#84)
return T();
}
/*!
* \Inserts a given value at the given point position interpreted as the datatype
* specified by the template argument point_field_type.
* \param data_ptr pointer into the point cloud 2 buffer
* \param value the value to insert
* \tparam point_field_type sensor_msgs::PointField datatype value
* \tparam T type of the value to insert
*/
template<int point_field_type, typename T>
inline void writePointCloud2BufferValue(unsigned char* data_ptr, T value){
typedef typename pointFieldTypeAsType<point_field_type>::type type;
*(reinterpret_cast<type*>(data_ptr)) = static_cast<type>(value);
}
/*!
* \Inserts a given value at the given point position interpreted as the datatype
* specified by the given datatype parameter.
* \param data_ptr pointer into the point cloud 2 buffer
* \param datatype sensor_msgs::PointField datatype value
* \param value the value to insert
* \tparam T type of the value to insert
*/
template<typename T>
inline void writePointCloud2BufferValue(unsigned char* data_ptr, const unsigned char datatype, T value){
switch(datatype){
case sensor_msgs::PointField::INT8:
writePointCloud2BufferValue<sensor_msgs::PointField::INT8, T>(data_ptr, value);
break;
case sensor_msgs::PointField::UINT8:
writePointCloud2BufferValue<sensor_msgs::PointField::UINT8, T>(data_ptr, value);
break;
case sensor_msgs::PointField::INT16:
writePointCloud2BufferValue<sensor_msgs::PointField::INT16, T>(data_ptr, value);
break;
case sensor_msgs::PointField::UINT16:
writePointCloud2BufferValue<sensor_msgs::PointField::UINT16, T>(data_ptr, value);
break;
case sensor_msgs::PointField::INT32:
writePointCloud2BufferValue<sensor_msgs::PointField::INT32, T>(data_ptr, value);
break;
case sensor_msgs::PointField::UINT32:
writePointCloud2BufferValue<sensor_msgs::PointField::UINT32, T>(data_ptr, value);
break;
case sensor_msgs::PointField::FLOAT32:
writePointCloud2BufferValue<sensor_msgs::PointField::FLOAT32, T>(data_ptr, value);
break;
case sensor_msgs::PointField::FLOAT64:
writePointCloud2BufferValue<sensor_msgs::PointField::FLOAT64, T>(data_ptr, value);
break;
}
}
}
#endif /* point_field_conversion.h */

195
thirdparty/ros/include/std_msgs/Bool.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Bool.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_BOOL_H
#define STD_MSGS_MESSAGE_BOOL_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Bool_
{
typedef Bool_<ContainerAllocator> Type;
Bool_()
: data(false) {
}
Bool_(const ContainerAllocator& _alloc)
: data(false) {
(void)_alloc;
}
typedef uint8_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Bool_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Bool_<ContainerAllocator> const> ConstPtr;
}; // struct Bool_
typedef ::std_msgs::Bool_<std::allocator<void> > Bool;
typedef boost::shared_ptr< ::std_msgs::Bool > BoolPtr;
typedef boost::shared_ptr< ::std_msgs::Bool const> BoolConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Bool_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Bool_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Bool_<ContainerAllocator1> & lhs, const ::std_msgs::Bool_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Bool_<ContainerAllocator1> & lhs, const ::std_msgs::Bool_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Bool_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Bool_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Bool_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Bool_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Bool_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Bool_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Bool_<ContainerAllocator> >
{
static const char* value()
{
return "8b94c1b53db61fb6aed406028ad6332a";
}
static const char* value(const ::std_msgs::Bool_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8b94c1b53db61fb6ULL;
static const uint64_t static_value2 = 0xaed406028ad6332aULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Bool_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Bool";
}
static const char* value(const ::std_msgs::Bool_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Bool_<ContainerAllocator> >
{
static const char* value()
{
return "bool data\n"
;
}
static const char* value(const ::std_msgs::Bool_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Bool_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Bool_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Bool_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Bool_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<uint8_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_BOOL_H

195
thirdparty/ros/include/std_msgs/Byte.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Byte.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_BYTE_H
#define STD_MSGS_MESSAGE_BYTE_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Byte_
{
typedef Byte_<ContainerAllocator> Type;
Byte_()
: data(0) {
}
Byte_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef int8_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Byte_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Byte_<ContainerAllocator> const> ConstPtr;
}; // struct Byte_
typedef ::std_msgs::Byte_<std::allocator<void> > Byte;
typedef boost::shared_ptr< ::std_msgs::Byte > BytePtr;
typedef boost::shared_ptr< ::std_msgs::Byte const> ByteConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Byte_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Byte_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Byte_<ContainerAllocator1> & lhs, const ::std_msgs::Byte_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Byte_<ContainerAllocator1> & lhs, const ::std_msgs::Byte_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Byte_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Byte_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Byte_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Byte_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Byte_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Byte_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Byte_<ContainerAllocator> >
{
static const char* value()
{
return "ad736a2e8818154c487bb80fe42ce43b";
}
static const char* value(const ::std_msgs::Byte_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xad736a2e8818154cULL;
static const uint64_t static_value2 = 0x487bb80fe42ce43bULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Byte_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Byte";
}
static const char* value(const ::std_msgs::Byte_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Byte_<ContainerAllocator> >
{
static const char* value()
{
return "byte data\n"
;
}
static const char* value(const ::std_msgs::Byte_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Byte_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Byte_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Byte_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Byte_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<int8_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_BYTE_H

250
thirdparty/ros/include/std_msgs/ByteMultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/ByteMultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_BYTEMULTIARRAY_H
#define STD_MSGS_MESSAGE_BYTEMULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct ByteMultiArray_
{
typedef ByteMultiArray_<ContainerAllocator> Type;
ByteMultiArray_()
: layout()
, data() {
}
ByteMultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<int8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int8_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::ByteMultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::ByteMultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct ByteMultiArray_
typedef ::std_msgs::ByteMultiArray_<std::allocator<void> > ByteMultiArray;
typedef boost::shared_ptr< ::std_msgs::ByteMultiArray > ByteMultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::ByteMultiArray const> ByteMultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::ByteMultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::ByteMultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::ByteMultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::ByteMultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::ByteMultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::ByteMultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::ByteMultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::ByteMultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::ByteMultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::ByteMultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::ByteMultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::ByteMultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::ByteMultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "70ea476cbcfd65ac2f68f3cda1e891fe";
}
static const char* value(const ::std_msgs::ByteMultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x70ea476cbcfd65acULL;
static const uint64_t static_value2 = 0x2f68f3cda1e891feULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::ByteMultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/ByteMultiArray";
}
static const char* value(const ::std_msgs::ByteMultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::ByteMultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"byte[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::ByteMultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::ByteMultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct ByteMultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::ByteMultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::ByteMultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<int8_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_BYTEMULTIARRAY_H

195
thirdparty/ros/include/std_msgs/Char.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Char.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_CHAR_H
#define STD_MSGS_MESSAGE_CHAR_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Char_
{
typedef Char_<ContainerAllocator> Type;
Char_()
: data(0) {
}
Char_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef uint8_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Char_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Char_<ContainerAllocator> const> ConstPtr;
}; // struct Char_
typedef ::std_msgs::Char_<std::allocator<void> > Char;
typedef boost::shared_ptr< ::std_msgs::Char > CharPtr;
typedef boost::shared_ptr< ::std_msgs::Char const> CharConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Char_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Char_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Char_<ContainerAllocator1> & lhs, const ::std_msgs::Char_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Char_<ContainerAllocator1> & lhs, const ::std_msgs::Char_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Char_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Char_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Char_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Char_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Char_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Char_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Char_<ContainerAllocator> >
{
static const char* value()
{
return "1bf77f25acecdedba0e224b162199717";
}
static const char* value(const ::std_msgs::Char_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x1bf77f25acecdedbULL;
static const uint64_t static_value2 = 0xa0e224b162199717ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Char_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Char";
}
static const char* value(const ::std_msgs::Char_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Char_<ContainerAllocator> >
{
static const char* value()
{
return "char data\n"
;
}
static const char* value(const ::std_msgs::Char_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Char_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Char_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Char_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Char_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<uint8_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_CHAR_H

225
thirdparty/ros/include/std_msgs/ColorRGBA.h vendored Normal file
View File

@@ -0,0 +1,225 @@
// Generated by gencpp from file std_msgs/ColorRGBA.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_COLORRGBA_H
#define STD_MSGS_MESSAGE_COLORRGBA_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct ColorRGBA_
{
typedef ColorRGBA_<ContainerAllocator> Type;
ColorRGBA_()
: r(0.0)
, g(0.0)
, b(0.0)
, a(0.0) {
}
ColorRGBA_(const ContainerAllocator& _alloc)
: r(0.0)
, g(0.0)
, b(0.0)
, a(0.0) {
(void)_alloc;
}
typedef float _r_type;
_r_type r;
typedef float _g_type;
_g_type g;
typedef float _b_type;
_b_type b;
typedef float _a_type;
_a_type a;
typedef boost::shared_ptr< ::std_msgs::ColorRGBA_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::ColorRGBA_<ContainerAllocator> const> ConstPtr;
}; // struct ColorRGBA_
typedef ::std_msgs::ColorRGBA_<std::allocator<void> > ColorRGBA;
typedef boost::shared_ptr< ::std_msgs::ColorRGBA > ColorRGBAPtr;
typedef boost::shared_ptr< ::std_msgs::ColorRGBA const> ColorRGBAConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::ColorRGBA_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::ColorRGBA_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::ColorRGBA_<ContainerAllocator1> & lhs, const ::std_msgs::ColorRGBA_<ContainerAllocator2> & rhs)
{
return lhs.r == rhs.r &&
lhs.g == rhs.g &&
lhs.b == rhs.b &&
lhs.a == rhs.a;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::ColorRGBA_<ContainerAllocator1> & lhs, const ::std_msgs::ColorRGBA_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::ColorRGBA_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::ColorRGBA_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::ColorRGBA_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::ColorRGBA_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::ColorRGBA_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::ColorRGBA_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::ColorRGBA_<ContainerAllocator> >
{
static const char* value()
{
return "a29a96539573343b1310c73607334b00";
}
static const char* value(const ::std_msgs::ColorRGBA_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xa29a96539573343bULL;
static const uint64_t static_value2 = 0x1310c73607334b00ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::ColorRGBA_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/ColorRGBA";
}
static const char* value(const ::std_msgs::ColorRGBA_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::ColorRGBA_<ContainerAllocator> >
{
static const char* value()
{
return "float32 r\n"
"float32 g\n"
"float32 b\n"
"float32 a\n"
;
}
static const char* value(const ::std_msgs::ColorRGBA_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::ColorRGBA_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.r);
stream.next(m.g);
stream.next(m.b);
stream.next(m.a);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct ColorRGBA_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::ColorRGBA_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::ColorRGBA_<ContainerAllocator>& v)
{
s << indent << "r: ";
Printer<float>::stream(s, indent + " ", v.r);
s << indent << "g: ";
Printer<float>::stream(s, indent + " ", v.g);
s << indent << "b: ";
Printer<float>::stream(s, indent + " ", v.b);
s << indent << "a: ";
Printer<float>::stream(s, indent + " ", v.a);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_COLORRGBA_H

195
thirdparty/ros/include/std_msgs/Duration.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Duration.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_DURATION_H
#define STD_MSGS_MESSAGE_DURATION_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Duration_
{
typedef Duration_<ContainerAllocator> Type;
Duration_()
: data() {
}
Duration_(const ContainerAllocator& _alloc)
: data() {
(void)_alloc;
}
typedef ros::Duration _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Duration_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Duration_<ContainerAllocator> const> ConstPtr;
}; // struct Duration_
typedef ::std_msgs::Duration_<std::allocator<void> > Duration;
typedef boost::shared_ptr< ::std_msgs::Duration > DurationPtr;
typedef boost::shared_ptr< ::std_msgs::Duration const> DurationConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Duration_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Duration_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Duration_<ContainerAllocator1> & lhs, const ::std_msgs::Duration_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Duration_<ContainerAllocator1> & lhs, const ::std_msgs::Duration_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Duration_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Duration_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Duration_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Duration_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Duration_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Duration_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Duration_<ContainerAllocator> >
{
static const char* value()
{
return "3e286caf4241d664e55f3ad380e2ae46";
}
static const char* value(const ::std_msgs::Duration_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x3e286caf4241d664ULL;
static const uint64_t static_value2 = 0xe55f3ad380e2ae46ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Duration_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Duration";
}
static const char* value(const ::std_msgs::Duration_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Duration_<ContainerAllocator> >
{
static const char* value()
{
return "duration data\n"
;
}
static const char* value(const ::std_msgs::Duration_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Duration_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Duration_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Duration_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Duration_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<ros::Duration>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_DURATION_H

174
thirdparty/ros/include/std_msgs/Empty.h vendored Normal file
View File

@@ -0,0 +1,174 @@
// Generated by gencpp from file std_msgs/Empty.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_EMPTY_H
#define STD_MSGS_MESSAGE_EMPTY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Empty_
{
typedef Empty_<ContainerAllocator> Type;
Empty_()
{
}
Empty_(const ContainerAllocator& _alloc)
{
(void)_alloc;
}
typedef boost::shared_ptr< ::std_msgs::Empty_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Empty_<ContainerAllocator> const> ConstPtr;
}; // struct Empty_
typedef ::std_msgs::Empty_<std::allocator<void> > Empty;
typedef boost::shared_ptr< ::std_msgs::Empty > EmptyPtr;
typedef boost::shared_ptr< ::std_msgs::Empty const> EmptyConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Empty_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Empty_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Empty_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Empty_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Empty_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Empty_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Empty_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Empty_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Empty_<ContainerAllocator> >
{
static const char* value()
{
return "d41d8cd98f00b204e9800998ecf8427e";
}
static const char* value(const ::std_msgs::Empty_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xd41d8cd98f00b204ULL;
static const uint64_t static_value2 = 0xe9800998ecf8427eULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Empty_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Empty";
}
static const char* value(const ::std_msgs::Empty_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Empty_<ContainerAllocator> >
{
static const char* value()
{
return "\n"
;
}
static const char* value(const ::std_msgs::Empty_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Empty_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream&, T)
{}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Empty_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Empty_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream&, const std::string&, const ::std_msgs::Empty_<ContainerAllocator>&)
{}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_EMPTY_H

195
thirdparty/ros/include/std_msgs/Float32.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Float32.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_FLOAT32_H
#define STD_MSGS_MESSAGE_FLOAT32_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Float32_
{
typedef Float32_<ContainerAllocator> Type;
Float32_()
: data(0.0) {
}
Float32_(const ContainerAllocator& _alloc)
: data(0.0) {
(void)_alloc;
}
typedef float _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Float32_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Float32_<ContainerAllocator> const> ConstPtr;
}; // struct Float32_
typedef ::std_msgs::Float32_<std::allocator<void> > Float32;
typedef boost::shared_ptr< ::std_msgs::Float32 > Float32Ptr;
typedef boost::shared_ptr< ::std_msgs::Float32 const> Float32ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Float32_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Float32_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Float32_<ContainerAllocator1> & lhs, const ::std_msgs::Float32_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Float32_<ContainerAllocator1> & lhs, const ::std_msgs::Float32_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Float32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Float32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Float32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Float32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Float32_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Float32_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Float32_<ContainerAllocator> >
{
static const char* value()
{
return "73fcbf46b49191e672908e50842a83d4";
}
static const char* value(const ::std_msgs::Float32_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x73fcbf46b49191e6ULL;
static const uint64_t static_value2 = 0x72908e50842a83d4ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Float32_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Float32";
}
static const char* value(const ::std_msgs::Float32_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Float32_<ContainerAllocator> >
{
static const char* value()
{
return "float32 data\n"
;
}
static const char* value(const ::std_msgs::Float32_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Float32_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Float32_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Float32_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Float32_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<float>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_FLOAT32_H

250
thirdparty/ros/include/std_msgs/Float32MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/Float32MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H
#define STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Float32MultiArray_
{
typedef Float32MultiArray_<ContainerAllocator> Type;
Float32MultiArray_()
: layout()
, data() {
}
Float32MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<float, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<float>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Float32MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Float32MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct Float32MultiArray_
typedef ::std_msgs::Float32MultiArray_<std::allocator<void> > Float32MultiArray;
typedef boost::shared_ptr< ::std_msgs::Float32MultiArray > Float32MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::Float32MultiArray const> Float32MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Float32MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Float32MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Float32MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Float32MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Float32MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Float32MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Float32MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Float32MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Float32MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Float32MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Float32MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Float32MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Float32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "6a40e0ffa6a17a503ac3f8616991b1f6";
}
static const char* value(const ::std_msgs::Float32MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x6a40e0ffa6a17a50ULL;
static const uint64_t static_value2 = 0x3ac3f8616991b1f6ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Float32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Float32MultiArray";
}
static const char* value(const ::std_msgs::Float32MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Float32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"float32[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::Float32MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Float32MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Float32MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Float32MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Float32MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<float>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H

195
thirdparty/ros/include/std_msgs/Float64.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Float64.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_FLOAT64_H
#define STD_MSGS_MESSAGE_FLOAT64_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Float64_
{
typedef Float64_<ContainerAllocator> Type;
Float64_()
: data(0.0) {
}
Float64_(const ContainerAllocator& _alloc)
: data(0.0) {
(void)_alloc;
}
typedef double _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Float64_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Float64_<ContainerAllocator> const> ConstPtr;
}; // struct Float64_
typedef ::std_msgs::Float64_<std::allocator<void> > Float64;
typedef boost::shared_ptr< ::std_msgs::Float64 > Float64Ptr;
typedef boost::shared_ptr< ::std_msgs::Float64 const> Float64ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Float64_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Float64_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Float64_<ContainerAllocator1> & lhs, const ::std_msgs::Float64_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Float64_<ContainerAllocator1> & lhs, const ::std_msgs::Float64_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Float64_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Float64_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Float64_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Float64_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Float64_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Float64_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Float64_<ContainerAllocator> >
{
static const char* value()
{
return "fdb28210bfa9d7c91146260178d9a584";
}
static const char* value(const ::std_msgs::Float64_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xfdb28210bfa9d7c9ULL;
static const uint64_t static_value2 = 0x1146260178d9a584ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Float64_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Float64";
}
static const char* value(const ::std_msgs::Float64_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Float64_<ContainerAllocator> >
{
static const char* value()
{
return "float64 data\n"
;
}
static const char* value(const ::std_msgs::Float64_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Float64_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Float64_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Float64_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Float64_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<double>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_FLOAT64_H

250
thirdparty/ros/include/std_msgs/Float64MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/Float64MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H
#define STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Float64MultiArray_
{
typedef Float64MultiArray_<ContainerAllocator> Type;
Float64MultiArray_()
: layout()
, data() {
}
Float64MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<double, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<double>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Float64MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Float64MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct Float64MultiArray_
typedef ::std_msgs::Float64MultiArray_<std::allocator<void> > Float64MultiArray;
typedef boost::shared_ptr< ::std_msgs::Float64MultiArray > Float64MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::Float64MultiArray const> Float64MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Float64MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Float64MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Float64MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Float64MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Float64MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Float64MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Float64MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Float64MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Float64MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Float64MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Float64MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Float64MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Float64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "4b7d974086d4060e7db4613a7e6c3ba4";
}
static const char* value(const ::std_msgs::Float64MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x4b7d974086d4060eULL;
static const uint64_t static_value2 = 0x7db4613a7e6c3ba4ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Float64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Float64MultiArray";
}
static const char* value(const ::std_msgs::Float64MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Float64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"float64[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::Float64MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Float64MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Float64MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Float64MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Float64MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<double>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H

225
thirdparty/ros/include/std_msgs/Header.h vendored Normal file
View File

@@ -0,0 +1,225 @@
// Generated by gencpp from file std_msgs/Header.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_HEADER_H
#define STD_MSGS_MESSAGE_HEADER_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Header_
{
typedef Header_<ContainerAllocator> Type;
Header_()
: seq(0)
, stamp()
, frame_id() {
}
Header_(const ContainerAllocator& _alloc)
: seq(0)
, stamp()
, frame_id(_alloc) {
(void)_alloc;
}
typedef uint32_t _seq_type;
_seq_type seq;
typedef ros::Time _stamp_type;
_stamp_type stamp;
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _frame_id_type;
_frame_id_type frame_id;
typedef boost::shared_ptr< ::std_msgs::Header_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Header_<ContainerAllocator> const> ConstPtr;
}; // struct Header_
typedef ::std_msgs::Header_<std::allocator<void> > Header;
typedef boost::shared_ptr< ::std_msgs::Header > HeaderPtr;
typedef boost::shared_ptr< ::std_msgs::Header const> HeaderConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Header_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Header_<ContainerAllocator1> & lhs, const ::std_msgs::Header_<ContainerAllocator2> & rhs)
{
return lhs.seq == rhs.seq &&
lhs.stamp == rhs.stamp &&
lhs.frame_id == rhs.frame_id;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Header_<ContainerAllocator1> & lhs, const ::std_msgs::Header_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Header_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Header_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Header_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Header_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Header_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Header_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Header_<ContainerAllocator> >
{
static const char* value()
{
return "2176decaecbce78abc3b96ef049fabed";
}
static const char* value(const ::std_msgs::Header_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x2176decaecbce78aULL;
static const uint64_t static_value2 = 0xbc3b96ef049fabedULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Header_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Header";
}
static const char* value(const ::std_msgs::Header_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Header_<ContainerAllocator> >
{
static const char* value()
{
return "# 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"
;
}
static const char* value(const ::std_msgs::Header_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Header_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.seq);
stream.next(m.stamp);
stream.next(m.frame_id);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Header_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Header_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Header_<ContainerAllocator>& v)
{
s << indent << "seq: ";
Printer<uint32_t>::stream(s, indent + " ", v.seq);
s << indent << "stamp: ";
Printer<ros::Time>::stream(s, indent + " ", v.stamp);
s << indent << "frame_id: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.frame_id);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_HEADER_H

195
thirdparty/ros/include/std_msgs/Int16.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Int16.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_INT16_H
#define STD_MSGS_MESSAGE_INT16_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Int16_
{
typedef Int16_<ContainerAllocator> Type;
Int16_()
: data(0) {
}
Int16_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef int16_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Int16_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Int16_<ContainerAllocator> const> ConstPtr;
}; // struct Int16_
typedef ::std_msgs::Int16_<std::allocator<void> > Int16;
typedef boost::shared_ptr< ::std_msgs::Int16 > Int16Ptr;
typedef boost::shared_ptr< ::std_msgs::Int16 const> Int16ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int16_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Int16_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Int16_<ContainerAllocator1> & lhs, const ::std_msgs::Int16_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Int16_<ContainerAllocator1> & lhs, const ::std_msgs::Int16_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int16_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int16_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int16_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int16_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int16_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int16_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Int16_<ContainerAllocator> >
{
static const char* value()
{
return "8524586e34fbd7cb1c08c5f5f1ca0e57";
}
static const char* value(const ::std_msgs::Int16_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8524586e34fbd7cbULL;
static const uint64_t static_value2 = 0x1c08c5f5f1ca0e57ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Int16_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Int16";
}
static const char* value(const ::std_msgs::Int16_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Int16_<ContainerAllocator> >
{
static const char* value()
{
return "int16 data\n"
;
}
static const char* value(const ::std_msgs::Int16_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Int16_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Int16_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Int16_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int16_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<int16_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_INT16_H

250
thirdparty/ros/include/std_msgs/Int16MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/Int16MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_INT16MULTIARRAY_H
#define STD_MSGS_MESSAGE_INT16MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Int16MultiArray_
{
typedef Int16MultiArray_<ContainerAllocator> Type;
Int16MultiArray_()
: layout()
, data() {
}
Int16MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<int16_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int16_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Int16MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Int16MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct Int16MultiArray_
typedef ::std_msgs::Int16MultiArray_<std::allocator<void> > Int16MultiArray;
typedef boost::shared_ptr< ::std_msgs::Int16MultiArray > Int16MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::Int16MultiArray const> Int16MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int16MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Int16MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Int16MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Int16MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Int16MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Int16MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int16MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int16MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int16MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int16MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int16MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int16MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Int16MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "d9338d7f523fcb692fae9d0a0e9f067c";
}
static const char* value(const ::std_msgs::Int16MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xd9338d7f523fcb69ULL;
static const uint64_t static_value2 = 0x2fae9d0a0e9f067cULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Int16MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Int16MultiArray";
}
static const char* value(const ::std_msgs::Int16MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Int16MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"int16[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::Int16MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Int16MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Int16MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Int16MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int16MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<int16_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_INT16MULTIARRAY_H

195
thirdparty/ros/include/std_msgs/Int32.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Int32.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_INT32_H
#define STD_MSGS_MESSAGE_INT32_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Int32_
{
typedef Int32_<ContainerAllocator> Type;
Int32_()
: data(0) {
}
Int32_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef int32_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Int32_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Int32_<ContainerAllocator> const> ConstPtr;
}; // struct Int32_
typedef ::std_msgs::Int32_<std::allocator<void> > Int32;
typedef boost::shared_ptr< ::std_msgs::Int32 > Int32Ptr;
typedef boost::shared_ptr< ::std_msgs::Int32 const> Int32ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int32_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Int32_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Int32_<ContainerAllocator1> & lhs, const ::std_msgs::Int32_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Int32_<ContainerAllocator1> & lhs, const ::std_msgs::Int32_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int32_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int32_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Int32_<ContainerAllocator> >
{
static const char* value()
{
return "da5909fbe378aeaf85e547e830cc1bb7";
}
static const char* value(const ::std_msgs::Int32_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xda5909fbe378aeafULL;
static const uint64_t static_value2 = 0x85e547e830cc1bb7ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Int32_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Int32";
}
static const char* value(const ::std_msgs::Int32_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Int32_<ContainerAllocator> >
{
static const char* value()
{
return "int32 data\n"
;
}
static const char* value(const ::std_msgs::Int32_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Int32_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Int32_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Int32_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int32_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<int32_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_INT32_H

250
thirdparty/ros/include/std_msgs/Int32MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/Int32MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_INT32MULTIARRAY_H
#define STD_MSGS_MESSAGE_INT32MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Int32MultiArray_
{
typedef Int32MultiArray_<ContainerAllocator> Type;
Int32MultiArray_()
: layout()
, data() {
}
Int32MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<int32_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int32_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Int32MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Int32MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct Int32MultiArray_
typedef ::std_msgs::Int32MultiArray_<std::allocator<void> > Int32MultiArray;
typedef boost::shared_ptr< ::std_msgs::Int32MultiArray > Int32MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::Int32MultiArray const> Int32MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int32MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Int32MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Int32MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Int32MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Int32MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Int32MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int32MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int32MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int32MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int32MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int32MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int32MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Int32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "1d99f79f8b325b44fee908053e9c945b";
}
static const char* value(const ::std_msgs::Int32MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x1d99f79f8b325b44ULL;
static const uint64_t static_value2 = 0xfee908053e9c945bULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Int32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Int32MultiArray";
}
static const char* value(const ::std_msgs::Int32MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Int32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"int32[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::Int32MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Int32MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Int32MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Int32MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int32MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<int32_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_INT32MULTIARRAY_H

195
thirdparty/ros/include/std_msgs/Int64.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Int64.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_INT64_H
#define STD_MSGS_MESSAGE_INT64_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Int64_
{
typedef Int64_<ContainerAllocator> Type;
Int64_()
: data(0) {
}
Int64_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef int64_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Int64_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Int64_<ContainerAllocator> const> ConstPtr;
}; // struct Int64_
typedef ::std_msgs::Int64_<std::allocator<void> > Int64;
typedef boost::shared_ptr< ::std_msgs::Int64 > Int64Ptr;
typedef boost::shared_ptr< ::std_msgs::Int64 const> Int64ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int64_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Int64_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Int64_<ContainerAllocator1> & lhs, const ::std_msgs::Int64_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Int64_<ContainerAllocator1> & lhs, const ::std_msgs::Int64_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int64_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int64_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int64_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int64_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int64_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int64_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Int64_<ContainerAllocator> >
{
static const char* value()
{
return "34add168574510e6e17f5d23ecc077ef";
}
static const char* value(const ::std_msgs::Int64_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x34add168574510e6ULL;
static const uint64_t static_value2 = 0xe17f5d23ecc077efULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Int64_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Int64";
}
static const char* value(const ::std_msgs::Int64_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Int64_<ContainerAllocator> >
{
static const char* value()
{
return "int64 data\n"
;
}
static const char* value(const ::std_msgs::Int64_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Int64_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Int64_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Int64_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int64_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<int64_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_INT64_H

250
thirdparty/ros/include/std_msgs/Int64MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/Int64MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_INT64MULTIARRAY_H
#define STD_MSGS_MESSAGE_INT64MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Int64MultiArray_
{
typedef Int64MultiArray_<ContainerAllocator> Type;
Int64MultiArray_()
: layout()
, data() {
}
Int64MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<int64_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int64_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Int64MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Int64MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct Int64MultiArray_
typedef ::std_msgs::Int64MultiArray_<std::allocator<void> > Int64MultiArray;
typedef boost::shared_ptr< ::std_msgs::Int64MultiArray > Int64MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::Int64MultiArray const> Int64MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int64MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Int64MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Int64MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Int64MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Int64MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Int64MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int64MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int64MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int64MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int64MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int64MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int64MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Int64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "54865aa6c65be0448113a2afc6a49270";
}
static const char* value(const ::std_msgs::Int64MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x54865aa6c65be044ULL;
static const uint64_t static_value2 = 0x8113a2afc6a49270ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Int64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Int64MultiArray";
}
static const char* value(const ::std_msgs::Int64MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Int64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"int64[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::Int64MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Int64MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Int64MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Int64MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int64MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<int64_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_INT64MULTIARRAY_H

195
thirdparty/ros/include/std_msgs/Int8.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Int8.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_INT8_H
#define STD_MSGS_MESSAGE_INT8_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Int8_
{
typedef Int8_<ContainerAllocator> Type;
Int8_()
: data(0) {
}
Int8_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef int8_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Int8_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Int8_<ContainerAllocator> const> ConstPtr;
}; // struct Int8_
typedef ::std_msgs::Int8_<std::allocator<void> > Int8;
typedef boost::shared_ptr< ::std_msgs::Int8 > Int8Ptr;
typedef boost::shared_ptr< ::std_msgs::Int8 const> Int8ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int8_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Int8_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Int8_<ContainerAllocator1> & lhs, const ::std_msgs::Int8_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Int8_<ContainerAllocator1> & lhs, const ::std_msgs::Int8_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int8_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int8_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int8_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int8_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int8_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int8_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Int8_<ContainerAllocator> >
{
static const char* value()
{
return "27ffa0c9c4b8fb8492252bcad9e5c57b";
}
static const char* value(const ::std_msgs::Int8_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x27ffa0c9c4b8fb84ULL;
static const uint64_t static_value2 = 0x92252bcad9e5c57bULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Int8_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Int8";
}
static const char* value(const ::std_msgs::Int8_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Int8_<ContainerAllocator> >
{
static const char* value()
{
return "int8 data\n"
;
}
static const char* value(const ::std_msgs::Int8_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Int8_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Int8_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Int8_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int8_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<int8_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_INT8_H

250
thirdparty/ros/include/std_msgs/Int8MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/Int8MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_INT8MULTIARRAY_H
#define STD_MSGS_MESSAGE_INT8MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Int8MultiArray_
{
typedef Int8MultiArray_<ContainerAllocator> Type;
Int8MultiArray_()
: layout()
, data() {
}
Int8MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<int8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<int8_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Int8MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Int8MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct Int8MultiArray_
typedef ::std_msgs::Int8MultiArray_<std::allocator<void> > Int8MultiArray;
typedef boost::shared_ptr< ::std_msgs::Int8MultiArray > Int8MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::Int8MultiArray const> Int8MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Int8MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Int8MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Int8MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Int8MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Int8MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::Int8MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int8MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Int8MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int8MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Int8MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int8MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Int8MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Int8MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "d7c1af35a1b4781bbe79e03dd94b7c13";
}
static const char* value(const ::std_msgs::Int8MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xd7c1af35a1b4781bULL;
static const uint64_t static_value2 = 0xbe79e03dd94b7c13ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Int8MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Int8MultiArray";
}
static const char* value(const ::std_msgs::Int8MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Int8MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"int8[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::Int8MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Int8MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Int8MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Int8MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Int8MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<int8_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_INT8MULTIARRAY_H

215
thirdparty/ros/include/std_msgs/MultiArrayDimension.h vendored Normal file
View File

@@ -0,0 +1,215 @@
// Generated by gencpp from file std_msgs/MultiArrayDimension.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H
#define STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct MultiArrayDimension_
{
typedef MultiArrayDimension_<ContainerAllocator> Type;
MultiArrayDimension_()
: label()
, size(0)
, stride(0) {
}
MultiArrayDimension_(const ContainerAllocator& _alloc)
: label(_alloc)
, size(0)
, stride(0) {
(void)_alloc;
}
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _label_type;
_label_type label;
typedef uint32_t _size_type;
_size_type size;
typedef uint32_t _stride_type;
_stride_type stride;
typedef boost::shared_ptr< ::std_msgs::MultiArrayDimension_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::MultiArrayDimension_<ContainerAllocator> const> ConstPtr;
}; // struct MultiArrayDimension_
typedef ::std_msgs::MultiArrayDimension_<std::allocator<void> > MultiArrayDimension;
typedef boost::shared_ptr< ::std_msgs::MultiArrayDimension > MultiArrayDimensionPtr;
typedef boost::shared_ptr< ::std_msgs::MultiArrayDimension const> MultiArrayDimensionConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::MultiArrayDimension_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::MultiArrayDimension_<ContainerAllocator1> & lhs, const ::std_msgs::MultiArrayDimension_<ContainerAllocator2> & rhs)
{
return lhs.label == rhs.label &&
lhs.size == rhs.size &&
lhs.stride == rhs.stride;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::MultiArrayDimension_<ContainerAllocator1> & lhs, const ::std_msgs::MultiArrayDimension_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::MultiArrayDimension_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::MultiArrayDimension_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::MultiArrayDimension_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >
{
static const char* value()
{
return "4cd0c83a8683deae40ecdac60e53bfa8";
}
static const char* value(const ::std_msgs::MultiArrayDimension_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x4cd0c83a8683deaeULL;
static const uint64_t static_value2 = 0x40ecdac60e53bfa8ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/MultiArrayDimension";
}
static const char* value(const ::std_msgs::MultiArrayDimension_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >
{
static const char* value()
{
return "string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::MultiArrayDimension_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.label);
stream.next(m.size);
stream.next(m.stride);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct MultiArrayDimension_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::MultiArrayDimension_<ContainerAllocator>& v)
{
s << indent << "label: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.label);
s << indent << "size: ";
Printer<uint32_t>::stream(s, indent + " ", v.size);
s << indent << "stride: ";
Printer<uint32_t>::stream(s, indent + " ", v.stride);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H

242
thirdparty/ros/include/std_msgs/MultiArrayLayout.h vendored Normal file
View File

@@ -0,0 +1,242 @@
// Generated by gencpp from file std_msgs/MultiArrayLayout.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H
#define STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayDimension.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct MultiArrayLayout_
{
typedef MultiArrayLayout_<ContainerAllocator> Type;
MultiArrayLayout_()
: dim()
, data_offset(0) {
}
MultiArrayLayout_(const ContainerAllocator& _alloc)
: dim(_alloc)
, data_offset(0) {
(void)_alloc;
}
typedef std::vector< ::std_msgs::MultiArrayDimension_<ContainerAllocator> , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >> _dim_type;
_dim_type dim;
typedef uint32_t _data_offset_type;
_data_offset_type data_offset;
typedef boost::shared_ptr< ::std_msgs::MultiArrayLayout_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::MultiArrayLayout_<ContainerAllocator> const> ConstPtr;
}; // struct MultiArrayLayout_
typedef ::std_msgs::MultiArrayLayout_<std::allocator<void> > MultiArrayLayout;
typedef boost::shared_ptr< ::std_msgs::MultiArrayLayout > MultiArrayLayoutPtr;
typedef boost::shared_ptr< ::std_msgs::MultiArrayLayout const> MultiArrayLayoutConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::MultiArrayLayout_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::MultiArrayLayout_<ContainerAllocator1> & lhs, const ::std_msgs::MultiArrayLayout_<ContainerAllocator2> & rhs)
{
return lhs.dim == rhs.dim &&
lhs.data_offset == rhs.data_offset;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::MultiArrayLayout_<ContainerAllocator1> & lhs, const ::std_msgs::MultiArrayLayout_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::MultiArrayLayout_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::MultiArrayLayout_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::MultiArrayLayout_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >
{
static const char* value()
{
return "0fed2a11c13e11c5571b4e2a995a91a3";
}
static const char* value(const ::std_msgs::MultiArrayLayout_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x0fed2a11c13e11c5ULL;
static const uint64_t static_value2 = 0x571b4e2a995a91a3ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/MultiArrayLayout";
}
static const char* value(const ::std_msgs::MultiArrayLayout_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >
{
static const char* value()
{
return "# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::MultiArrayLayout_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.dim);
stream.next(m.data_offset);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct MultiArrayLayout_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::MultiArrayLayout_<ContainerAllocator>& v)
{
s << indent << "dim[]" << std::endl;
for (size_t i = 0; i < v.dim.size(); ++i)
{
s << indent << " dim[" << i << "]: ";
s << std::endl;
s << indent;
Printer< ::std_msgs::MultiArrayDimension_<ContainerAllocator> >::stream(s, indent + " ", v.dim[i]);
}
s << indent << "data_offset: ";
Printer<uint32_t>::stream(s, indent + " ", v.data_offset);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H

195
thirdparty/ros/include/std_msgs/String.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/String.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_STRING_H
#define STD_MSGS_MESSAGE_STRING_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct String_
{
typedef String_<ContainerAllocator> Type;
String_()
: data() {
}
String_(const ContainerAllocator& _alloc)
: data(_alloc) {
(void)_alloc;
}
typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::String_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::String_<ContainerAllocator> const> ConstPtr;
}; // struct String_
typedef ::std_msgs::String_<std::allocator<void> > String;
typedef boost::shared_ptr< ::std_msgs::String > StringPtr;
typedef boost::shared_ptr< ::std_msgs::String const> StringConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::String_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::String_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::String_<ContainerAllocator1> & lhs, const ::std_msgs::String_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::String_<ContainerAllocator1> & lhs, const ::std_msgs::String_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::String_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::String_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::String_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::String_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::String_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::String_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::String_<ContainerAllocator> >
{
static const char* value()
{
return "992ce8a1687cec8c8bd883ec73ca41d1";
}
static const char* value(const ::std_msgs::String_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x992ce8a1687cec8cULL;
static const uint64_t static_value2 = 0x8bd883ec73ca41d1ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::String_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/String";
}
static const char* value(const ::std_msgs::String_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::String_<ContainerAllocator> >
{
static const char* value()
{
return "string data\n"
;
}
static const char* value(const ::std_msgs::String_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::String_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct String_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::String_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::String_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>>>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_STRING_H

195
thirdparty/ros/include/std_msgs/Time.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/Time.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_TIME_H
#define STD_MSGS_MESSAGE_TIME_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct Time_
{
typedef Time_<ContainerAllocator> Type;
Time_()
: data() {
}
Time_(const ContainerAllocator& _alloc)
: data() {
(void)_alloc;
}
typedef ros::Time _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::Time_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::Time_<ContainerAllocator> const> ConstPtr;
}; // struct Time_
typedef ::std_msgs::Time_<std::allocator<void> > Time;
typedef boost::shared_ptr< ::std_msgs::Time > TimePtr;
typedef boost::shared_ptr< ::std_msgs::Time const> TimeConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::Time_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::Time_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::Time_<ContainerAllocator1> & lhs, const ::std_msgs::Time_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::Time_<ContainerAllocator1> & lhs, const ::std_msgs::Time_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Time_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::Time_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Time_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::Time_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Time_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::Time_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::Time_<ContainerAllocator> >
{
static const char* value()
{
return "cd7166c74c552c311fbcc2fe5a7bc289";
}
static const char* value(const ::std_msgs::Time_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xcd7166c74c552c31ULL;
static const uint64_t static_value2 = 0x1fbcc2fe5a7bc289ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::Time_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/Time";
}
static const char* value(const ::std_msgs::Time_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::Time_<ContainerAllocator> >
{
static const char* value()
{
return "time data\n"
;
}
static const char* value(const ::std_msgs::Time_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::Time_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct Time_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::Time_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::Time_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<ros::Time>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_TIME_H

195
thirdparty/ros/include/std_msgs/UInt16.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/UInt16.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_UINT16_H
#define STD_MSGS_MESSAGE_UINT16_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct UInt16_
{
typedef UInt16_<ContainerAllocator> Type;
UInt16_()
: data(0) {
}
UInt16_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef uint16_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::UInt16_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt16_<ContainerAllocator> const> ConstPtr;
}; // struct UInt16_
typedef ::std_msgs::UInt16_<std::allocator<void> > UInt16;
typedef boost::shared_ptr< ::std_msgs::UInt16 > UInt16Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt16 const> UInt16ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt16_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::UInt16_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::UInt16_<ContainerAllocator1> & lhs, const ::std_msgs::UInt16_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::UInt16_<ContainerAllocator1> & lhs, const ::std_msgs::UInt16_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt16_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt16_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt16_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt16_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt16_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt16_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::UInt16_<ContainerAllocator> >
{
static const char* value()
{
return "1df79edf208b629fe6b81923a544552d";
}
static const char* value(const ::std_msgs::UInt16_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x1df79edf208b629fULL;
static const uint64_t static_value2 = 0xe6b81923a544552dULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::UInt16_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/UInt16";
}
static const char* value(const ::std_msgs::UInt16_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::UInt16_<ContainerAllocator> >
{
static const char* value()
{
return "uint16 data\n"
;
}
static const char* value(const ::std_msgs::UInt16_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::UInt16_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct UInt16_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::UInt16_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt16_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<uint16_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_UINT16_H

250
thirdparty/ros/include/std_msgs/UInt16MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/UInt16MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_UINT16MULTIARRAY_H
#define STD_MSGS_MESSAGE_UINT16MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct UInt16MultiArray_
{
typedef UInt16MultiArray_<ContainerAllocator> Type;
UInt16MultiArray_()
: layout()
, data() {
}
UInt16MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<uint16_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint16_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::UInt16MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt16MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct UInt16MultiArray_
typedef ::std_msgs::UInt16MultiArray_<std::allocator<void> > UInt16MultiArray;
typedef boost::shared_ptr< ::std_msgs::UInt16MultiArray > UInt16MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::UInt16MultiArray const> UInt16MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt16MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::UInt16MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::UInt16MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::UInt16MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::UInt16MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt16MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt16MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt16MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "52f264f1c973c4b73790d384c6cb4484";
}
static const char* value(const ::std_msgs::UInt16MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x52f264f1c973c4b7ULL;
static const uint64_t static_value2 = 0x3790d384c6cb4484ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/UInt16MultiArray";
}
static const char* value(const ::std_msgs::UInt16MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"uint16[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::UInt16MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct UInt16MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::UInt16MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt16MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<uint16_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_UINT16MULTIARRAY_H

195
thirdparty/ros/include/std_msgs/UInt32.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/UInt32.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_UINT32_H
#define STD_MSGS_MESSAGE_UINT32_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct UInt32_
{
typedef UInt32_<ContainerAllocator> Type;
UInt32_()
: data(0) {
}
UInt32_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef uint32_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::UInt32_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt32_<ContainerAllocator> const> ConstPtr;
}; // struct UInt32_
typedef ::std_msgs::UInt32_<std::allocator<void> > UInt32;
typedef boost::shared_ptr< ::std_msgs::UInt32 > UInt32Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt32 const> UInt32ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt32_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::UInt32_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::UInt32_<ContainerAllocator1> & lhs, const ::std_msgs::UInt32_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::UInt32_<ContainerAllocator1> & lhs, const ::std_msgs::UInt32_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt32_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt32_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt32_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt32_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::UInt32_<ContainerAllocator> >
{
static const char* value()
{
return "304a39449588c7f8ce2df6e8001c5fce";
}
static const char* value(const ::std_msgs::UInt32_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x304a39449588c7f8ULL;
static const uint64_t static_value2 = 0xce2df6e8001c5fceULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::UInt32_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/UInt32";
}
static const char* value(const ::std_msgs::UInt32_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::UInt32_<ContainerAllocator> >
{
static const char* value()
{
return "uint32 data\n"
;
}
static const char* value(const ::std_msgs::UInt32_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::UInt32_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct UInt32_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::UInt32_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt32_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<uint32_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_UINT32_H

250
thirdparty/ros/include/std_msgs/UInt32MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/UInt32MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_UINT32MULTIARRAY_H
#define STD_MSGS_MESSAGE_UINT32MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct UInt32MultiArray_
{
typedef UInt32MultiArray_<ContainerAllocator> Type;
UInt32MultiArray_()
: layout()
, data() {
}
UInt32MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<uint32_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint32_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::UInt32MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt32MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct UInt32MultiArray_
typedef ::std_msgs::UInt32MultiArray_<std::allocator<void> > UInt32MultiArray;
typedef boost::shared_ptr< ::std_msgs::UInt32MultiArray > UInt32MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::UInt32MultiArray const> UInt32MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt32MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::UInt32MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::UInt32MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::UInt32MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::UInt32MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt32MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt32MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt32MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "4d6a180abc9be191b96a7eda6c8a233d";
}
static const char* value(const ::std_msgs::UInt32MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x4d6a180abc9be191ULL;
static const uint64_t static_value2 = 0xb96a7eda6c8a233dULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/UInt32MultiArray";
}
static const char* value(const ::std_msgs::UInt32MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"uint32[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::UInt32MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct UInt32MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::UInt32MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt32MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<uint32_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_UINT32MULTIARRAY_H

195
thirdparty/ros/include/std_msgs/UInt64.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/UInt64.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_UINT64_H
#define STD_MSGS_MESSAGE_UINT64_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct UInt64_
{
typedef UInt64_<ContainerAllocator> Type;
UInt64_()
: data(0) {
}
UInt64_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef uint64_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::UInt64_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt64_<ContainerAllocator> const> ConstPtr;
}; // struct UInt64_
typedef ::std_msgs::UInt64_<std::allocator<void> > UInt64;
typedef boost::shared_ptr< ::std_msgs::UInt64 > UInt64Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt64 const> UInt64ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt64_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::UInt64_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::UInt64_<ContainerAllocator1> & lhs, const ::std_msgs::UInt64_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::UInt64_<ContainerAllocator1> & lhs, const ::std_msgs::UInt64_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt64_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt64_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt64_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt64_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt64_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt64_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::UInt64_<ContainerAllocator> >
{
static const char* value()
{
return "1b2a79973e8bf53d7b53acb71299cb57";
}
static const char* value(const ::std_msgs::UInt64_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x1b2a79973e8bf53dULL;
static const uint64_t static_value2 = 0x7b53acb71299cb57ULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::UInt64_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/UInt64";
}
static const char* value(const ::std_msgs::UInt64_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::UInt64_<ContainerAllocator> >
{
static const char* value()
{
return "uint64 data\n"
;
}
static const char* value(const ::std_msgs::UInt64_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::UInt64_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct UInt64_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::UInt64_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt64_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<uint64_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_UINT64_H

250
thirdparty/ros/include/std_msgs/UInt64MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/UInt64MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_UINT64MULTIARRAY_H
#define STD_MSGS_MESSAGE_UINT64MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct UInt64MultiArray_
{
typedef UInt64MultiArray_<ContainerAllocator> Type;
UInt64MultiArray_()
: layout()
, data() {
}
UInt64MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<uint64_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint64_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::UInt64MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt64MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct UInt64MultiArray_
typedef ::std_msgs::UInt64MultiArray_<std::allocator<void> > UInt64MultiArray;
typedef boost::shared_ptr< ::std_msgs::UInt64MultiArray > UInt64MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::UInt64MultiArray const> UInt64MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt64MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::UInt64MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::UInt64MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::UInt64MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::UInt64MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt64MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt64MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt64MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "6088f127afb1d6c72927aa1247e945af";
}
static const char* value(const ::std_msgs::UInt64MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x6088f127afb1d6c7ULL;
static const uint64_t static_value2 = 0x2927aa1247e945afULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/UInt64MultiArray";
}
static const char* value(const ::std_msgs::UInt64MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"uint64[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::UInt64MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct UInt64MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::UInt64MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt64MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<uint64_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_UINT64MULTIARRAY_H

195
thirdparty/ros/include/std_msgs/UInt8.h vendored Normal file
View File

@@ -0,0 +1,195 @@
// Generated by gencpp from file std_msgs/UInt8.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_UINT8_H
#define STD_MSGS_MESSAGE_UINT8_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct UInt8_
{
typedef UInt8_<ContainerAllocator> Type;
UInt8_()
: data(0) {
}
UInt8_(const ContainerAllocator& _alloc)
: data(0) {
(void)_alloc;
}
typedef uint8_t _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::UInt8_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt8_<ContainerAllocator> const> ConstPtr;
}; // struct UInt8_
typedef ::std_msgs::UInt8_<std::allocator<void> > UInt8;
typedef boost::shared_ptr< ::std_msgs::UInt8 > UInt8Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt8 const> UInt8ConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt8_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::UInt8_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::UInt8_<ContainerAllocator1> & lhs, const ::std_msgs::UInt8_<ContainerAllocator2> & rhs)
{
return lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::UInt8_<ContainerAllocator1> & lhs, const ::std_msgs::UInt8_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt8_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt8_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt8_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt8_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt8_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt8_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::UInt8_<ContainerAllocator> >
{
static const char* value()
{
return "7c8164229e7d2c17eb95e9231617fdee";
}
static const char* value(const ::std_msgs::UInt8_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x7c8164229e7d2c17ULL;
static const uint64_t static_value2 = 0xeb95e9231617fdeeULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::UInt8_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/UInt8";
}
static const char* value(const ::std_msgs::UInt8_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::UInt8_<ContainerAllocator> >
{
static const char* value()
{
return "uint8 data\n"
;
}
static const char* value(const ::std_msgs::UInt8_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::UInt8_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct UInt8_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::UInt8_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt8_<ContainerAllocator>& v)
{
s << indent << "data: ";
Printer<uint8_t>::stream(s, indent + " ", v.data);
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_UINT8_H

250
thirdparty/ros/include/std_msgs/UInt8MultiArray.h vendored Normal file
View File

@@ -0,0 +1,250 @@
// Generated by gencpp from file std_msgs/UInt8MultiArray.msg
// DO NOT EDIT!
#ifndef STD_MSGS_MESSAGE_UINT8MULTIARRAY_H
#define STD_MSGS_MESSAGE_UINT8MULTIARRAY_H
#include <string>
#include <vector>
#include <memory>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/MultiArrayLayout.h>
namespace std_msgs
{
template <class ContainerAllocator>
struct UInt8MultiArray_
{
typedef UInt8MultiArray_<ContainerAllocator> Type;
UInt8MultiArray_()
: layout()
, data() {
}
UInt8MultiArray_(const ContainerAllocator& _alloc)
: layout(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::MultiArrayLayout_<ContainerAllocator> _layout_type;
_layout_type layout;
typedef std::vector<uint8_t, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<uint8_t>> _data_type;
_data_type data;
typedef boost::shared_ptr< ::std_msgs::UInt8MultiArray_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::std_msgs::UInt8MultiArray_<ContainerAllocator> const> ConstPtr;
}; // struct UInt8MultiArray_
typedef ::std_msgs::UInt8MultiArray_<std::allocator<void> > UInt8MultiArray;
typedef boost::shared_ptr< ::std_msgs::UInt8MultiArray > UInt8MultiArrayPtr;
typedef boost::shared_ptr< ::std_msgs::UInt8MultiArray const> UInt8MultiArrayConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::std_msgs::UInt8MultiArray_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >::stream(s, "", v);
return s;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator==(const ::std_msgs::UInt8MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::UInt8MultiArray_<ContainerAllocator2> & rhs)
{
return lhs.layout == rhs.layout &&
lhs.data == rhs.data;
}
template<typename ContainerAllocator1, typename ContainerAllocator2>
bool operator!=(const ::std_msgs::UInt8MultiArray_<ContainerAllocator1> & lhs, const ::std_msgs::UInt8MultiArray_<ContainerAllocator2> & rhs)
{
return !(lhs == rhs);
}
} // namespace std_msgs
namespace ros
{
namespace message_traits
{
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::std_msgs::UInt8MultiArray_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::std_msgs::UInt8MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct HasHeader< ::std_msgs::UInt8MultiArray_<ContainerAllocator> const>
: FalseType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "82373f1612381bb6ee473b5cd6f5d89c";
}
static const char* value(const ::std_msgs::UInt8MultiArray_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x82373f1612381bb6ULL;
static const uint64_t static_value2 = 0xee473b5cd6f5d89cULL;
};
template<class ContainerAllocator>
struct DataType< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "std_msgs/UInt8MultiArray";
}
static const char* value(const ::std_msgs::UInt8MultiArray_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >
{
static const char* value()
{
return "# Please look at the MultiArrayLayout message definition for\n"
"# documentation on all multiarrays.\n"
"\n"
"MultiArrayLayout layout # specification of data layout\n"
"uint8[] data # array of data\n"
"\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayLayout\n"
"# The multiarray declares a generic multi-dimensional array of a\n"
"# particular data type. Dimensions are ordered from outer most\n"
"# to inner most.\n"
"\n"
"MultiArrayDimension[] dim # Array of dimension properties\n"
"uint32 data_offset # padding elements at front of data\n"
"\n"
"# Accessors should ALWAYS be written in terms of dimension stride\n"
"# and specified outer-most dimension first.\n"
"# \n"
"# multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n"
"#\n"
"# A standard, 3-channel 640x480 image with interleaved color channels\n"
"# would be specified as:\n"
"#\n"
"# dim[0].label = \"height\"\n"
"# dim[0].size = 480\n"
"# dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n"
"# dim[1].label = \"width\"\n"
"# dim[1].size = 640\n"
"# dim[1].stride = 3*640 = 1920\n"
"# dim[2].label = \"channel\"\n"
"# dim[2].size = 3\n"
"# dim[2].stride = 3\n"
"#\n"
"# multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n"
"\n"
"================================================================================\n"
"MSG: std_msgs/MultiArrayDimension\n"
"string label # label of given dimension\n"
"uint32 size # size of given dimension (in type units)\n"
"uint32 stride # stride of given dimension\n"
;
}
static const char* value(const ::std_msgs::UInt8MultiArray_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.layout);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct UInt8MultiArray_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::std_msgs::UInt8MultiArray_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::std_msgs::UInt8MultiArray_<ContainerAllocator>& v)
{
s << indent << "layout: ";
s << std::endl;
Printer< ::std_msgs::MultiArrayLayout_<ContainerAllocator> >::stream(s, indent + " ", v.layout);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<uint8_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // STD_MSGS_MESSAGE_UINT8MULTIARRAY_H

36
thirdparty/ros/include/std_msgs/builtin_bool.h vendored Normal file
View File

@@ -0,0 +1,36 @@
/*
* Copyright (C) 2009, Willow Garage, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the names of Willow Garage, Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef STD_MSGS_BUILTIN_BOOL_H
#define STD_MSGS_BUILTIN_BOOL_H
#include "trait_macros.h"
#include <std_msgs/Bool.h>
STD_MSGS_DEFINE_BUILTIN_TRAITS(bool, Bool, 0x8b94c1b53db61fb6ULL, 0xaed406028ad6332aULL)
#endif

Some files were not shown because too many files have changed in this diff Show More