add more files msgs

nav_msgs/include/nav_msgs/GetMap.h

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

nav_msgs/include/nav_msgs/GetMapAction.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file 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 <nav_msgs/GetMapActionGoal.h>
+#include <nav_msgs/GetMapActionResult.h>
+#include <nav_msgs/GetMapActionFeedback.h>
+
+namespace 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 ::nav_msgs::GetMapActionGoal_<ContainerAllocator> _action_goal_type;
+    _action_goal_type action_goal;
+
+    typedef ::nav_msgs::GetMapActionResult_<ContainerAllocator> _action_result_type;
+    _action_result_type action_result;
+
+    typedef ::nav_msgs::GetMapActionFeedback_<ContainerAllocator> _action_feedback_type;
+    _action_feedback_type action_feedback;
+
+    typedef boost::shared_ptr<::nav_msgs::GetMapAction_<ContainerAllocator>> Ptr;
+    typedef boost::shared_ptr<::nav_msgs::GetMapAction_<ContainerAllocator> const> ConstPtr;
+
+  }; // struct GetMapAction_
+
+  typedef ::nav_msgs::GetMapAction_<std::allocator<void>> GetMapAction;
+
+  typedef boost::shared_ptr<::nav_msgs::GetMapAction> GetMapActionPtr;
+  typedef boost::shared_ptr<::nav_msgs::GetMapAction const> GetMapActionConstPtr;
+
+  // constants requiring out of line definition
+
+  template <typename ContainerAllocator1, typename ContainerAllocator2>
+  bool operator==(const ::nav_msgs::GetMapAction_<ContainerAllocator1> &lhs, const ::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 ::nav_msgs::GetMapAction_<ContainerAllocator1> &lhs, const ::nav_msgs::GetMapAction_<ContainerAllocator2> &rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTION_H

nav_msgs/include/nav_msgs/GetMapActionFeedback.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file 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 <std_msgs/Header.h>
+#include <actionlib_msgs/GoalStatus.h>
+#include <nav_msgs/GetMapFeedback.h>
+
+namespace 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  ::std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::nav_msgs::GetMapFeedback_<ContainerAllocator>  _feedback_type;
+  _feedback_type feedback;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionFeedback_
+
+typedef ::nav_msgs::GetMapActionFeedback_<std::allocator<void> > GetMapActionFeedback;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionFeedback > GetMapActionFeedbackPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionFeedback const> GetMapActionFeedbackConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapActionFeedback_<ContainerAllocator1> & lhs, const ::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 ::nav_msgs::GetMapActionFeedback_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionFeedback_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONFEEDBACK_H

nav_msgs/include/nav_msgs/GetMapActionGoal.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file 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 <std_msgs/Header.h>
+#include <actionlib_msgs/GoalID.h>
+#include <nav_msgs/GetMapGoal.h>
+
+namespace 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  ::std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalID_<ContainerAllocator>  _goal_id_type;
+  _goal_id_type goal_id;
+
+   typedef  ::nav_msgs::GetMapGoal_<ContainerAllocator>  _goal_type;
+  _goal_type goal;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionGoal_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionGoal_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionGoal_
+
+typedef ::nav_msgs::GetMapActionGoal_<std::allocator<void> > GetMapActionGoal;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionGoal > GetMapActionGoalPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionGoal const> GetMapActionGoalConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapActionGoal_<ContainerAllocator1> & lhs, const ::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 ::nav_msgs::GetMapActionGoal_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionGoal_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONGOAL_H

nav_msgs/include/nav_msgs/GetMapActionResult.h

@@ -0,0 +1,77 @@
+// Generated by gencpp from file 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 <std_msgs/Header.h>
+#include <actionlib_msgs/GoalStatus.h>
+#include <nav_msgs/GetMapResult.h>
+
+namespace 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  ::std_msgs::Header  _header_type;
+  _header_type header;
+
+   typedef  ::actionlib_msgs::GoalStatus_<ContainerAllocator>  _status_type;
+  _status_type status;
+
+   typedef  ::nav_msgs::GetMapResult_<ContainerAllocator>  _result_type;
+  _result_type result;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionResult_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapActionResult_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapActionResult_
+
+typedef ::nav_msgs::GetMapActionResult_<std::allocator<void> > GetMapActionResult;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionResult > GetMapActionResultPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapActionResult const> GetMapActionResultConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapActionResult_<ContainerAllocator1> & lhs, const ::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 ::nav_msgs::GetMapActionResult_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapActionResult_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPACTIONRESULT_H

nav_msgs/include/nav_msgs/GetMapFeedback.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file 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 nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapFeedback_
+{
+  typedef GetMapFeedback_<ContainerAllocator> Type;
+
+  GetMapFeedback_()
+    {
+    }
+  GetMapFeedback_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapFeedback_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapFeedback_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapFeedback_
+
+typedef ::nav_msgs::GetMapFeedback_<std::allocator<void> > GetMapFeedback;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapFeedback > GetMapFeedbackPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapFeedback const> GetMapFeedbackConstPtr;
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPFEEDBACK_H

nav_msgs/include/nav_msgs/GetMapGoal.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file 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 nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapGoal_
+{
+  typedef GetMapGoal_<ContainerAllocator> Type;
+
+  GetMapGoal_()
+    {
+    }
+  GetMapGoal_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapGoal_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapGoal_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapGoal_
+
+typedef ::nav_msgs::GetMapGoal_<std::allocator<void> > GetMapGoal;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapGoal > GetMapGoalPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapGoal const> GetMapGoalConstPtr;
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPGOAL_H

nav_msgs/include/nav_msgs/GetMapRequest.h

@@ -0,0 +1,45 @@
+// Generated by gencpp from file 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 nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapRequest_
+{
+  typedef GetMapRequest_<ContainerAllocator> Type;
+
+  GetMapRequest_()
+    {
+    }
+  GetMapRequest_(const ContainerAllocator& _alloc)
+    {
+  (void)_alloc;
+    }
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapRequest_
+
+typedef ::nav_msgs::GetMapRequest_<std::allocator<void> > GetMapRequest;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapRequest > GetMapRequestPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapRequest const> GetMapRequestConstPtr;
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPREQUEST_H

nav_msgs/include/nav_msgs/GetMapResponse.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file 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 <nav_msgs/OccupancyGrid.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapResponse_
+{
+  typedef GetMapResponse_<ContainerAllocator> Type;
+
+  GetMapResponse_()
+    : map()  {
+    }
+  GetMapResponse_(const ContainerAllocator& _alloc)
+    : map(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapResponse_
+
+typedef ::nav_msgs::GetMapResponse_<std::allocator<void> > GetMapResponse;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapResponse > GetMapResponsePtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapResponse const> GetMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPRESPONSE_H

nav_msgs/include/nav_msgs/GetMapResult.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file 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 <nav_msgs/OccupancyGrid.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetMapResult_
+{
+  typedef GetMapResult_<ContainerAllocator> Type;
+
+  GetMapResult_()
+    : map()  {
+    }
+  GetMapResult_(const ContainerAllocator& _alloc)
+    : map(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetMapResult_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetMapResult_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetMapResult_
+
+typedef ::nav_msgs::GetMapResult_<std::allocator<void> > GetMapResult;
+
+typedef boost::shared_ptr< ::nav_msgs::GetMapResult > GetMapResultPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetMapResult const> GetMapResultConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetMapResult_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapResult_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetMapResult_<ContainerAllocator1> & lhs, const ::nav_msgs::GetMapResult_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETMAPRESULT_H

nav_msgs/include/nav_msgs/GetPlan.h

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

nav_msgs/include/nav_msgs/GetPlanRequest.h

@@ -0,0 +1,75 @@
+// Generated by gencpp from file 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 <geometry_msgs/PoseStamped.h>
+
+namespace 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  ::geometry_msgs::PoseStamped  _start_type;
+  _start_type start;
+
+   typedef  ::geometry_msgs::PoseStamped  _goal_type;
+  _goal_type goal;
+
+   typedef float _tolerance_type;
+  _tolerance_type tolerance;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetPlanRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetPlanRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetPlanRequest_
+
+typedef ::nav_msgs::GetPlanRequest_<std::allocator<void> > GetPlanRequest;
+
+typedef boost::shared_ptr< ::nav_msgs::GetPlanRequest > GetPlanRequestPtr;
+typedef boost::shared_ptr< ::nav_msgs::GetPlanRequest const> GetPlanRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetPlanRequest_<ContainerAllocator1> & lhs, const ::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 ::nav_msgs::GetPlanRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::GetPlanRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETPLANREQUEST_H

nav_msgs/include/nav_msgs/GetPlanResponse.h

@@ -0,0 +1,63 @@
+// Generated by gencpp from file 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 <nav_msgs/Path.h>
+
+namespace nav_msgs
+{
+template <class ContainerAllocator>
+struct GetPlanResponse_
+{
+  typedef GetPlanResponse_<ContainerAllocator> Type;
+
+  GetPlanResponse_()
+    : plan()  {
+    }
+  GetPlanResponse_(const ContainerAllocator& _alloc)
+    : plan(_alloc)  {
+  (void)_alloc;
+    }
+
+
+
+   typedef  ::nav_msgs::Path_<ContainerAllocator>  _plan_type;
+  _plan_type plan;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::GetPlanResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::GetPlanResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct GetPlanResponse_
+
+typedef ::nav_msgs::GetPlanResponse_<std::allocator<void> > GetPlanResponse;
+
+typedef boost::shared_ptr< ::nav_msgs::GetPlanResponse > GetPlanResponsePtr;
+typedef boost::shared_ptr< ::nav_msgs::GetPlanResponse const> GetPlanResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::GetPlanResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::GetPlanResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.plan == rhs.plan;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::GetPlanResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::GetPlanResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_GETPLANRESPONSE_H

nav_msgs/include/nav_msgs/GridCells.h

@@ -21,8 +21,27 @@ struct GridCells
     float cell_width;
     float cell_height;
     std::vector<geometry_msgs::Point> cells;
+    
+    GridCells() = default;
 };
 
+inline bool operator==(const nav_msgs::GridCells & lhs, const nav_msgs::GridCells & rhs)
+{
+    if(lhs.cells.size() != rhs.cells.size()) return false;
+    for(int i = 0; i < lhs.cells.size(); i++)
+    {
+        if(lhs.cells[i] != rhs.cells[i]) return false;
+    }
+  return lhs.header == rhs.header &&
+    isEqual(lhs.cell_width, rhs.cell_width) &&
+    isEqual(lhs.cell_height, rhs.cell_height);
+}
+
+inline bool operator!=(const nav_msgs::GridCells & lhs, const nav_msgs::GridCells & rhs)
+{
+  return !(lhs == rhs);
+}
+
 }
 
 #endif //GRID_CELLS_H

nav_msgs/include/nav_msgs/LoadMap.h

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

nav_msgs/include/nav_msgs/LoadMapRequest.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file 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 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< ::nav_msgs::LoadMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::LoadMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LoadMapRequest_
+
+typedef ::nav_msgs::LoadMapRequest_<std::allocator<void> > LoadMapRequest;
+
+typedef boost::shared_ptr< ::nav_msgs::LoadMapRequest > LoadMapRequestPtr;
+typedef boost::shared_ptr< ::nav_msgs::LoadMapRequest const> LoadMapRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::LoadMapRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::LoadMapRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.map_url == rhs.map_url;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::LoadMapRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::LoadMapRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_LOADMAPREQUEST_H

nav_msgs/include/nav_msgs/LoadMapResponse.h

@@ -0,0 +1,94 @@
+// Generated by gencpp from file 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 <nav_msgs/OccupancyGrid.h>
+
+namespace 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  ::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< ::nav_msgs::LoadMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::LoadMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct LoadMapResponse_
+
+typedef ::nav_msgs::LoadMapResponse_<std::allocator<void> > LoadMapResponse;
+
+typedef boost::shared_ptr< ::nav_msgs::LoadMapResponse > LoadMapResponsePtr;
+typedef boost::shared_ptr< ::nav_msgs::LoadMapResponse const> LoadMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::LoadMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::LoadMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map &&
+    lhs.result == rhs.result;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::LoadMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::LoadMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_LOADMAPRESPONSE_H

nav_msgs/include/nav_msgs/MapMetaData.h

@@ -5,6 +5,7 @@
 #include <string>
 #include <vector>
 #include "geometry_msgs/Pose.h"
+// #include "utils.h"
 
 namespace nav_msgs
 {
@@ -16,8 +17,24 @@ struct MapMetaData
     uint32_t width;
     uint32_t height;
     geometry_msgs::Pose origin;
+
+    MapMetaData() : map_load_time(0.0), resolution(0.0), width(0), height(0), origin() {}
 };
 
+inline bool operator==(const nav_msgs::MapMetaData & lhs, const nav_msgs::MapMetaData & rhs)
+{
+  return isEqual(lhs.map_load_time, rhs.map_load_time) &&
+    isEqual(lhs.resolution, rhs.resolution) &&
+    lhs.width == rhs.width &&
+    lhs.height == rhs.height &&
+    lhs.origin == rhs.origin;
+}
+
+inline bool operator!=(const nav_msgs::MapMetaData & lhs, const nav_msgs::MapMetaData & rhs)
+{
+  return !(lhs == rhs);
+}
+
 }
 
 #endif //MAP_META_DATA_H

nav_msgs/include/nav_msgs/OccupancyGrid.h

@@ -4,7 +4,7 @@
 #include <cstdint>
 #include <string>
 #include <vector>
-#include "std_msgs/Header.h"
+#include <std_msgs/Header.h>
 #include <nav_msgs/MapMetaData.h>
 
 namespace nav_msgs
@@ -17,8 +17,26 @@ std_msgs::Header header;
 MapMetaData info;
 
 std::vector<uint8_t> data;
+OccupancyGrid() = default;
 };
 
+inline bool operator==(const nav_msgs::OccupancyGrid & lhs, const nav_msgs::OccupancyGrid & rhs)
+{
+    if(lhs.data.size() != rhs.data.size()) return false;
+    for(int i = 0; i < lhs.data.size(); i++)
+    {
+        if(lhs.data[i] != rhs.data[i]) return false;
+    }
+  return lhs.header == rhs.header &&
+    lhs.info == rhs.info;
+
 }
 
+inline bool operator!=(const nav_msgs::OccupancyGrid & lhs, const nav_msgs::OccupancyGrid & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
 #endif //OCCUPANCY_GRID_H

nav_msgs/include/nav_msgs/Odometry.h

@@ -25,8 +25,24 @@ struct Odometry
     std::string child_frame_id;
     geometry_msgs::PoseWithCovariance pose;
     geometry_msgs::TwistWithCovariance twist;
+
+    Odometry() = default;
 };
 
+inline bool operator==(const nav_msgs::Odometry & lhs, const nav_msgs::Odometry & rhs)
+{
+  return lhs.header == rhs.header &&
+    lhs.child_frame_id == rhs.child_frame_id &&
+    lhs.pose == rhs.pose &&
+    lhs.twist == rhs.twist;
+}
+
+inline bool operator!=(const nav_msgs::Odometry & lhs, const nav_msgs::Odometry & rhs)
+{
+  return !(lhs == rhs);
+}
+
+
 }
 
 #endif //ODOMETRY_H

nav_msgs/include/nav_msgs/Path.h

@@ -17,8 +17,25 @@ struct Path
 {
     std_msgs::Header header;
     std::vector<geometry_msgs::PoseStamped> poses;
+
+    Path() = default;
 };
 
+bool operator==(const nav_msgs::Path & lhs, const nav_msgs::Path & rhs)
+{
+    if(lhs.poses.size() != rhs.poses.size()) return false;
+    for(int i = 0; i < lhs.poses.size(); i++)
+    {
+        if(lhs.poses[i] != rhs.poses[i]) return false;
+    }
+  return lhs.header == rhs.header;
+}
+
+bool operator!=(const nav_msgs::Path & lhs, const nav_msgs::Path & rhs)
+{
+  return !(lhs == rhs);
+}
+
 }
 
 #endif //PATH_H

nav_msgs/include/nav_msgs/SetMap.h

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

nav_msgs/include/nav_msgs/SetMapRequest.h

@@ -0,0 +1,70 @@
+// Generated by gencpp from file 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 <nav_msgs/OccupancyGrid.h>
+#include <geometry_msgs/PoseWithCovarianceStamped.h>
+
+namespace 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  ::nav_msgs::OccupancyGrid_<ContainerAllocator>  _map_type;
+  _map_type map;
+
+   typedef  ::geometry_msgs::PoseWithCovarianceStamped  _initial_pose_type;
+  _initial_pose_type initial_pose;
+
+
+
+
+  typedef boost::shared_ptr< ::nav_msgs::SetMapRequest_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::SetMapRequest_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetMapRequest_
+
+typedef ::nav_msgs::SetMapRequest_<std::allocator<void> > SetMapRequest;
+
+typedef boost::shared_ptr< ::nav_msgs::SetMapRequest > SetMapRequestPtr;
+typedef boost::shared_ptr< ::nav_msgs::SetMapRequest const> SetMapRequestConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::SetMapRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::SetMapRequest_<ContainerAllocator2> & rhs)
+{
+  return lhs.map == rhs.map &&
+    lhs.initial_pose == rhs.initial_pose;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::SetMapRequest_<ContainerAllocator1> & lhs, const ::nav_msgs::SetMapRequest_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_SETMAPREQUEST_H

nav_msgs/include/nav_msgs/SetMapResponse.h

@@ -0,0 +1,62 @@
+// Generated by gencpp from file 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 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< ::nav_msgs::SetMapResponse_<ContainerAllocator> > Ptr;
+  typedef boost::shared_ptr< ::nav_msgs::SetMapResponse_<ContainerAllocator> const> ConstPtr;
+
+}; // struct SetMapResponse_
+
+typedef ::nav_msgs::SetMapResponse_<std::allocator<void> > SetMapResponse;
+
+typedef boost::shared_ptr< ::nav_msgs::SetMapResponse > SetMapResponsePtr;
+typedef boost::shared_ptr< ::nav_msgs::SetMapResponse const> SetMapResponseConstPtr;
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator==(const ::nav_msgs::SetMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::SetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return lhs.success == rhs.success;
+}
+
+template<typename ContainerAllocator1, typename ContainerAllocator2>
+bool operator!=(const ::nav_msgs::SetMapResponse_<ContainerAllocator1> & lhs, const ::nav_msgs::SetMapResponse_<ContainerAllocator2> & rhs)
+{
+  return !(lhs == rhs);
+}
+
+} // namespace nav_msgs
+
+#endif // NAV_MSGS_MESSAGE_SETMAPRESPONSE_H