update

geometry_msgs/include/robot_geometry_msgs/Accel.h

@@ -0,0 +1,209 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+#include <robot_geometry_msgs/Vector3.h>
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_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  ::robot_geometry_msgs::Vector3_<ContainerAllocator>  _linear_type;
+  _linear_type linear;
+
+   typedef  ::robot_geometry_msgs::Vector3_<ContainerAllocator>  _angular_type;
+  _angular_type angular;
+
+
+
+
+
+  typedef boost::shared_ptr< ::robot_geometry_msgs::Accel_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_geometry_msgs::Accel_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Accel_
+
+typedef ::robot_geometry_msgs::Accel_<std::allocator<void> > Accel;
+
+typedef boost::shared_ptr< ::robot_geometry_msgs::Accel > AccelPtr;
+typedef boost::shared_ptr< ::robot_geometry_msgs::Accel const> AccelConstPtr;
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::robot_geometry_msgs::Accel_<ContainerAllocator2> & rhs)
+{
+  return lhs.linear == rhs.linear &&
+    lhs.angular == rhs.angular;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_geometry_msgs::Accel_<ContainerAllocator1> & lhs, const ::robot_geometry_msgs::Accel_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace robot_geometry_msgs
+
+namespace ros
+{
+namespace message_traits
+{
+
+
+
+
+
+template <class ContainerAllocator>
+struct IsMessage< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsMessage< ::robot_geometry_msgs::Accel_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct IsFixedSize< ::robot_geometry_msgs::Accel_<ContainerAllocator> const>
+  : TrueType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+  : FalseType
+  { };
+
+template <class ContainerAllocator>
+struct HasHeader< ::robot_geometry_msgs::Accel_<ContainerAllocator> const>
+  : FalseType
+  { };
+
+
+template<class ContainerAllocator>
+struct MD5Sum< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "9f195f881246fdfa2798d1d3eebca84a";
+  }
+
+  static const char* value(const ::robot_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< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+{
+  static const char* value()
+  {
+    return "robot_geometry_msgs/Accel";
+  }
+
+  static const char* value(const ::robot_geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
+};
+
+template<class ContainerAllocator>
+struct Definition< ::robot_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: robot_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"
+"# robot_geometry_msgs/Point message instead.\n"
+"\n"
+"float64 x\n"
+"float64 y\n"
+"float64 z\n"
+;
+  }
+
+  static const char* value(const ::robot_geometry_msgs::Accel_<ContainerAllocator>&) { return value(); }
+};
+
+} // namespace message_traits
+} // namespace ros
+
+namespace ros
+{
+namespace serialization
+{
+
+  template<class ContainerAllocator> struct Serializer< ::robot_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< ::robot_geometry_msgs::Accel_<ContainerAllocator> >
+{
+  template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::robot_geometry_msgs::Accel_<ContainerAllocator>& v)
+  {
+    if (false || !indent.empty())
+      s << std::endl;
+    s << indent << "linear: ";
+    Printer< ::robot_geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.linear);
+    if (true || !indent.empty())
+      s << std::endl;
+    s << indent << "angular: ";
+    Printer< ::robot_geometry_msgs::Vector3_<ContainerAllocator> >::stream(s, indent + "  ", v.angular);
+  }
+};
+
+} // namespace message_operations
+} // namespace ros
+
+#endif // GEOMETRY_MSGS_MESSAGE_ACCEL_H

geometry_msgs/include/robot_geometry_msgs/AccelStamped.h

@@ -0,0 +1,61 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Accel.h>
+
+namespace robot_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 ::robot_geometry_msgs::Accel_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelStamped_
+
+  typedef ::robot_geometry_msgs::AccelStamped_<std::allocator<void>> AccelStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelStamped> AccelStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelStamped const> AccelStampedConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::AccelStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.accel == rhs.accel;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::AccelStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_ACCELSTAMPED_H

geometry_msgs/include/robot_geometry_msgs/AccelWithCovariance.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+#include <boost/array.hpp>
+#include <robot_geometry_msgs/Accel.h>
+
+namespace robot_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 ::robot_geometry_msgs::Accel_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelWithCovariance_
+
+  typedef ::robot_geometry_msgs::AccelWithCovariance_<std::allocator<void>> AccelWithCovariance;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovariance> AccelWithCovariancePtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovariance const> AccelWithCovarianceConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return lhs.accel == rhs.accel &&
+           lhs.covariance == rhs.covariance;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCE_H

geometry_msgs/include/robot_geometry_msgs/AccelWithCovarianceStamped.h

@@ -0,0 +1,64 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/AccelWithCovariance.h>
+
+namespace robot_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 ::robot_geometry_msgs::AccelWithCovariance_<ContainerAllocator> _accel_type;
+    _accel_type accel;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct AccelWithCovarianceStamped_
+
+  typedef ::robot_geometry_msgs::AccelWithCovarianceStamped_<std::allocator<void>> AccelWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovarianceStamped> AccelWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::AccelWithCovarianceStamped const> AccelWithCovarianceStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.accel == rhs.accel;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::AccelWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_ACCELWITHCOVARIANCESTAMPED_H

geometry_msgs/include/robot_geometry_msgs/Inertia.h

@@ -0,0 +1,88 @@
+// Generated by gencpp from file robot_geometry_msgs/Inertia.msg
+// DO NOT EDIT!
+
+#ifndef GEOMETRY_MSGS_MESSAGE_INERTIA_H
+#define GEOMETRY_MSGS_MESSAGE_INERTIA_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_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 ::robot_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<::robot_geometry_msgs::Inertia_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Inertia_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Inertia_
+
+  typedef ::robot_geometry_msgs::Inertia_<std::allocator<void>> Inertia;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Inertia> InertiaPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Inertia const> InertiaConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Inertia_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_geometry_msgs::Inertia_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Inertia_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_INERTIA_H

geometry_msgs/include/robot_geometry_msgs/InertiaStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Inertia.h>
+
+namespace robot_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 ::robot_geometry_msgs::Inertia_<ContainerAllocator> _inertia_type;
+    _inertia_type inertia;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::InertiaStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::InertiaStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct InertiaStamped_
+
+  typedef ::robot_geometry_msgs::InertiaStamped_<std::allocator<void>> InertiaStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::InertiaStamped> InertiaStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::InertiaStamped const> InertiaStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::InertiaStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::InertiaStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.inertia == rhs.inertia;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::InertiaStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::InertiaStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_INERTIASTAMPED_H

geometry_msgs/include/robot_geometry_msgs/Point.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+namespace robot_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<::robot_geometry_msgs::Point_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Point_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Point_
+
+  typedef ::robot_geometry_msgs::Point_<std::allocator<void>> Point;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Point> PointPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Point const> PointConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Point_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_geometry_msgs::Point_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Point_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_POINT_H

geometry_msgs/include/robot_geometry_msgs/Point32.h

@@ -0,0 +1,66 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+namespace robot_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<::robot_geometry_msgs::Point32_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Point32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Point32_
+
+  typedef ::robot_geometry_msgs::Point32_<std::allocator<void>> Point32;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Point32> Point32Ptr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Point32 const> Point32ConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Point32_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_geometry_msgs::Point32_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Point32_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_POINT32_H

geometry_msgs/include/robot_geometry_msgs/PointStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/PointStamped.msg
+// DO NOT EDIT!
+
+#ifndef GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Point.h>
+
+namespace robot_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 ::robot_geometry_msgs::Point_<ContainerAllocator> _point_type;
+    _point_type point;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PointStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PointStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PointStamped_
+
+  typedef ::robot_geometry_msgs::PointStamped_<std::allocator<void>> PointStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PointStamped> PointStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PointStamped const> PointStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PointStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PointStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.point == rhs.point;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PointStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PointStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_POINTSTAMPED_H

geometry_msgs/include/robot_geometry_msgs/Polygon.h

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

geometry_msgs/include/robot_geometry_msgs/PolygonStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/PolygonStamped.msg
+// DO NOT EDIT!
+
+#ifndef GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Polygon.h>
+
+namespace robot_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 ::robot_geometry_msgs::Polygon_<ContainerAllocator> _polygon_type;
+    _polygon_type polygon;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PolygonStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PolygonStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PolygonStamped_
+
+  typedef ::robot_geometry_msgs::PolygonStamped_<std::allocator<void>> PolygonStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PolygonStamped> PolygonStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PolygonStamped const> PolygonStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PolygonStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PolygonStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.polygon == rhs.polygon;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PolygonStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PolygonStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_POLYGONSTAMPED_H

geometry_msgs/include/robot_geometry_msgs/Pose.h

@@ -0,0 +1,64 @@
+// Generated by gencpp from file robot_geometry_msgs/Pose.msg
+// DO NOT EDIT!
+
+#ifndef GEOMETRY_MSGS_MESSAGE_POSE_H
+#define GEOMETRY_MSGS_MESSAGE_POSE_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Point.h>
+#include <robot_geometry_msgs/Quaternion.h>
+
+namespace robot_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 ::robot_geometry_msgs::Point_<ContainerAllocator> _position_type;
+    _position_type position;
+
+    typedef ::robot_geometry_msgs::Quaternion_<ContainerAllocator> _orientation_type;
+    _orientation_type orientation;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Pose_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Pose_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Pose_
+
+  typedef ::robot_geometry_msgs::Pose_<std::allocator<void>> Pose;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Pose> PosePtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Pose const> PoseConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Pose_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Pose_<ContainerAllocator2> &rhs)
+  {
+    return lhs.position == rhs.position &&
+           lhs.orientation == rhs.orientation;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Pose_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Pose_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_POSE_H

geometry_msgs/include/robot_geometry_msgs/Pose2D.h

@@ -0,0 +1,66 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+namespace robot_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<::robot_geometry_msgs::Pose2D_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Pose2D_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Pose2D_
+
+  typedef ::robot_geometry_msgs::Pose2D_<std::allocator<void>> Pose2D;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Pose2D> Pose2DPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Pose2D const> Pose2DConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Pose2D_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_geometry_msgs::Pose2D_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Pose2D_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_POSE2D_H

geometry_msgs/include/robot_geometry_msgs/PoseArray.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Pose.h>
+
+namespace robot_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<::robot_geometry_msgs::Pose_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::robot_geometry_msgs::Pose_<ContainerAllocator>>> _poses_type;
+    _poses_type poses;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseArray_
+
+  typedef ::robot_geometry_msgs::PoseArray_<std::allocator<void>> PoseArray;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseArray> PoseArrayPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseArray const> PoseArrayConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PoseArray_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.poses == rhs.poses;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PoseArray_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_POSEARRAY_H

geometry_msgs/include/robot_geometry_msgs/PoseStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_geometry_msgs/PoseStamped.msg
+// DO NOT EDIT!
+
+#ifndef GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H
+#define GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Pose.h>
+
+namespace robot_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 ::robot_geometry_msgs::Pose_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseStamped_
+
+  typedef ::robot_geometry_msgs::PoseStamped_<std::allocator<void>> PoseStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseStamped> PoseStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseStamped const> PoseStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PoseStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.pose == rhs.pose;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PoseStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_POSESTAMPED_H

geometry_msgs/include/robot_geometry_msgs/PoseWithCovariance.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+#include <boost/array.hpp>
+#include <robot_geometry_msgs/Pose.h>
+
+namespace robot_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 ::robot_geometry_msgs::Pose_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseWithCovariance_
+
+  typedef ::robot_geometry_msgs::PoseWithCovariance_<std::allocator<void>> PoseWithCovariance;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovariance> PoseWithCovariancePtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovariance const> PoseWithCovarianceConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return lhs.pose == rhs.pose &&
+           lhs.covariance == rhs.covariance;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCE_H

geometry_msgs/include/robot_geometry_msgs/PoseWithCovarianceStamped.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/PoseWithCovariance.h>
+
+namespace robot_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 ::robot_geometry_msgs::PoseWithCovariance_<ContainerAllocator> _pose_type;
+    _pose_type pose;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct PoseWithCovarianceStamped_
+
+  typedef ::robot_geometry_msgs::PoseWithCovarianceStamped_<std::allocator<void>> PoseWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovarianceStamped> PoseWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::PoseWithCovarianceStamped const> PoseWithCovarianceStampedConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.pose == rhs.pose;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::PoseWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_POSEWITHCOVARIANCESTAMPED_H

geometry_msgs/include/robot_geometry_msgs/Quaternion.h

@@ -0,0 +1,69 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+namespace robot_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<::robot_geometry_msgs::Quaternion_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Quaternion_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Quaternion_
+
+  typedef ::robot_geometry_msgs::Quaternion_<std::allocator<void>> Quaternion;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Quaternion> QuaternionPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Quaternion const> QuaternionConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Quaternion_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_geometry_msgs::Quaternion_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Quaternion_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_QUATERNION_H

geometry_msgs/include/robot_geometry_msgs/QuaternionStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Quaternion.h>
+
+namespace robot_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 ::robot_geometry_msgs::Quaternion_<ContainerAllocator> _quaternion_type;
+    _quaternion_type quaternion;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct QuaternionStamped_
+
+  typedef ::robot_geometry_msgs::QuaternionStamped_<std::allocator<void>> QuaternionStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::QuaternionStamped> QuaternionStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::QuaternionStamped const> QuaternionStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.quaternion == rhs.quaternion;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::QuaternionStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_QUATERNIONSTAMPED_H

geometry_msgs/include/robot_geometry_msgs/Transform.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Vector3.h>
+#include <robot_geometry_msgs/Quaternion.h>
+
+namespace robot_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 ::robot_geometry_msgs::Vector3_<ContainerAllocator> _translation_type;
+    _translation_type translation;
+
+    typedef ::robot_geometry_msgs::Quaternion_<ContainerAllocator> _rotation_type;
+    _rotation_type rotation;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Transform_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Transform_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Transform_
+
+  typedef ::robot_geometry_msgs::Transform_<std::allocator<void>> Transform;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Transform> TransformPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Transform const> TransformConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Transform_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Transform_<ContainerAllocator2> &rhs)
+  {
+    return lhs.translation == rhs.translation &&
+           lhs.rotation == rhs.rotation;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Transform_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Transform_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORM_H

geometry_msgs/include/robot_geometry_msgs/TransformStamped.h

@@ -0,0 +1,69 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Transform.h>
+
+namespace robot_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 ::robot_geometry_msgs::Transform_<ContainerAllocator> _transform_type;
+    _transform_type transform;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::TransformStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::TransformStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TransformStamped_
+
+  typedef ::robot_geometry_msgs::TransformStamped_<std::allocator<void>> TransformStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::TransformStamped> TransformStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::TransformStamped const> TransformStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::TransformStamped_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_geometry_msgs::TransformStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TransformStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_TRANSFORMSTAMPED_H

geometry_msgs/include/robot_geometry_msgs/Twist.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Vector3.h>
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_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 ::robot_geometry_msgs::Vector3_<ContainerAllocator> _linear_type;
+    _linear_type linear;
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _angular_type;
+    _angular_type angular;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Twist_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Twist_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Twist_
+
+  typedef ::robot_geometry_msgs::Twist_<std::allocator<void>> Twist;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Twist> TwistPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Twist const> TwistConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Twist_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Twist_<ContainerAllocator2> &rhs)
+  {
+    return lhs.linear == rhs.linear &&
+           lhs.angular == rhs.angular;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Twist_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Twist_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_TWIST_H

geometry_msgs/include/robot_geometry_msgs/TwistStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Twist.h>
+
+namespace robot_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 ::robot_geometry_msgs::Twist_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistStamped_
+
+  typedef ::robot_geometry_msgs::TwistStamped_<std::allocator<void>> TwistStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistStamped> TwistStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistStamped const> TwistStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::TwistStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.twist == rhs.twist;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::TwistStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_TWISTSTAMPED_H

geometry_msgs/include/robot_geometry_msgs/TwistWithCovariance.h

@@ -0,0 +1,66 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+#include <boost/array.hpp>
+#include <robot_geometry_msgs/Twist.h>
+
+namespace robot_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 ::robot_geometry_msgs::Twist_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::array<double, 36> _covariance_type;
+    _covariance_type covariance;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistWithCovariance_
+
+  typedef ::robot_geometry_msgs::TwistWithCovariance_<std::allocator<void>> TwistWithCovariance;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovariance> TwistWithCovariancePtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovariance const> TwistWithCovarianceConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return lhs.twist == rhs.twist &&
+           lhs.covariance == rhs.covariance;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCE_H

geometry_msgs/include/robot_geometry_msgs/TwistWithCovarianceStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/TwistWithCovariance.h>
+
+namespace robot_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 ::robot_geometry_msgs::TwistWithCovariance_<ContainerAllocator> _twist_type;
+    _twist_type twist;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct TwistWithCovarianceStamped_
+
+  typedef ::robot_geometry_msgs::TwistWithCovarianceStamped_<std::allocator<void>> TwistWithCovarianceStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovarianceStamped> TwistWithCovarianceStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::TwistWithCovarianceStamped const> TwistWithCovarianceStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.twist == rhs.twist;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::TwistWithCovarianceStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_TWISTWITHCOVARIANCESTAMPED_H

geometry_msgs/include/robot_geometry_msgs/Vector3.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+namespace robot_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<::robot_geometry_msgs::Vector3_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Vector3_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Vector3_
+
+  typedef ::robot_geometry_msgs::Vector3_<std::allocator<void>> Vector3;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Vector3> Vector3Ptr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Vector3 const> Vector3ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Vector3_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_geometry_msgs::Vector3_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Vector3_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3_H

geometry_msgs/include/robot_geometry_msgs/Vector3Stamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_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 ::robot_geometry_msgs::Vector3_<ContainerAllocator> _vector_type;
+    _vector_type vector;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Vector3Stamped_
+
+  typedef ::robot_geometry_msgs::Vector3Stamped_<std::allocator<void>> Vector3Stamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Vector3Stamped> Vector3StampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Vector3Stamped const> Vector3StampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.vector == rhs.vector;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Vector3Stamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_VECTOR3STAMPED_H

geometry_msgs/include/robot_geometry_msgs/Wrench.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/Vector3.h>
+#include <robot_geometry_msgs/Vector3.h>
+
+namespace robot_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 ::robot_geometry_msgs::Vector3_<ContainerAllocator> _force_type;
+    _force_type force;
+
+    typedef ::robot_geometry_msgs::Vector3_<ContainerAllocator> _torque_type;
+    _torque_type torque;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::Wrench_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::Wrench_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Wrench_
+
+  typedef ::robot_geometry_msgs::Wrench_<std::allocator<void>> Wrench;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::Wrench> WrenchPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::Wrench const> WrenchConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::Wrench_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Wrench_<ContainerAllocator2> &rhs)
+  {
+    return lhs.force == rhs.force &&
+           lhs.torque == rhs.torque;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::Wrench_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::Wrench_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_WRENCH_H

geometry_msgs/include/robot_geometry_msgs/WrenchStamped.h

@@ -0,0 +1,65 @@
+// Generated by gencpp from file robot_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 <boost/shared_ptr.hpp>
+
+#include <std_msgs/Header.h>
+#include <robot_geometry_msgs/Wrench.h>
+
+namespace robot_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 ::robot_geometry_msgs::Wrench_<ContainerAllocator> _wrench_type;
+    _wrench_type wrench;
+
+    typedef boost::shared_ptr<::robot_geometry_msgs::WrenchStamped_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_geometry_msgs::WrenchStamped_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct WrenchStamped_
+
+  typedef ::robot_geometry_msgs::WrenchStamped_<std::allocator<void>> WrenchStamped;
+
+  typedef boost::shared_ptr<::robot_geometry_msgs::WrenchStamped> WrenchStampedPtr;
+  typedef boost::shared_ptr<::robot_geometry_msgs::WrenchStamped const> WrenchStampedConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_geometry_msgs::WrenchStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::WrenchStamped_<ContainerAllocator2> &rhs)
+  {
+    return lhs.header == rhs.header &&
+           lhs.wrench == rhs.wrench;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_geometry_msgs::WrenchStamped_<ContainerAllocator1> &lhs, const ::robot_geometry_msgs::WrenchStamped_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_geometry_msgs
+
+#endif // GEOMETRY_MSGS_MESSAGE_WRENCHSTAMPED_H