plugin.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009, 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_PLUGINLOADER_PLUGIN_H
#define RVE_PLUGINLOADER_PLUGIN_H

#include "class_entry.h"

#include <string>
#include <list>
#include <stdexcept>

#include <boost/shared_ptr.hpp>
#include <boost/signals.hpp>

#include <rve_dynlib/dynlib.h>

namespace YAML
{
class Node;
}

namespace rve_pluginloader
{

typedef std::map<std::string, std::string> M_string;

class Plugin;
struct PluginStatus
{
  PluginStatus(Plugin* p)
  : plugin(p)
  {}
  Plugin* plugin;
};
typedef boost::signal<void(const PluginStatus&)> PluginStatusSignal;

class Exception : public std::runtime_error
{
public:
  Exception(const std::string& str)
  : std::runtime_error(str)
  {}
};

class PluginParseException : public Exception
{
public:
  PluginParseException(const std::string& file, const std::string& error)
  : Exception("Unable to parse plugin description file [" + file + "]: " + error)
  {}
};

class LibraryLoadException : public Exception
{
public:
  LibraryLoadException(const std::string& library_name, const std::string& error)
  : Exception("Unable to load library [" + library_name + "]: " + error)
  {}
};

class LibraryDoesNotExistException : public Exception
{
public:
  LibraryDoesNotExistException(const std::string& library_name)
  : Exception("Library [" + library_name + "] does not exist on disk")
  {}
};

class NoPluginRegisterFunctionException : public Exception
{
public:
  NoPluginRegisterFunctionException(const std::string& library_name)
  : Exception("Library [" + library_name + "] does not have an rvePluginRegister(rve_pluginloader::TypeRegistry*) function!")
  {}
};

class PluginDoesNotContainClassException : public Exception
{
public:
  PluginDoesNotContainClassException(const std::string& package, const std::string& derived_class)
  : Exception("Plugin from package [" + package + "] does not contain class [" + derived_class + "]")
  {}
};

class OutstandingAllocationException : public Exception
{
public:
  OutstandingAllocationException(const std::string& str)
  : Exception(str)
  {}
};

class Plugin
{
public:
  Plugin();
  ~Plugin();

  void loadDescription(const std::string& description_path);
  void load();
  void unload();
  bool isLoaded();

  const std::string& getPackageName() const { return package_name_; }
  const std::string& getDescriptionPath() const { return description_path_; }
  const std::string& getName() { return name_; }

  PluginStatusSignal& getLoadingSignal() { return loading_signal_; }
  PluginStatusSignal& getLoadedSignal() { return loaded_signal_; }
  PluginStatusSignal& getUnloadingSignal() { return unloading_signal_; }
  PluginStatusSignal& getUnloadedSignal() { return unloaded_signal_; }

  YAML::Node& getDescription() { return *doc_; }

  const V_ClassEntry* getClassEntries(const std::string& base_class) const;
  const ClassEntryPtr& getClassEntry(const std::string& base_class, const std::string& derived_class) const;

  bool hasClass(const std::string& base_class, const std::string& derived_class) const;

  template<typename T>
  T* create(const std::string& base_class, const std::string& derived_class)
  {
    T* t = static_cast<T*>(create(base_class, derived_class));
    return t;
  }

  void* create(const std::string& base_class, const std::string& derived_class);

  template<typename T>
  boost::shared_ptr<T> createShared(const std::string& base_class, const std::string& derived_class)
  {
    return boost::static_pointer_cast<T>(createShared(base_class, derived_class));
  }

  boost::shared_ptr<void> createShared(const std::string& base_class, const std::string& derived_class);

  void destroy(void* mem);
  bool ownsAllocation(void* mem);

private:
  void unload(bool allow_throw);

  std::string description_path_;
  std::string package_name_;
  std::string package_path_;
  std::string library_path_;
  std::string name_;

  M_ClassEntry class_entries_;

  bool loaded_;

  rve_dynlib::Handle library_;

  PluginStatusSignal loading_signal_;
  PluginStatusSignal loaded_signal_;
  PluginStatusSignal unloading_signal_;
  PluginStatusSignal unloaded_signal_;

  YAML::Node* doc_;

  struct AllocationInfo
  {
    void* pointer;
    std::vector<void*> backtrace;
    std::string base_class;
    std::string derived_class;
  };
  typedef std::map<void*, AllocationInfo> M_AllocationInfo;
  M_AllocationInfo allocations_;
};
typedef boost::shared_ptr<Plugin> PluginPtr;
typedef std::list<PluginPtr> L_Plugin;

}

#endif // RVE_PLUGINLOADER_PLUGIN_MANAGER_H