node_handle.h

Go to the documentation of this file.

#include "sick_scan/sick_scan_base.h" /* Base definitions included in all header files, added by add_sick_scan_base_header.py. Do not edit this line. */
/*
 * Copyright (C) 2009, Willow Garage, Inc.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef ROSCPP_NODE_HANDLE_H
#define ROSCPP_NODE_HANDLE_H
 
#include "ros/forwards.h"
#include "ros/publisher.h"
#include "ros/subscriber.h"
#include "ros/service_server.h"
#include "ros/service_client.h"
#include "ros/timer.h"
#include "ros/rate.h"
#include "ros/wall_timer.h"
#include "ros/advertise_options.h"
#include "ros/advertise_service_options.h"
#include "ros/subscribe_options.h"
#include "ros/service_client_options.h"
#include "ros/timer_options.h"
#include "ros/wall_timer_options.h"
#include "ros/spinner.h"
#include "ros/init.h"
#include "common.h"
 
//#include <boost/bind.hpp>
 
#include <xmlrpcpp/XmlRpcValue.h>
 
namespace roswrap
{
 
  class NodeHandleBackingCollection;
 
  class ROSCPP_DECL NodeHandle
  {
  public:
    NodeHandle(const std::string& ns = std::string(), const M_string& remappings = M_string());
    NodeHandle(const NodeHandle& rhs);
    NodeHandle(const NodeHandle& parent, const std::string& ns);
    NodeHandle(const NodeHandle& parent, const std::string& ns, const M_string& remappings);
    ~NodeHandle();
 
    NodeHandle& operator=(const NodeHandle& rhs);
 
    void setCallbackQueue(CallbackQueueInterface* queue);
 
    CallbackQueueInterface* getCallbackQueue() const
    {
      return callback_queue_ ? callback_queue_ : (CallbackQueueInterface*)getGlobalCallbackQueue();
    }
 
    const std::string& getNamespace() const { return namespace_; }
 
    const std::string& getUnresolvedNamespace() const { return unresolved_namespace_; }
 
    std::string resolveName(const std::string& name, bool remap = true) const;
 
    // Versions of advertise()
 
    template <class M>
    Publisher advertise(const std::string& topic, uint32_t queue_size, bool latch = false)
    {
      AdvertiseOptions ops;
      ops.template init<M>(topic, queue_size);
      ops.latch = latch;
      return advertise(ops);
    }
 
  template <class M>
  Publisher advertise(const std::string& topic, uint32_t queue_size,
                            const SubscriberStatusCallback& connect_cb,
                            const SubscriberStatusCallback& disconnect_cb = SubscriberStatusCallback(),
                            const VoidConstPtr& tracked_object = VoidConstPtr(),
                            bool latch = false)
  {
    AdvertiseOptions ops;
    ops.template init<M>(topic, queue_size, connect_cb, disconnect_cb);
    ops.tracked_object = tracked_object;
    ops.latch = latch;
    return advertise(ops);
  }
 
  Publisher advertise(AdvertiseOptions& ops);
 
 
  // Versions of subscribe()
 
  template<class M, class T>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size, void(T::*fp)(M), T* obj,
                       const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template initByFullCallbackType<M>(topic, queue_size, std::bind(fp, obj, std::placeholders::_1));
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M, class T>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size, void(T::*fp)(M) const, T* obj,
                       const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template initByFullCallbackType<M>(topic, queue_size, std::bind(fp, obj, std::placeholders::_1));
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M, class T>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size,
                       void(T::*fp)(const std::shared_ptr<M const>&), T* obj,
                       const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template init<M>(topic, queue_size, std::bind(fp, obj, std::placeholders::_1));
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
  template<class M, class T>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size,
                       void(T::*fp)(const std::shared_ptr<M const>&) const, T* obj,
                       const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template init<M>(topic, queue_size, std::bind(fp, obj, std::placeholders::_1));
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M, class T>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size, void(T::*fp)(M),
                       const std::shared_ptr<T>& obj, const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template initByFullCallbackType<M>(topic, queue_size, std::bind(fp, obj.get(), std::placeholders::_1));
    ops.tracked_object = obj;
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M, class T>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size, void(T::*fp)(M) const,
                       const std::shared_ptr<T>& obj, const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template initByFullCallbackType<M>(topic, queue_size, std::bind(fp, obj.get(), std::placeholders::_1));
    ops.tracked_object = obj;
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M, class T>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size,
                       void(T::*fp)(const std::shared_ptr<M const>&),
                       const std::shared_ptr<T>& obj, const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template init<M>(topic, queue_size, std::bind(fp, obj.get(), std::placeholders::_1));
    ops.tracked_object = obj;
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
  template<class M, class T>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size,
                       void(T::*fp)(const std::shared_ptr<M const>&) const,
                       const std::shared_ptr<T>& obj, const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template init<M>(topic, queue_size, std::bind(fp, obj.get(), std::placeholders::_1));
    ops.tracked_object = obj;
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size, void(*fp)(M), const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template initByFullCallbackType<M>(topic, queue_size, fp);
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size, void(*fp)(const std::shared_ptr<M const>&), const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template init<M>(topic, queue_size, fp);
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size, const std::function<void (const std::shared_ptr<M const>&)>& callback,
                             const VoidConstPtr& tracked_object = VoidConstPtr(), const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template init<M>(topic, queue_size, callback);
    ops.tracked_object = tracked_object;
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  template<class M, class C>
  Subscriber subscribe(const std::string& topic, uint32_t queue_size, const std::function<void (C)>& callback,
                             const VoidConstPtr& tracked_object = VoidConstPtr(), const TransportHints& transport_hints = TransportHints())
  {
    SubscribeOptions ops;
    ops.template initByFullCallbackType<C>(topic, queue_size, callback);
    ops.tracked_object = tracked_object;
    ops.transport_hints = transport_hints;
    return subscribe(ops);
  }
 
  Subscriber subscribe(SubscribeOptions& ops);
 
  // Versions of advertiseService()
 
  template<class T, class MReq, class MRes>
  ServiceServer advertiseService(const std::string& service, bool(T::*srv_func)(MReq &, MRes &), T *obj)
  {
    AdvertiseServiceOptions ops;
    ops.template init<MReq, MRes>(service, std::bind(srv_func, obj, std::placeholders::_1, std::placeholders::_2));
    return advertiseService(ops);
  }
 
  template<class T, class MReq, class MRes>
  ServiceServer advertiseService(const std::string& service, bool(T::*srv_func)(ServiceEvent<MReq, MRes>&), T *obj)
  {
    AdvertiseServiceOptions ops;
    ops.template initBySpecType<ServiceEvent<MReq, MRes> >(service, std::bind(srv_func, obj, std::placeholders::_1));
    return advertiseService(ops);
  }
 
  template<class T, class MReq, class MRes>
  ServiceServer advertiseService(const std::string& service, bool(T::*srv_func)(MReq &, MRes &), const std::shared_ptr<T>& obj)
  {
    AdvertiseServiceOptions ops;
    ops.template init<MReq, MRes>(service, std::bind(srv_func, obj.get(), std::placeholders::_1, std::placeholders::_2));
    ops.tracked_object = obj;
    return advertiseService(ops);
  }
 
  template<class T, class MReq, class MRes>
  ServiceServer advertiseService(const std::string& service, bool(T::*srv_func)(ServiceEvent<MReq, MRes>&), const std::shared_ptr<T>& obj)
  {
    AdvertiseServiceOptions ops;
    ops.template initBySpecType<ServiceEvent<MReq, MRes> >(service, std::bind(srv_func, obj.get(), std::placeholders::_1));
    ops.tracked_object = obj;
    return advertiseService(ops);
  }
 
  template<class MReq, class MRes>
  ServiceServer advertiseService(const std::string& service, bool(*srv_func)(MReq&, MRes&))
  {
    AdvertiseServiceOptions ops;
    ops.template init<MReq, MRes>(service, srv_func);
    return advertiseService(ops);
  }
 
  template<class MReq, class MRes>
  ServiceServer advertiseService(const std::string& service, bool(*srv_func)(ServiceEvent<MReq, MRes>&))
  {
    AdvertiseServiceOptions ops;
    ops.template initBySpecType<ServiceEvent<MReq, MRes> >(service, srv_func);
    return advertiseService(ops);
  }
 
  template<class MReq, class MRes>
  ServiceServer advertiseService(const std::string& service, const std::function<bool(MReq&, MRes&)>& callback,
                                 const VoidConstPtr& tracked_object = VoidConstPtr())
  {
    AdvertiseServiceOptions ops;
    ops.template init<MReq, MRes>(service, callback);
    ops.tracked_object = tracked_object;
    return advertiseService(ops);
  }
 
  template<class S>
  ServiceServer advertiseService(const std::string& service, const std::function<bool(S&)>& callback,
                                 const VoidConstPtr& tracked_object = VoidConstPtr())
  {
    AdvertiseServiceOptions ops;
    ops.template initBySpecType<S>(service, callback);
    ops.tracked_object = tracked_object;
    return advertiseService(ops);
  }
 
  ServiceServer advertiseService(AdvertiseServiceOptions& ops);
 
  // Versions of serviceClient()
 
  template<class MReq, class MRes>
  ServiceClient serviceClient(const std::string& service_name, bool persistent = false,
                              const M_string& header_values = M_string())
  {
    ServiceClientOptions ops;
    ops.template init<MReq, MRes>(service_name, persistent, header_values);
    return serviceClient(ops);
  }
 
  template<class Service>
  ServiceClient serviceClient(const std::string& service_name, bool persistent = false,
                              const M_string& header_values = M_string())
  {
    ServiceClientOptions ops;
    ops.template init<Service>(service_name, persistent, header_values);
    return serviceClient(ops);
  }
 
  ServiceClient serviceClient(ServiceClientOptions& ops);
 
  // Versions of createTimer()
 
  template<class Handler, class Obj>
  Timer createTimer(Rate r, Handler h, Obj o, bool oneshot = false, bool autostart = true) const
  {
    return createTimer(r.expectedCycleTime(), h, o, oneshot, autostart);
  }
 
  template<class T>
  Timer createTimer(Duration period, void(T::*callback)(const TimerEvent&) const, T* obj,
                    bool oneshot = false, bool autostart = true) const
  {
    return createTimer(period, std::bind(callback, obj, std::placeholders::_1), oneshot, autostart);
  }
 
  template<class T>
  Timer createTimer(Duration period, void(T::*callback)(const TimerEvent&), T* obj,
                    bool oneshot = false, bool autostart = true) const
  {
    return createTimer(period, std::bind(callback, obj, std::placeholders::_1), oneshot, autostart);
  }
 
  template<class T>
  Timer createTimer(Duration period, void(T::*callback)(const TimerEvent&), const std::shared_ptr<T>& obj,
                    bool oneshot = false, bool autostart = true) const
  {
    TimerOptions ops(period, std::bind(callback, obj.get(), std::placeholders::_1), 0);
    ops.tracked_object = obj;
    ops.oneshot = oneshot;
    ops.autostart = autostart;
    return createTimer(ops);
  }
 
  Timer createTimer(Duration period, const TimerCallback& callback, bool oneshot = false,
                    bool autostart = true) const;
 
  Timer createTimer(TimerOptions& ops) const;
 
  // Versions of createWallTimer()
 
  template<class T>
  WallTimer createWallTimer(WallDuration period, void(T::*callback)(const WallTimerEvent&), T* obj,
                            bool oneshot = false, bool autostart = true) const
  {
    return createWallTimer(period, std::bind(callback, obj, std::placeholders::_1), oneshot, autostart);
  }
 
  template<class T>
  WallTimer createWallTimer(WallDuration period, void(T::*callback)(const WallTimerEvent&),
                            const std::shared_ptr<T>& obj,
                            bool oneshot = false, bool autostart = true) const
  {
    WallTimerOptions ops(period, std::bind(callback, obj.get(), std::placeholders::_1), 0);
    ops.tracked_object = obj;
    ops.oneshot = oneshot;
    ops.autostart = autostart;
    return createWallTimer(ops);
  }
 
  WallTimer createWallTimer(WallDuration period, const WallTimerCallback& callback,
                            bool oneshot = false, bool autostart = true) const;
 
  WallTimer createWallTimer(WallTimerOptions& ops) const;
 
  void setParam(const std::string& key, const XmlRpc::XmlRpcValue& v) const;
  void setParam(const std::string& key, const std::string& s) const;
  void setParam(const std::string& key, const char* s) const;
  void setParam(const std::string& key, double d) const;
  void setParam(const std::string& key, int i) const;
  void setParam(const std::string& key, bool b) const;
 
  void setParam(const std::string& key, const std::vector<std::string>& vec) const;
  void setParam(const std::string& key, const std::vector<double>& vec) const;
  void setParam(const std::string& key, const std::vector<float>& vec) const;
  void setParam(const std::string& key, const std::vector<int>& vec) const;
  void setParam(const std::string& key, const std::vector<bool>& vec) const;
 
  void setParam(const std::string& key, const std::map<std::string, std::string>& map) const;
  void setParam(const std::string& key, const std::map<std::string, double>& map) const;
  void setParam(const std::string& key, const std::map<std::string, float>& map) const;
  void setParam(const std::string& key, const std::map<std::string, int>& map) const;
  void setParam(const std::string& key, const std::map<std::string, bool>& map) const;
 
  bool getParam(const std::string& key, std::string& s) const;
  bool getParam(const std::string& key, double& d) const;
  bool getParam(const std::string& key, float& f) const;
  bool getParam(const std::string& key, int& i) const;
  bool getParam(const std::string& key, bool& b) const;
  bool getParam(const std::string& key, XmlRpc::XmlRpcValue& v) const;
 
  bool getParam(const std::string& key, std::vector<std::string>& vec) const;
  bool getParam(const std::string& key, std::vector<double>& vec) const;
  bool getParam(const std::string& key, std::vector<float>& vec) const;
  bool getParam(const std::string& key, std::vector<int>& vec) const;
  bool getParam(const std::string& key, std::vector<bool>& vec) const;
 
  bool getParam(const std::string& key, std::map<std::string, std::string>& map) const;
  bool getParam(const std::string& key, std::map<std::string, double>& map) const;
  bool getParam(const std::string& key, std::map<std::string, float>& map) const;
  bool getParam(const std::string& key, std::map<std::string, int>& map) const;
  bool getParam(const std::string& key, std::map<std::string, bool>& map) const;
 
  bool getParamCached(const std::string& key, std::string& s) const;
  bool getParamCached(const std::string& key, double& d) const;
  bool getParamCached(const std::string& key, float& f) const;
  bool getParamCached(const std::string& key, int& i) const;
  bool getParamCached(const std::string& key, bool& b) const;
  bool getParamCached(const std::string& key, XmlRpc::XmlRpcValue& v) const;
 
  bool getParamCached(const std::string& key, std::vector<std::string>& vec) const;
  bool getParamCached(const std::string& key, std::vector<double>& vec) const;
  bool getParamCached(const std::string& key, std::vector<float>& vec) const;
  bool getParamCached(const std::string& key, std::vector<int>& vec) const;
  bool getParamCached(const std::string& key, std::vector<bool>& vec) const;
 
  bool getParamCached(const std::string& key, std::map<std::string, std::string>& map) const;
  bool getParamCached(const std::string& key, std::map<std::string, double>& map) const;
  bool getParamCached(const std::string& key, std::map<std::string, float>& map) const;
  bool getParamCached(const std::string& key, std::map<std::string, int>& map) const;
  bool getParamCached(const std::string& key, std::map<std::string, bool>& map) const;
 
  bool hasParam(const std::string& key) const;
  bool searchParam(const std::string& key, std::string& result) const;
  bool deleteParam(const std::string& key) const;
 
  bool getParamNames(std::vector<std::string>& keys) const;
 
  template<typename T>
  bool param(const std::string& param_name, T& param_val, const T& default_val) const
  {
    if (hasParam(param_name))
    {
      if (getParam(param_name, param_val))
      {
        return true;
      }
    }
 
    param_val = default_val;
    return false;
  }
 
  template<typename T>
  T param(const std::string& param_name, const T& default_val)
  {
      T param_val;
      param(param_name, param_val, default_val);
      return param_val;
  }
 
  void shutdown();
 
  bool ok() const;
 
private:
  struct no_validate { };
  // this is pretty awful, but required to preserve public interface (and make minimum possible changes)
  std::string resolveName(const std::string& name, bool remap, no_validate) const;
 
  void construct(const std::string& ns, bool validate_name);
  void destruct();
 
  void initRemappings(const M_string& remappings);
 
  std::string remapName(const std::string& name) const;
 
  std::string namespace_;
  std::string unresolved_namespace_;
  M_string remappings_;
  M_string unresolved_remappings_;
 
  CallbackQueueInterface* callback_queue_;
 
  NodeHandleBackingCollection* collection_;
 
  bool ok_;
};
 
}
 
#endif // ROSCPP_NODE_HANDLE_H