Hiep sua ten file

robot_nav_msgs/include/robot_nav_msgs/GetMap.h

@@ -0,0 +1,27 @@
+// Generated by gencpp from file robot_nav_msgs/GetMap.msg
+// DO NOT EDIT!
+
+#ifndef NAV_MSGS_MESSAGE_GETMAP_H
+#define NAV_MSGS_MESSAGE_GETMAP_H
+
+#include <robot_nav_msgs/GetMapRequest.h>
+#include <robot_nav_msgs/GetMapResponse.h>
+
+namespace robot_nav_msgs
+{
+
+  struct GetMap
+  {
+
+    typedef GetMapRequest Request;
+    typedef GetMapResponse Response;
+    Request request;
+    Response response;
+
+    typedef Request RequestType;
+    typedef Response ResponseType;
+
+  }; // struct GetMap
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAP_H

robot_nav_msgs/include/robot_nav_msgs/GetMapAction.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapAction.msg
+// DO NOT EDIT!
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPACTION_H
+#define NAV_MSGS_MESSAGE_GETMAPACTION_H
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/GetMapActionGoal.h>
+#include <robot_nav_msgs/GetMapActionResult.h>
+#include <robot_nav_msgs/GetMapActionFeedback.h>
+
+namespace robot_nav_msgs
+{
+  template <class ContainerAllocator>
+  struct GetMapAction_
+  {
+    typedef GetMapAction_<ContainerAllocator> Type;
+
+    GetMapAction_()
+        : action_goal(), action_result(), action_feedback()
+    {
+    }
+    GetMapAction_(const ContainerAllocator &_alloc)
+        : action_goal(_alloc), action_result(_alloc), action_feedback(_alloc)
+    {
+      (void)_alloc;
+    }
+
+    typedef ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator> _action_goal_type;
+    _action_goal_type action_goal;
+
+    typedef ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator> _action_result_type;
+    _action_result_type action_result;
+
+    typedef ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator> _action_feedback_type;
+    _action_feedback_type action_feedback;
+
+    typedef boost::shared_ptr<::robot_nav_msgs::GetMapAction_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::robot_nav_msgs::GetMapAction_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct GetMapAction_
+
+  typedef ::robot_nav_msgs::GetMapAction_<std::allocator<void>> GetMapAction;
+
+  typedef boost::shared_ptr<::robot_nav_msgs::GetMapAction> GetMapActionPtr;
+  typedef boost::shared_ptr<::robot_nav_msgs::GetMapAction const> GetMapActionConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::robot_nav_msgs::GetMapAction_<ContainerAllocator1> &lhs, const ::robot_nav_msgs::GetMapAction_<ContainerAllocator2> &rhs)
+  {
+    return lhs.action_goal == rhs.action_goal &&
+           lhs.action_result == rhs.action_result &&
+           lhs.action_feedback == rhs.action_feedback;
+  }
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator!=(const ::robot_nav_msgs::GetMapAction_<ContainerAllocator1> &lhs, const ::robot_nav_msgs::GetMapAction_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTION_H

robot_nav_msgs/include/robot_nav_msgs/GetMapActionFeedback.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapActionFeedback.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H
+#define NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <actionlib_msgs/GoalStatus.h>
+#include <robot_nav_msgs/GetMapFeedback.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionFeedback_
+{
+  typedef GetMapActionFeedback_<ContainerAllocator> Type;
+
+  GetMapActionFeedback_()
+    : header()
+    , status()
+    , feedback()  {
+    }
+  GetMapActionFeedback_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , status(_alloc)
+    , feedback(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::robot_nav_msgs::GetMapFeedback_<ContainerAllocator>  _feedback_type;
+  _feedback_type feedback;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionFeedback_
+
+typedef ::robot_nav_msgs::GetMapActionFeedback_<std::allocator<void> > GetMapActionFeedback;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionFeedback > GetMapActionFeedbackPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionFeedback const> GetMapActionFeedbackConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.status == rhs.status &&
+    lhs.feedback == rhs.feedback;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionFeedback_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H

robot_nav_msgs/include/robot_nav_msgs/GetMapActionGoal.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapActionGoal.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H
+#define NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <actionlib_msgs/GoalID.h>
+#include <robot_nav_msgs/GetMapGoal.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionGoal_
+{
+  typedef GetMapActionGoal_<ContainerAllocator> Type;
+
+  GetMapActionGoal_()
+    : header()
+    , goal_id()
+    , goal()  {
+    }
+  GetMapActionGoal_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , goal_id(_alloc)
+    , goal(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalID_<ContainerAllocator>  _goal_id_type;
+  _goal_id_type goal_id;
+
+   typedef  ::robot_nav_msgs::GetMapGoal_<ContainerAllocator>  _goal_type;
+  _goal_type goal;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionGoal_
+
+typedef ::robot_nav_msgs::GetMapActionGoal_<std::allocator<void> > GetMapActionGoal;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionGoal > GetMapActionGoalPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionGoal const> GetMapActionGoalConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.goal_id == rhs.goal_id &&
+    lhs.goal == rhs.goal;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionGoal_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H

robot_nav_msgs/include/robot_nav_msgs/GetMapActionResult.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapActionResult.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H
+#define NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <actionlib_msgs/GoalStatus.h>
+#include <robot_nav_msgs/GetMapResult.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapActionResult_
+{
+  typedef GetMapActionResult_<ContainerAllocator> Type;
+
+  GetMapActionResult_()
+    : header()
+    , status()
+    , result()  {
+    }
+  GetMapActionResult_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , status(_alloc)
+    , result(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::robot_nav_msgs::GetMapResult_<ContainerAllocator>  _result_type;
+  _result_type result;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionResult_
+
+typedef ::robot_nav_msgs::GetMapActionResult_<std::allocator<void> > GetMapActionResult;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionResult > GetMapActionResultPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapActionResult const> GetMapActionResultConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.status == rhs.status &&
+    lhs.result == rhs.result;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapActionResult_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H

robot_nav_msgs/include/robot_nav_msgs/GetMapFeedback.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapFeedback.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H
+#define NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapFeedback_
+{
+  typedef GetMapFeedback_<ContainerAllocator> Type;
+
+  GetMapFeedback_()
+    {
+    }
+  GetMapFeedback_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapFeedback_
+
+typedef ::robot_nav_msgs::GetMapFeedback_<std::allocator<void> > GetMapFeedback;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapFeedback > GetMapFeedbackPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapFeedback const> GetMapFeedbackConstPtr;
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H

robot_nav_msgs/include/robot_nav_msgs/GetMapGoal.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapGoal.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPGOAL_H
+#define NAV_MSGS_MESSAGE_GETMAPGOAL_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapGoal_
+{
+  typedef GetMapGoal_<ContainerAllocator> Type;
+
+  GetMapGoal_()
+    {
+    }
+  GetMapGoal_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapGoal_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapGoal_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapGoal_
+
+typedef ::robot_nav_msgs::GetMapGoal_<std::allocator<void> > GetMapGoal;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapGoal > GetMapGoalPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapGoal const> GetMapGoalConstPtr;
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPGOAL_H

robot_nav_msgs/include/robot_nav_msgs/GetMapRequest.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPREQUEST_H
+#define NAV_MSGS_MESSAGE_GETMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapRequest_
+{
+  typedef GetMapRequest_<ContainerAllocator> Type;
+
+  GetMapRequest_()
+    {
+    }
+  GetMapRequest_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapRequest_
+
+typedef ::robot_nav_msgs::GetMapRequest_<std::allocator<void> > GetMapRequest;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapRequest > GetMapRequestPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapRequest const> GetMapRequestConstPtr;
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPREQUEST_H

robot_nav_msgs/include/robot_nav_msgs/GetMapResponse.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPRESPONSE_H
+#define NAV_MSGS_MESSAGE_GETMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/OccupancyGrid.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapResponse_
+{
+  typedef GetMapResponse_<ContainerAllocator> Type;
+
+  GetMapResponse_()
+    : map()  {
+    }
+  GetMapResponse_(const ContainerAllocator& _alloc)
+    : map(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapResponse_
+
+typedef ::robot_nav_msgs::GetMapResponse_<std::allocator<void> > GetMapResponse;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResponse > GetMapResponsePtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResponse const> GetMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPRESPONSE_H

robot_nav_msgs/include/robot_nav_msgs/GetMapResult.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_nav_msgs/GetMapResult.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETMAPRESULT_H
+#define NAV_MSGS_MESSAGE_GETMAPRESULT_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/OccupancyGrid.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapResult_
+{
+  typedef GetMapResult_<ContainerAllocator> Type;
+
+  GetMapResult_()
+    : map()  {
+    }
+  GetMapResult_(const ContainerAllocator& _alloc)
+    : map(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResult_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResult_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapResult_
+
+typedef ::robot_nav_msgs::GetMapResult_<std::allocator<void> > GetMapResult;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResult > GetMapResultPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetMapResult const> GetMapResultConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetMapResult_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapResult_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetMapResult_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetMapResult_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPRESULT_H

robot_nav_msgs/include/robot_nav_msgs/GetPlan.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file robot_nav_msgs/GetPlan.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETPLAN_H
+#define NAV_MSGS_MESSAGE_GETPLAN_H
+
+
+#include <robot_nav_msgs/GetPlanRequest.h>
+#include <robot_nav_msgs/GetPlanResponse.h>
+
+
+namespace robot_nav_msgs
+{
+
+struct GetPlan
+{
+
+typedef GetPlanRequest Request;
+typedef GetPlanResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct GetPlan
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETPLAN_H

robot_nav_msgs/include/robot_nav_msgs/GetPlanRequest.h

@@ -0,0 +1,75 @@
+// Generated by gencpp from file robot_nav_msgs/GetPlanRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETPLANREQUEST_H
+#define NAV_MSGS_MESSAGE_GETPLANREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_geometry_msgs/PoseStamped.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetPlanRequest_
+{
+  typedef GetPlanRequest_<ContainerAllocator> Type;
+
+  GetPlanRequest_()
+    : start()
+    , goal()
+    , tolerance(0.0)  {
+    }
+  GetPlanRequest_(const ContainerAllocator& _alloc)
+    : start(_alloc)
+    , goal(_alloc)
+    , tolerance(0.0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_geometry_msgs::PoseStamped  _start_type;
+  _start_type start;
+
+   typedef  ::robot_geometry_msgs::PoseStamped  _goal_type;
+  _goal_type goal;
+
+   typedef float _tolerance_type;
+  _tolerance_type tolerance;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetPlanRequest_
+
+typedef ::robot_nav_msgs::GetPlanRequest_<std::allocator<void> > GetPlanRequest;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanRequest > GetPlanRequestPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanRequest const> GetPlanRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.start == rhs.start &&
+    lhs.goal == rhs.goal &&
+    lhs.tolerance == rhs.tolerance;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetPlanRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETPLANREQUEST_H

robot_nav_msgs/include/robot_nav_msgs/GetPlanResponse.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file robot_nav_msgs/GetPlanResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GETPLANRESPONSE_H
+#define NAV_MSGS_MESSAGE_GETPLANRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/Path.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GetPlanResponse_
+{
+  typedef GetPlanResponse_<ContainerAllocator> Type;
+
+  GetPlanResponse_()
+    : plan()  {
+    }
+  GetPlanResponse_(const ContainerAllocator& _alloc)
+    : plan(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::Path_<ContainerAllocator>  _plan_type;
+  _plan_type plan;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetPlanResponse_
+
+typedef ::robot_nav_msgs::GetPlanResponse_<std::allocator<void> > GetPlanResponse;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanResponse > GetPlanResponsePtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GetPlanResponse const> GetPlanResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.plan == rhs.plan;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GetPlanResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETPLANRESPONSE_H

robot_nav_msgs/include/robot_nav_msgs/GridCells.h

@@ -0,0 +1,82 @@
+// Generated by gencpp from file robot_nav_msgs/GridCells.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_GRIDCELLS_H
+#define NAV_MSGS_MESSAGE_GRIDCELLS_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/Point.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct GridCells_
+{
+  typedef GridCells_<ContainerAllocator> Type;
+
+  GridCells_()
+    : header()
+    , cell_width(0.0)
+    , cell_height(0.0)
+    , cells()  {
+    }
+  GridCells_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , cell_width(0.0)
+    , cell_height(0.0)
+    , cells(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef float _cell_width_type;
+  _cell_width_type cell_width;
+
+   typedef float _cell_height_type;
+  _cell_height_type cell_height;
+
+   typedef std::vector< ::robot_geometry_msgs::Point , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::robot_geometry_msgs::Point >> _cells_type;
+  _cells_type cells;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::GridCells_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::GridCells_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GridCells_
+
+typedef ::robot_nav_msgs::GridCells_<std::allocator<void> > GridCells;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::GridCells > GridCellsPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::GridCells const> GridCellsConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::GridCells_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GridCells_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.cell_width == rhs.cell_width &&
+    lhs.cell_height == rhs.cell_height &&
+    lhs.cells == rhs.cells;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::GridCells_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::GridCells_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GRIDCELLS_H

robot_nav_msgs/include/robot_nav_msgs/LoadMap.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file robot_nav_msgs/LoadMap.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_LOADMAP_H
+#define NAV_MSGS_MESSAGE_LOADMAP_H
+
+
+#include <robot_nav_msgs/LoadMapRequest.h>
+#include <robot_nav_msgs/LoadMapResponse.h>
+
+
+namespace robot_nav_msgs
+{
+
+struct LoadMap
+{
+
+typedef LoadMapRequest Request;
+typedef LoadMapResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct LoadMap
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_LOADMAP_H

robot_nav_msgs/include/robot_nav_msgs/LoadMapRequest.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file robot_nav_msgs/LoadMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_LOADMAPREQUEST_H
+#define NAV_MSGS_MESSAGE_LOADMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct LoadMapRequest_
+{
+  typedef LoadMapRequest_<ContainerAllocator> Type;
+
+  LoadMapRequest_()
+    : map_url()  {
+    }
+  LoadMapRequest_(const ContainerAllocator& _alloc)
+    : map_url(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef std::basic_string<char, std::char_traits<char>, typename std::allocator_traits<ContainerAllocator>::template rebind_alloc<char>> _map_url_type;
+  _map_url_type map_url;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LoadMapRequest_
+
+typedef ::robot_nav_msgs::LoadMapRequest_<std::allocator<void> > LoadMapRequest;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapRequest > LoadMapRequestPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapRequest const> LoadMapRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.map_url == rhs.map_url;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::LoadMapRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_LOADMAPREQUEST_H

robot_nav_msgs/include/robot_nav_msgs/LoadMapResponse.h

@@ -0,0 +1,94 @@
+// Generated by gencpp from file robot_nav_msgs/LoadMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H
+#define NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/OccupancyGrid.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct LoadMapResponse_
+{
+  typedef LoadMapResponse_<ContainerAllocator> Type;
+
+  LoadMapResponse_()
+    : map()
+    , result(0)  {
+    }
+  LoadMapResponse_(const ContainerAllocator& _alloc)
+    : map(_alloc)
+    , result(0)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+   typedef uint8_t _result_type;
+  _result_type result;
+
+
+
+// reducing the odds to have name collisions with Windows.h 
+#if defined(_WIN32) && defined(RESULT_SUCCESS)
+  #undef RESULT_SUCCESS
+#endif
+#if defined(_WIN32) && defined(RESULT_MAP_DOES_NOT_EXIST)
+  #undef RESULT_MAP_DOES_NOT_EXIST
+#endif
+#if defined(_WIN32) && defined(RESULT_INVALID_MAP_DATA)
+  #undef RESULT_INVALID_MAP_DATA
+#endif
+#if defined(_WIN32) && defined(RESULT_INVALID_MAP_METADATA)
+  #undef RESULT_INVALID_MAP_METADATA
+#endif
+#if defined(_WIN32) && defined(RESULT_UNDEFINED_FAILURE)
+  #undef RESULT_UNDEFINED_FAILURE
+#endif
+
+  enum {
+    RESULT_SUCCESS = 0u,
+    RESULT_MAP_DOES_NOT_EXIST = 1u,
+    RESULT_INVALID_MAP_DATA = 2u,
+    RESULT_INVALID_MAP_METADATA = 3u,
+    RESULT_UNDEFINED_FAILURE = 255u,
+  };
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LoadMapResponse_
+
+typedef ::robot_nav_msgs::LoadMapResponse_<std::allocator<void> > LoadMapResponse;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapResponse > LoadMapResponsePtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::LoadMapResponse const> LoadMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map &&
+    lhs.result == rhs.result;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::LoadMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H

robot_nav_msgs/include/robot_nav_msgs/MapMetaData.h

@@ -0,0 +1,88 @@
+// Generated by gencpp from file robot_nav_msgs/MapMetaData.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_MAPMETADATA_H
+#define NAV_MSGS_MESSAGE_MAPMETADATA_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot/time.h>
+#include <robot_geometry_msgs/Pose.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct MapMetaData_
+{
+  typedef MapMetaData_<ContainerAllocator> Type;
+
+  MapMetaData_()
+    : map_load_time()
+    , resolution(0.0)
+    , width(0)
+    , height(0)
+    , origin()  {
+    }
+  MapMetaData_(const ContainerAllocator& _alloc)
+    : map_load_time()
+    , resolution(0.0)
+    , width(0)
+    , height(0)
+    , origin(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef robot::Time _map_load_time_type;
+  _map_load_time_type map_load_time;
+
+   typedef float _resolution_type;
+  _resolution_type resolution;
+
+   typedef uint32_t _width_type;
+  _width_type width;
+
+   typedef uint32_t _height_type;
+  _height_type height;
+
+   typedef  ::robot_geometry_msgs::Pose  _origin_type;
+  _origin_type origin;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::MapMetaData_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::MapMetaData_<ContainerAllocator> const> ConstPtr;
+
+}; // struct MapMetaData_
+
+typedef ::robot_nav_msgs::MapMetaData_<std::allocator<void> > MapMetaData;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::MapMetaData > MapMetaDataPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::MapMetaData const> MapMetaDataConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::MapMetaData_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::MapMetaData_<ContainerAllocator2> & rhs)
+{
+  return lhs.map_load_time == rhs.map_load_time &&
+    lhs.resolution == rhs.resolution &&
+    lhs.width == rhs.width &&
+    lhs.height == rhs.height &&
+    lhs.origin == rhs.origin;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::MapMetaData_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::MapMetaData_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_MAPMETADATA_H

robot_nav_msgs/include/robot_nav_msgs/OccupancyGrid.h

@@ -0,0 +1,76 @@
+// Generated by gencpp from file robot_nav_msgs/OccupancyGrid.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_OCCUPANCYGRID_H
+#define NAV_MSGS_MESSAGE_OCCUPANCYGRID_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_nav_msgs/MapMetaData.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct OccupancyGrid_
+{
+  typedef OccupancyGrid_<ContainerAllocator> Type;
+
+  OccupancyGrid_()
+    : header()
+    , info()
+    , data()  {
+    }
+  OccupancyGrid_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , info(_alloc)
+    , data(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::robot_nav_msgs::MapMetaData_<ContainerAllocator>  _info_type;
+  _info_type info;
+
+   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_nav_msgs::OccupancyGrid_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator> const> ConstPtr;
+
+}; // struct OccupancyGrid_
+
+typedef ::robot_nav_msgs::OccupancyGrid_<std::allocator<void> > OccupancyGrid;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::OccupancyGrid > OccupancyGridPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::OccupancyGrid const> OccupancyGridConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.info == rhs.info &&
+    lhs.data == rhs.data;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_OCCUPANCYGRID_H

robot_nav_msgs/include/robot_nav_msgs/Odometry.h

@@ -0,0 +1,83 @@
+// Generated by gencpp from file robot_nav_msgs/Odometry.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_ODOMETRY_H
+#define NAV_MSGS_MESSAGE_ODOMETRY_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/PoseWithCovariance.h>
+#include <robot_geometry_msgs/TwistWithCovariance.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct Odometry_
+{
+  typedef Odometry_<ContainerAllocator> Type;
+
+  Odometry_()
+    : header()
+    , child_frame_id()
+    , pose()
+    , twist()  {
+    }
+  Odometry_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , child_frame_id(_alloc)
+    , pose(_alloc)
+    , twist(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _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::PoseWithCovariance  _pose_type;
+  _pose_type pose;
+
+   typedef  ::robot_geometry_msgs::TwistWithCovariance  _twist_type;
+  _twist_type twist;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::Odometry_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::Odometry_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Odometry_
+
+typedef ::robot_nav_msgs::Odometry_<std::allocator<void> > Odometry;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::Odometry > OdometryPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::Odometry const> OdometryConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::Odometry_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::Odometry_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.child_frame_id == rhs.child_frame_id &&
+    lhs.pose == rhs.pose &&
+    lhs.twist == rhs.twist;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::Odometry_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::Odometry_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_ODOMETRY_H

robot_nav_msgs/include/robot_nav_msgs/Path.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file robot_nav_msgs/Path.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_PATH_H
+#define NAV_MSGS_MESSAGE_PATH_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_std_msgs/Header.h>
+#include <robot_geometry_msgs/PoseStamped.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct Path_
+{
+  typedef Path_<ContainerAllocator> Type;
+
+  Path_()
+    : header()
+    , poses()  {
+    }
+  Path_(const ContainerAllocator& _alloc)
+    : header(_alloc)
+    , poses(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef std::vector< ::robot_geometry_msgs::PoseStamped , typename std::allocator_traits<ContainerAllocator>::template rebind_alloc< ::robot_geometry_msgs::PoseStamped >> _poses_type;
+  _poses_type poses;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::Path_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::Path_<ContainerAllocator> const> ConstPtr;
+
+}; // struct Path_
+
+typedef ::robot_nav_msgs::Path_<std::allocator<void> > Path;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::Path > PathPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::Path const> PathConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::Path_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::Path_<ContainerAllocator2> & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.poses == rhs.poses;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::Path_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::Path_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_PATH_H

robot_nav_msgs/include/robot_nav_msgs/SetMap.h

@@ -0,0 +1,30 @@
+// Generated by gencpp from file robot_nav_msgs/SetMap.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_SETMAP_H
+#define NAV_MSGS_MESSAGE_SETMAP_H
+
+
+#include <robot_nav_msgs/SetMapRequest.h>
+#include <robot_nav_msgs/SetMapResponse.h>
+
+
+namespace robot_nav_msgs
+{
+
+struct SetMap
+{
+
+typedef SetMapRequest Request;
+typedef SetMapResponse Response;
+Request request;
+Response response;
+
+typedef Request RequestType;
+typedef Response ResponseType;
+
+}; // struct SetMap
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_SETMAP_H

robot_nav_msgs/include/robot_nav_msgs/SetMapRequest.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file robot_nav_msgs/SetMapRequest.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_SETMAPREQUEST_H
+#define NAV_MSGS_MESSAGE_SETMAPREQUEST_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+#include <robot_nav_msgs/OccupancyGrid.h>
+#include <robot_geometry_msgs/PoseWithCovarianceStamped.h>
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct SetMapRequest_
+{
+  typedef SetMapRequest_<ContainerAllocator> Type;
+
+  SetMapRequest_()
+    : map()
+    , initial_pose()  {
+    }
+  SetMapRequest_(const ContainerAllocator& _alloc)
+    : map(_alloc)
+    , initial_pose(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::robot_nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+   typedef  ::robot_geometry_msgs::PoseWithCovarianceStamped  _initial_pose_type;
+  _initial_pose_type initial_pose;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::SetMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::SetMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetMapRequest_
+
+typedef ::robot_nav_msgs::SetMapRequest_<std::allocator<void> > SetMapRequest;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::SetMapRequest > SetMapRequestPtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::SetMapRequest const> SetMapRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::SetMapRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::SetMapRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map &&
+    lhs.initial_pose == rhs.initial_pose;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::SetMapRequest_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::SetMapRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_SETMAPREQUEST_H

robot_nav_msgs/include/robot_nav_msgs/SetMapResponse.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file robot_nav_msgs/SetMapResponse.msg
+// DO NOT EDIT!
+
+
+#ifndef NAV_MSGS_MESSAGE_SETMAPRESPONSE_H
+#define NAV_MSGS_MESSAGE_SETMAPRESPONSE_H
+
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <boost/shared_ptr.hpp>
+
+
+namespace robot_nav_msgs
+{
+template <class ContainerAllocator>
+struct SetMapResponse_
+{
+  typedef SetMapResponse_<ContainerAllocator> Type;
+
+  SetMapResponse_()
+    : success(false)  {
+    }
+  SetMapResponse_(const ContainerAllocator& _alloc)
+    : success(false)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef uint8_t _success_type;
+  _success_type success;
+
+
+
+
+  typedef boost::shared_ptr< ::robot_nav_msgs::SetMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::robot_nav_msgs::SetMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetMapResponse_
+
+typedef ::robot_nav_msgs::SetMapResponse_<std::allocator<void> > SetMapResponse;
+
+typedef boost::shared_ptr< ::robot_nav_msgs::SetMapResponse > SetMapResponsePtr;
+typedef boost::shared_ptr< ::robot_nav_msgs::SetMapResponse const> SetMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::robot_nav_msgs::SetMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::SetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.success == rhs.success;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::robot_nav_msgs::SetMapResponse_<ContainerAllocator1> & lhs, const ::robot_nav_msgs::SetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace robot_nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_SETMAPRESPONSE_H