Hiep sua ten file

robot_std_msgs/include/robot_std_msgs/Bool.h

@@ -0,0 +1,61 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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< ::robot_std_msgs::Bool_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_std_msgs::Bool_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Bool_
+
+typedef ::robot_std_msgs::Bool_<std::allocator<void> > Bool;
+
+typedef boost::shared_ptr< ::robot_std_msgs::Bool > BoolPtr;
+typedef boost::shared_ptr< ::robot_std_msgs::Bool const> BoolConstPtr;
+
+// constants requiring out of line definition
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_std_msgs::Bool_<ContainerAllocator1> & lhs, const ::robot_std_msgs::Bool_<ContainerAllocator2> & rhs)
+{
+  return lhs.data == rhs.data;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_std_msgs::Bool_<ContainerAllocator1> & lhs, const ::robot_std_msgs::Bool_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_BOOL_H

robot_std_msgs/include/robot_std_msgs/Byte.h

@@ -0,0 +1,56 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::Byte_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Byte_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Byte_
+
+  typedef ::robot_std_msgs::Byte_<std::allocator<void>> Byte;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Byte> BytePtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Byte const> ByteConstPtr;
+
+  // constants requiring out of line definition
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Byte_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Byte_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Byte_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Byte_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_BYTE_H

robot_std_msgs/include/robot_std_msgs/ByteMultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::ByteMultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::ByteMultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct ByteMultiArray_
+
+  typedef ::robot_std_msgs::ByteMultiArray_<std::allocator<void>> ByteMultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::ByteMultiArray> ByteMultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::ByteMultiArray const> ByteMultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::ByteMultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::ByteMultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::ByteMultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::ByteMultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+#endif // STD_MSGS_MESSAGE_BYTEMULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/Char.h

@@ -0,0 +1,56 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::Char_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Char_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Char_
+
+  typedef ::robot_std_msgs::Char_<std::allocator<void>> Char;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Char> CharPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Char const> CharConstPtr;
+
+  // constants requiring out of line definition
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Char_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Char_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Char_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Char_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_CHAR_H

robot_std_msgs/include/robot_std_msgs/ColorRGBA.h

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

robot_std_msgs/include/robot_std_msgs/Duration.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file robot_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 <robot/duration.h>
+
+namespace robot_std_msgs
+{
+template <class ContainerAllocator>
+struct Duration_
+{
+  typedef Duration_<ContainerAllocator> Type;
+
+  Duration_()
+    : data()  {
+    }
+  Duration_(const ContainerAllocator& _alloc)
+    : data()  {
+  (void)_alloc;
+    }
+
+   typedef robot::Duration _data_type;
+  _data_type data;
+
+  typedef std::shared_ptr< ::robot_std_msgs::Duration_<ContainerAllocator> > Ptr;
+  typedef std::shared_ptr< ::robot_std_msgs::Duration_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Duration_
+
+typedef ::robot_std_msgs::Duration_<std::allocator<void> > Duration;
+
+typedef std::shared_ptr< ::robot_std_msgs::Duration > DurationPtr;
+typedef std::shared_ptr< ::robot_std_msgs::Duration const> DurationConstPtr;
+
+// constants requiring out of line definition
+
+
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_std_msgs::Duration_<ContainerAllocator1> & lhs, const ::robot_std_msgs::Duration_<ContainerAllocator2> & rhs)
+{
+  return lhs.data == rhs.data;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_std_msgs::Duration_<ContainerAllocator1> & lhs, const ::robot_std_msgs::Duration_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_DURATION_H

robot_std_msgs/include/robot_std_msgs/Empty.h

@@ -0,0 +1,40 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_std_msgs
+{
+  template <class ContainerAllocator>
+  struct Empty_
+  {
+    typedef Empty_<ContainerAllocator> Type;
+
+    Empty_()
+    {
+    }
+    Empty_(const ContainerAllocator &_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef boost::shared_ptr<::robot_std_msgs::Empty_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Empty_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Empty_
+
+  typedef ::robot_std_msgs::Empty_<std::allocator<void>> Empty;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Empty> EmptyPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Empty const> EmptyConstPtr;
+
+  // constants requiring out of line definition
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_EMPTY_H

robot_std_msgs/include/robot_std_msgs/Float32.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::Float32_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Float32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Float32_
+
+  typedef ::robot_std_msgs::Float32_<std::allocator<void>> Float32;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Float32> Float32Ptr;
+  typedef boost::shared_ptr<::robot_std_msgs::Float32 const> Float32ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Float32_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Float32_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Float32_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Float32_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_FLOAT32_H

robot_std_msgs/include/robot_std_msgs/Float32MultiArray.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::Float32MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Float32MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Float32MultiArray_
+
+  typedef ::robot_std_msgs::Float32MultiArray_<std::allocator<void>> Float32MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Float32MultiArray> Float32MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Float32MultiArray const> Float32MultiArrayConstPtr;
+
+  // constants requiring out of line definition
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Float32MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Float32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Float32MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Float32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_FLOAT32MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/Float64.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::Float64_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Float64_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Float64_
+
+  typedef ::robot_std_msgs::Float64_<std::allocator<void>> Float64;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Float64> Float64Ptr;
+  typedef boost::shared_ptr<::robot_std_msgs::Float64 const> Float64ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Float64_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Float64_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Float64_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Float64_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_FLOAT64_H

robot_std_msgs/include/robot_std_msgs/Float64MultiArray.h

@@ -0,0 +1,59 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::Float64MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Float64MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Float64MultiArray_
+
+  typedef ::robot_std_msgs::Float64MultiArray_<std::allocator<void>> Float64MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Float64MultiArray> Float64MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Float64MultiArray const> Float64MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Float64MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Float64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Float64MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Float64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+#endif // STD_MSGS_MESSAGE_FLOAT64MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/Header.h

@@ -0,0 +1,66 @@
+// Generated by gencpp from file robot_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 <robot/time.h>
+
+namespace robot_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 robot::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 std::shared_ptr<::robot_std_msgs::Header_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::robot_std_msgs::Header_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Header_
+
+  typedef ::robot_std_msgs::Header_<std::allocator<void>> Header;
+
+  typedef std::shared_ptr<::robot_std_msgs::Header> HeaderPtr;
+  typedef std::shared_ptr<::robot_std_msgs::Header const> HeaderConstPtr;
+
+  // constants requiring out of line definition
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Header_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_std_msgs::Header_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Header_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_HEADER_H

robot_std_msgs/include/robot_std_msgs/Int16.h

@@ -0,0 +1,57 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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 std::shared_ptr<::robot_std_msgs::Int16_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::robot_std_msgs::Int16_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int16_
+
+  typedef ::robot_std_msgs::Int16_<std::allocator<void>> Int16;
+
+  typedef std::shared_ptr<::robot_std_msgs::Int16> Int16Ptr;
+  typedef std::shared_ptr<::robot_std_msgs::Int16 const> Int16ConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Int16_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int16_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Int16_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int16_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT16_H

robot_std_msgs/include/robot_std_msgs/Int16MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::Int16MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Int16MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int16MultiArray_
+
+  typedef ::robot_std_msgs::Int16MultiArray_<std::allocator<void>> Int16MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Int16MultiArray> Int16MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Int16MultiArray const> Int16MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Int16MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int16MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Int16MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int16MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT16MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/Int32.h

@@ -0,0 +1,57 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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 std::shared_ptr<::robot_std_msgs::Int32_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::robot_std_msgs::Int32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int32_
+
+  typedef ::robot_std_msgs::Int32_<std::allocator<void>> Int32;
+
+  typedef std::shared_ptr<::robot_std_msgs::Int32> Int32Ptr;
+  typedef std::shared_ptr<::robot_std_msgs::Int32 const> Int32ConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Int32_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int32_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Int32_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int32_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT32_H

robot_std_msgs/include/robot_std_msgs/Int32MultiArray.h

@@ -0,0 +1,61 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::Int32MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Int32MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int32MultiArray_
+
+  typedef ::robot_std_msgs::Int32MultiArray_<std::allocator<void>> Int32MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Int32MultiArray> Int32MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Int32MultiArray const> Int32MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Int32MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Int32MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT32MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/Int64.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::Int64_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Int64_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int64_
+
+  typedef ::robot_std_msgs::Int64_<std::allocator<void>> Int64;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Int64> Int64Ptr;
+  typedef boost::shared_ptr<::robot_std_msgs::Int64 const> Int64ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Int64_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int64_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Int64_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int64_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT64_H

robot_std_msgs/include/robot_std_msgs/Int64MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::Int64MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Int64MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int64MultiArray_
+
+  typedef ::robot_std_msgs::Int64MultiArray_<std::allocator<void>> Int64MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Int64MultiArray> Int64MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Int64MultiArray const> Int64MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Int64MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Int64MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT64MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/Int8.h

@@ -0,0 +1,57 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::Int8_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Int8_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int8_
+
+  typedef ::robot_std_msgs::Int8_<std::allocator<void>> Int8;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Int8> Int8Ptr;
+  typedef boost::shared_ptr<::robot_std_msgs::Int8 const> Int8ConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Int8_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int8_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Int8_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int8_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT8_H

robot_std_msgs/include/robot_std_msgs/Int8MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::Int8MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::Int8MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Int8MultiArray_
+
+  typedef ::robot_std_msgs::Int8MultiArray_<std::allocator<void>> Int8MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::Int8MultiArray> Int8MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::Int8MultiArray const> Int8MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Int8MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int8MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Int8MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Int8MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_INT8MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/MultiArrayDimension.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::MultiArrayDimension_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::MultiArrayDimension_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct MultiArrayDimension_
+
+  typedef ::robot_std_msgs::MultiArrayDimension_<std::allocator<void>> MultiArrayDimension;
+
+  typedef boost::shared_ptr<::robot_std_msgs::MultiArrayDimension> MultiArrayDimensionPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::MultiArrayDimension const> MultiArrayDimensionConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::MultiArrayDimension_<ContainerAllocator1> &lhs, const ::robot_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 ::robot_std_msgs::MultiArrayDimension_<ContainerAllocator1> &lhs, const ::robot_std_msgs::MultiArrayDimension_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_MULTIARRAYDIMENSION_H

robot_std_msgs/include/robot_std_msgs/MultiArrayLayout.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayDimension.h>
+
+namespace robot_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<::robot_std_msgs::MultiArrayDimension_<ContainerAllocator>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<::robot_std_msgs::MultiArrayDimension_<ContainerAllocator>>> _dim_type;
+    _dim_type dim;
+
+    typedef uint32_t _data_offset_type;
+    _data_offset_type data_offset;
+
+    typedef boost::shared_ptr<::robot_std_msgs::MultiArrayLayout_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::MultiArrayLayout_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct MultiArrayLayout_
+
+  typedef ::robot_std_msgs::MultiArrayLayout_<std::allocator<void>> MultiArrayLayout;
+
+  typedef boost::shared_ptr<::robot_std_msgs::MultiArrayLayout> MultiArrayLayoutPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::MultiArrayLayout const> MultiArrayLayoutConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::MultiArrayLayout_<ContainerAllocator1> &lhs, const ::robot_std_msgs::MultiArrayLayout_<ContainerAllocator2> &rhs)
+  {
+    return lhs.dim == rhs.dim &&
+           lhs.data_offset == rhs.data_offset;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::MultiArrayLayout_<ContainerAllocator1> &lhs, const ::robot_std_msgs::MultiArrayLayout_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_MULTIARRAYLAYOUT_H

robot_std_msgs/include/robot_std_msgs/String.h

@@ -0,0 +1,57 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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 std::shared_ptr<::robot_std_msgs::String_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::robot_std_msgs::String_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct String_
+
+  typedef ::robot_std_msgs::String_<std::allocator<void>> String;
+
+  typedef std::shared_ptr<::robot_std_msgs::String> StringPtr;
+  typedef std::shared_ptr<::robot_std_msgs::String const> StringConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::String_<ContainerAllocator1> &lhs, const ::robot_std_msgs::String_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::String_<ContainerAllocator1> &lhs, const ::robot_std_msgs::String_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_STRING_H

robot_std_msgs/include/robot_std_msgs/Time.h

@@ -0,0 +1,59 @@
+// Generated by gencpp from file robot_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 <robot/time.h>
+
+namespace robot_std_msgs
+{
+  template <class ContainerAllocator>
+  struct Time_
+  {
+    typedef Time_<ContainerAllocator> Type;
+
+    Time_()
+        : data()
+    {
+    }
+    Time_(const ContainerAllocator &_alloc)
+        : data()
+    {
+      (void)_alloc;
+    }
+
+    typedef robot::Time _data_type;
+    _data_type data;
+
+    typedef std::shared_ptr<::robot_std_msgs::Time_<ContainerAllocator>> Ptr;
+    typedef std::shared_ptr<::robot_std_msgs::Time_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct Time_
+
+  typedef ::robot_std_msgs::Time_<std::allocator<void>> Time;
+
+  typedef std::shared_ptr<::robot_std_msgs::Time> TimePtr;
+  typedef std::shared_ptr<::robot_std_msgs::Time const> TimeConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::Time_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Time_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::Time_<ContainerAllocator1> &lhs, const ::robot_std_msgs::Time_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_TIME_H

robot_std_msgs/include/robot_std_msgs/UInt16.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::UInt16_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::UInt16_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt16_
+
+  typedef ::robot_std_msgs::UInt16_<std::allocator<void>> UInt16;
+
+  typedef boost::shared_ptr<::robot_std_msgs::UInt16> UInt16Ptr;
+  typedef boost::shared_ptr<::robot_std_msgs::UInt16 const> UInt16ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::UInt16_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt16_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::UInt16_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt16_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT16_H

robot_std_msgs/include/robot_std_msgs/UInt16MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::UInt16MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::UInt16MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt16MultiArray_
+
+  typedef ::robot_std_msgs::UInt16MultiArray_<std::allocator<void>> UInt16MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::UInt16MultiArray> UInt16MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::UInt16MultiArray const> UInt16MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::UInt16MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt16MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::UInt16MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt16MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT16MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/UInt32.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::UInt32_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::UInt32_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt32_
+
+  typedef ::robot_std_msgs::UInt32_<std::allocator<void>> UInt32;
+
+  typedef boost::shared_ptr<::robot_std_msgs::UInt32> UInt32Ptr;
+  typedef boost::shared_ptr<::robot_std_msgs::UInt32 const> UInt32ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::UInt32_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt32_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::UInt32_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt32_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT32_H

robot_std_msgs/include/robot_std_msgs/UInt32MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::UInt32MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::UInt32MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt32MultiArray_
+
+  typedef ::robot_std_msgs::UInt32MultiArray_<std::allocator<void>> UInt32MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::UInt32MultiArray> UInt32MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::UInt32MultiArray const> UInt32MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::UInt32MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::UInt32MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt32MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT32MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/UInt64.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::UInt64_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::UInt64_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt64_
+
+  typedef ::robot_std_msgs::UInt64_<std::allocator<void>> UInt64;
+
+  typedef boost::shared_ptr<::robot_std_msgs::UInt64> UInt64Ptr;
+  typedef boost::shared_ptr<::robot_std_msgs::UInt64 const> UInt64ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::UInt64_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt64_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::UInt64_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt64_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT64_H

robot_std_msgs/include/robot_std_msgs/UInt64MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::UInt64MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::UInt64MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt64MultiArray_
+
+  typedef ::robot_std_msgs::UInt64MultiArray_<std::allocator<void>> UInt64MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::UInt64MultiArray> UInt64MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::UInt64MultiArray const> UInt64MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::UInt64MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::UInt64MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt64MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT64MULTIARRAY_H

robot_std_msgs/include/robot_std_msgs/UInt8.h

@@ -0,0 +1,55 @@
+// Generated by gencpp from file robot_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>
+
+namespace robot_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<::robot_std_msgs::UInt8_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::UInt8_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt8_
+
+  typedef ::robot_std_msgs::UInt8_<std::allocator<void>> UInt8;
+
+  typedef boost::shared_ptr<::robot_std_msgs::UInt8> UInt8Ptr;
+  typedef boost::shared_ptr<::robot_std_msgs::UInt8 const> UInt8ConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::UInt8_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt8_<ContainerAllocator2> &rhs)
+  {
+    return lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::UInt8_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt8_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT8_H

robot_std_msgs/include/robot_std_msgs/UInt8MultiArray.h

@@ -0,0 +1,60 @@
+// Generated by gencpp from file robot_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 <robot_std_msgs/MultiArrayLayout.h>
+
+namespace robot_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 ::robot_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<::robot_std_msgs::UInt8MultiArray_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_std_msgs::UInt8MultiArray_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct UInt8MultiArray_
+
+  typedef ::robot_std_msgs::UInt8MultiArray_<std::allocator<void>> UInt8MultiArray;
+
+  typedef boost::shared_ptr<::robot_std_msgs::UInt8MultiArray> UInt8MultiArrayPtr;
+  typedef boost::shared_ptr<::robot_std_msgs::UInt8MultiArray const> UInt8MultiArrayConstPtr;
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_std_msgs::UInt8MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt8MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return lhs.layout == rhs.layout &&
+           lhs.data == rhs.data;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_std_msgs::UInt8MultiArray_<ContainerAllocator1> &lhs, const ::robot_std_msgs::UInt8MultiArray_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_std_msgs
+
+#endif // STD_MSGS_MESSAGE_UINT8MULTIARRAY_H