class_loader.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012, 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 CLASS_LOADER_CLASS_LOADER_H_DEFINED
#define CLASS_LOADER_CLASS_LOADER_H_DEFINED

#include <boost/shared_ptr.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/bind.hpp>
#include <vector>
#include <string>
#include <console_bridge/console.h>
#include "class_loader/class_loader_register_macro.h"
#include "class_loader/class_loader_core.h"
#include "class_loader/console_bridge_compatibility.h"

#if __cplusplus >= 201103L
#  include<memory>
#  include<functional>
#endif

namespace class_loader
{

std::string systemLibrarySuffix();

class ClassLoader
{
  public:
#if __cplusplus >= 201103L
    template<typename Base>
    using DeleterType = std::function<void (Base *)>;

    template<typename Base>
    using UniquePtr = std::unique_ptr<Base, DeleterType<Base>>;
#endif

    ClassLoader(const std::string& library_path, bool ondemand_load_unload = false);

    virtual ~ClassLoader();

    template <class Base>
    std::vector<std::string> getAvailableClasses()
    {
      return(class_loader::class_loader_private::getAvailableClasses<Base>(this));
    }

    std::string getLibraryPath(){return(library_path_);}

    template <class Base>
    boost::shared_ptr<Base> createInstance(const std::string& derived_class_name)
    {
      return boost::shared_ptr<Base>(createRawInstance<Base>(derived_class_name, true),
                                     boost::bind(&ClassLoader::onPluginDeletion<Base>, this, _1));
    }

#if __cplusplus >= 201103L

    template<class Base>
    UniquePtr<Base> createUniqueInstance(const std::string& derived_class_name)
    {
      Base* raw = createRawInstance<Base>(derived_class_name, true);
      return std::unique_ptr<Base, DeleterType<Base>>(raw, boost::bind(&ClassLoader::onPluginDeletion<Base>, this, _1));
    }
#endif

    template <class Base>
    Base* createUnmanagedInstance(const std::string& derived_class_name)
    {
      return createRawInstance<Base>(derived_class_name, false);
    }

    template <class Base>
    bool isClassAvailable(const std::string& class_name)
    {
      std::vector<std::string> available_classes = getAvailableClasses<Base>();
      return(std::find(available_classes.begin(), available_classes.end(), class_name) != available_classes.end());
    }

    bool isLibraryLoaded();

    bool isLibraryLoadedByAnyClassloader();

    bool isOnDemandLoadUnloadEnabled(){return(ondemand_load_unload_);}

    void loadLibrary();

    int unloadLibrary();

  private:
    template <class Base>
    void onPluginDeletion(Base* obj)
    {
      CONSOLE_BRIDGE_logDebug("class_loader::ClassLoader: Calling onPluginDeletion() for obj ptr = %p.\n", obj);
      if(obj)
      {
        boost::recursive_mutex::scoped_lock lock(plugin_ref_count_mutex_);
        delete(obj);
        plugin_ref_count_ = plugin_ref_count_ - 1;
        assert(plugin_ref_count_ >= 0);
        if(plugin_ref_count_ == 0 && isOnDemandLoadUnloadEnabled())
        {
          if(!ClassLoader::hasUnmanagedInstanceBeenCreated())
            unloadLibraryInternal(false);
          else
            CONSOLE_BRIDGE_logWarn("class_loader::ClassLoader: Cannot unload library %s even though last shared pointer went out of scope. This is because createUnmanagedInstance was used within the scope of this process, perhaps by a different ClassLoader. Library will NOT be closed.", getLibraryPath().c_str());
        }
      }
    }

    template <class Base>
    Base* createRawInstance(const std::string& derived_class_name, bool managed)
    {
      if (!managed)
        has_unmananged_instance_been_created_ = true;

      if (managed && ClassLoader::hasUnmanagedInstanceBeenCreated() && isOnDemandLoadUnloadEnabled())
        CONSOLE_BRIDGE_logInform("class_loader::ClassLoader: An attempt is being made to create a managed plugin instance (i.e. boost::shared_ptr), however an unmanaged instance was created within this process address space. This means libraries for the managed instances will not be shutdown automatically on final plugin destruction if on demand (lazy) loading/unloading mode is used.");

      if (!isLibraryLoaded())
        loadLibrary();

      Base* obj = class_loader::class_loader_private::createInstance<Base>(derived_class_name, this);
      assert(obj != NULL); //Unreachable assertion if createInstance() throws on failure

      if (managed)
      {
        boost::recursive_mutex::scoped_lock lock(plugin_ref_count_mutex_);
        plugin_ref_count_ = plugin_ref_count_ + 1;
      }

      return obj;
    }

    static bool hasUnmanagedInstanceBeenCreated();

    int unloadLibraryInternal(bool lock_plugin_ref_count);

  private:

    bool ondemand_load_unload_;
    std::string library_path_;
    int load_ref_count_;
    boost::recursive_mutex load_ref_count_mutex_;
    int plugin_ref_count_;
    boost::recursive_mutex plugin_ref_count_mutex_;
    static bool has_unmananged_instance_been_created_;
};

}


#endif