property_node.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010, Willow Garage, Inc.
 * All rights reserved.
 *
 * 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 name of the 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 RVE_PROPERTIES_PROPERTY_NODE_H
#define RVE_PROPERTIES_PROPERTY_NODE_H

#include "forwards.h"
#include "property_value.h"

#include <string>
#include <map>
#include <vector>

#include <ros/types.h>
#include <ros/assert.h>

#include <stdexcept>

#include <boost/thread/recursive_mutex.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/function.hpp>

namespace ros
{
class CallbackQueueInterface;
}

namespace rve_properties
{

class BadPathException : public std::runtime_error
{
public:
  BadPathException(const std::string& error)
  : std::runtime_error(error)
  {}
};

struct PropertyData
{
  PropertyData()
  : metadata(0)
  {}

  PropertyValue value;
  std::map<std::string, std::string>* metadata;         // Only allocate if necessary
};

class PropertyNode;
typedef boost::shared_ptr<PropertyNode> PropertyNodePtr;
typedef std::vector<PropertyNodePtr> V_PropertyNode;

typedef boost::function<void(const PropertyNodePtr&, const std::string&, PropertyChangeType)> PropertyChangeCallback;

class PropertyNode : public boost::enable_shared_from_this<PropertyNode>
{
public:
  PropertyNode();
  ~PropertyNode();

  PropertyNodePtr getNode(const std::string& path, bool create_if_necessary = true);
  void setNode(const std::string& path, const PropertyNodePtr& node);
  void removeNode(const std::string& path);
  bool exists(const std::string& path);
  bool hasValue();

  template<typename T>
  void set(T t)
  {
    {
      boost::recursive_mutex::scoped_lock lock(mutex_);
      data_.value.set(t);
    }

    fireChanged(shared_from_this(), "", PropertyChanged);
  }

  template<typename T>
  T get()
  {
    boost::recursive_mutex::scoped_lock lock(mutex_);
    return data_.value.get<T>();
  }

  template<typename T>
  void get(T& t)
  {
    boost::recursive_mutex::scoped_lock lock(mutex_);
    data_.value.get(t);
  }

  template<typename T>
  void get(T& t, T default_value)
  {
    boost::recursive_mutex::scoped_lock lock(mutex_);
    data_.value.get(t, default_value);
  }

  template<typename T>
  void set(const std::string& path, T t)
  {
    PropertyNodePtr n = getNode(path);
    n->set(t);
  }

  template<typename T>
  T get(const std::string& path)
  {
    PropertyNodePtr n = getNode(path);
    return n->get<T>();
  }

  template<typename T>
  void get(const std::string& path, T& t)
  {
    PropertyNodePtr n = getNode(path);
    n->get(t);
  }

  template<typename T>
  void get(const std::string& path, T& t, T default_value)
  {
    PropertyNodePtr n = getNode(path);
    n->get(t, default_value);
  }

  void addChangeCallback(const PropertyChangeCallback& cb, void* owner, ros::CallbackQueueInterface* callback_queue);
  void removeChangeCallback(void* owner);

  PropertyNodePtr getParent();

  PropertyValue getValue() { return data_.value; }
  std::string getName() { return name_; }

  template<typename F>
  void visitChildren(F& f, bool recurse = true, const std::string& base_path = std::string())
  {
    boost::recursive_mutex::scoped_lock lock(mutex_);
    if (!children_)
    {
      return;
    }

    std::string new_base;
    if (name_.empty())
    {
      ROS_ASSERT(!parent_);
      new_base = base_path;
    }
    else
    {
      if (base_path.empty())
      {
        new_base = name_;
      }
      else
      {
        new_base = base_path + "/" + name_;
      }
    }

    M_PropertyNode::iterator it = children_->begin();
    M_PropertyNode::iterator end = children_->end();
    for (; it != end; ++it)
    {
      const PropertyNodePtr& child = it->second;
      std::string full_child_path = new_base.empty() ? it->first : new_base + "/" + it->first;
      f(full_child_path, child);
      if (recurse)
      {
        child->visitChildren(f, recurse, new_base);
      }
    }
  }

  void getChildren(V_PropertyNode& out_children)
  {
    out_children.clear();

    boost::recursive_mutex::scoped_lock lock(mutex_);
    if (!children_)
    {
      return;
    }

    out_children.reserve(children_->size());

    M_PropertyNode::iterator it = children_->begin();
    M_PropertyNode::iterator end = children_->end();
    for (; it != end; ++it)
    {
      const PropertyNodePtr& child = it->second;
      out_children.push_back(child);
    }
  }

private:
  PropertyNode(const PropertyNode&);
  PropertyNode& operator=(const PropertyNode&);

  std::pair<PropertyNodePtr, std::string> getParentOf(const std::string& path);

  void setChild(const std::string& name, const PropertyNodePtr& node);
  void childChanged(const PropertyNodePtr& child, const std::string& child_path, PropertyChangeType type);
  void fireChanged(const PropertyNodePtr& node, const std::string& path, PropertyChangeType type);

  void setParent(PropertyNode* parent, const std::string& name, bool remove_from_previous);

  boost::recursive_mutex mutex_;  // TODO do we want to remove exposure of boost/thread/recursive_mutex.hpp from this header?
  PropertyData data_;

  std::string name_;
  PropertyNode* parent_;

  typedef std::map<std::string, PropertyNodePtr> M_PropertyNode;
  M_PropertyNode* children_;  // Only allocate if necessary

  struct ChangeCallback
  {
    PropertyChangeCallback cb;
    void* owner;
    ros::CallbackQueueInterface* queue;
  };
  typedef std::vector<ChangeCallback> V_ChangeCallback;
  V_ChangeCallback* change_callbacks_;  // Only allocate if necessary
};

}

#endif // RVE_PROPERTIES_PROPERTY_NODE_H