client_context.cpp

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.
 */

#include <rve_render_client/client_context.h>
#include <rve_render_client/registry.h>
#include <rve_render_client/context_object.h>

#include <rve_rpc/client.h>

#include <ros/node_handle.h>

#include <boost/unordered_map.hpp>

#include <set>

namespace rve_render_client
{

struct ClientContext::Impl
{
  Impl(ClientContext* parent, const std::string& name, const ros::NodeHandle& nh);
  ~Impl();

  InterfaceHandle lookupInterface(const std::string& name) const;
  rve_interface_gen::Interface* getInterface(InterfaceHandle handle) const;
  rve_rpc::Client& getRPCClient() { return client_; }

  void addObject(ContextObject* obj);
  void removeObject(ContextObject* obj);
  bool hasObject(ContextObject* obj);

  void close();
  void reopen();
  bool isConnected()
  {
    return client_.isConnected();
  }

  ros::NodeHandle& getNodeHandle() { return nh_; }

  struct InterfaceInfo
  {
    rve_interface_gen::InterfacePtr interface;
    std::string name;
  };

  ClientContext* parent_;

  typedef boost::unordered_map<InterfaceHandle, InterfaceInfo> M_Interface;
  M_Interface interfaces_;
  uint32_t id_counter_;
  rve_rpc::Client client_;

  typedef std::vector<ContextObject*> V_ContextObject;
  V_ContextObject objects_;

  ros::NodeHandle nh_;
};

ClientContext::Impl::Impl(ClientContext* parent, const std::string& name, const ros::NodeHandle& nh)
: parent_(parent)
, id_counter_(0)
, client_(name, nh)
, nh_(nh)
{
  // grab all the currently available interfaces and create them
  V_string names;
  getProxyNames(names);
  V_string::iterator it = names.begin();
  V_string::iterator end = names.end();
  for (; it != end; ++it)
  {
    const std::string& name = *it;
    InterfaceInfo info;
    info.interface.reset(createProxy(name, client_), boost::bind(destroyProxy, name, _1));
    info.name = name;

    while (interfaces_.count(++id_counter_) > 0);

    interfaces_.insert(std::make_pair(id_counter_, info));
  }

  // TODO: do this async
  //client_.connectAsync();
  client_.connect();
}

ClientContext::Impl::~Impl()
{
  if (isConnected())
  {
    close();
  }
}

InterfaceHandle ClientContext::Impl::lookupInterface(const std::string& name) const
{
  M_Interface::const_iterator it = interfaces_.begin();
  M_Interface::const_iterator end = interfaces_.end();
  for (; it != end; ++it)
  {
    const InterfaceInfo& info = it->second;
    if (info.name == name)
    {
      return it->first;
    }
  }

  return NullHandle;
}

rve_interface_gen::Interface* ClientContext::Impl::getInterface(InterfaceHandle handle) const
{
  M_Interface::const_iterator it = interfaces_.find(handle);
  if (it == interfaces_.end())
  {
    return 0;
  }

  return it->second.interface.get();
}

void ClientContext::Impl::addObject(ContextObject* obj)
{
  objects_.push_back(obj);
  obj->create(parent_);
}

void ClientContext::Impl::removeObject(ContextObject* obj)
{
  obj->destroy(parent_);
  V_ContextObject::iterator it = std::find(objects_.begin(), objects_.end(), obj);
  ROS_ASSERT(it != objects_.end());
  objects_.erase(it);
}

bool ClientContext::Impl::hasObject(ContextObject* obj)
{
  V_ContextObject::iterator it = std::find(objects_.begin(), objects_.end(), obj);
  return it != objects_.end();
}

void ClientContext::Impl::close()
{
  // for each object call obj->destroy(this)
  std::for_each(objects_.begin(), objects_.end(), boost::bind(&ContextObject::destroy, _1, parent_));

  client_.flush();
  client_.disconnect();
}

void ClientContext::Impl::reopen()
{
  client_.connect();

  std::set<rve_common::UUID> left;
  V_ContextObject::iterator it = objects_.begin();
  V_ContextObject::iterator end = objects_.end();
  for (; it != end; ++it)
  {
    ContextObject* obj = *it;
    left.insert(obj->getID());
  }

  // horribly inefficient, but easy.  Wait for all dependencies of an object
  // to be created before creating said object.
  std::vector<rve_common::UUID> deps;
  while (!left.empty())
  {
    deps.clear();
    it = objects_.begin();
    for (; it != end; ++it)
    {
      ContextObject* obj = *it;
      bool ready = true;
      obj->getDependencies(deps);
      for (size_t i = 0; i < deps.size(); ++i)
      {
        if (left.count(deps[i]) > 0)
        {
          ready = false;
          break;
        }
      }

      if (ready)
      {
        obj->create(parent_);
        left.erase(obj->getID());
      }
    }
  }
}


ClientContext::ClientContext(const std::string& name, const ros::NodeHandle& nh)
: impl_(new Impl(this, name, nh))
{
}

ClientContext::~ClientContext()
{
}

InterfaceHandle ClientContext::lookupInterface(const std::string& name) const
{
  return impl_->lookupInterface(name);
}

rve_interface_gen::Interface* ClientContext::getInterface(InterfaceHandle handle) const
{
  return impl_->getInterface(handle);
}

rve_rpc::Client& ClientContext::getRPCClient()
{
  return impl_->getRPCClient();
}

void ClientContext::addObject(ContextObject* obj)
{
  impl_->addObject(obj);
}

void ClientContext::removeObject(ContextObject* obj)
{
  impl_->removeObject(obj);
}

void ClientContext::close()
{
  impl_->close();
}

void ClientContext::reopen()
{
  impl_->reopen();
}

bool ClientContext::isConnected()
{
  return impl_->isConnected();
}

bool ClientContext::hasObject(ContextObject* obj)
{
  return impl_->hasObject(obj);
}

ros::NodeHandle& ClientContext::getNodeHandle()
{
  return impl_->getNodeHandle();
}

}