Parameter.hpp

#ifndef _ASTRA_ROS_PARAMETER_HPP_
#define _ASTRA_ROS_PARAMETER_HPP_
 
#include <functional>
#include <boost/optional.hpp>
 
#include <mutex>
 
namespace astra_ros
{
  template<typename T>
  class ParameterImpl
  {
  public:
    typedef T ValueType;
    typedef std::function<bool (const T &value, const T &previous)> OnChange;
 
    ParameterImpl()
      : value_(T())
    {
    }
 
    ParameterImpl(const T &value)
      : value_(value)
    {
    }
    
    bool set(const T &value) noexcept
    {
      std::lock_guard<std::mutex> lock(mutex_);
 
      if (on_change_)
      {
        if ((*on_change_)(value, value_))
        {
          // Accept the changes
          value_ = value;
          return true;
        }
 
        return false;
      }
 
      // No handler, always accept the change
      value_ = value;
      return true;
    }
 
    const T &get() const noexcept
    {
      std::lock_guard<std::mutex> lock(mutex_);
      return value_;
    }
 
    void setOnChangeHandler(const boost::optional<OnChange> &on_change)
    {
      on_change_ = on_change;
    }
 
    const boost::optional<OnChange> &getOnChangeHandler() const
    {
      return on_change_;
    }
 
  private:
    mutable std::mutex mutex_;
    
    T value_;
    boost::optional<OnChange> on_change_;
  };
 
  // Parameter wraps a value to make it "live"
  // A listener can register a callback when the value changes
  template<typename T>
  class Parameter
  {
  public:
    typedef typename ParameterImpl<T>::ValueType ValueType;
    typedef typename ParameterImpl<T>::OnChange OnChange;
 
    Parameter()
      : impl_(std::make_shared<ParameterImpl<T>>())
    {
    }
 
    Parameter(const T &value)
      : impl_(std::make_shared<ParameterImpl<T>>(value))
    {
    }
 
    bool set(const T &value)
    {
      return impl_->set(value);
    }
 
    const T &get() const
    {
      return impl_->get();
    }
 
    const T &operator *() const
    {
      return get();
    }
 
    void setOnChangeHandler(const boost::optional<OnChange> &on_change)
    {
      impl_->setOnChangeHandler(on_change);
    }
 
    template<typename F, typename... Args>
    void bindOnChangeHandler(F &&f, Args &&...args)
    {
      setOnChangeHandler(bind(f, args...));
    }
 
    const boost::optional<OnChange> &getOnChangeHandler() const
    {
      return impl_->getOnChangeHandler();
    }
 
    template<typename F, typename... Args>
    static OnChange bind(F &&f, Args &&...args)
    {
      return OnChange(std::bind(f, args..., std::placeholders::_1, std::placeholders::_2));
    }
 
  private:
    std::shared_ptr<ParameterImpl<T>> impl_;
  };
 
}
 
 
 
#endif