class_loader_core.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_private_H_DEFINED
#define class_loader_private_H_DEFINED

#include <Poco/SharedLibrary.h>
#include <boost/thread/recursive_mutex.hpp>
//#include <vector>
#include <map>
#include <typeinfo>
#include <string>
#include "class_loader/meta_object.h"
#include "class_loader/class_loader_exceptions.h"
#include <cstdio>
 
namespace class_loader
{

class ClassLoader; //Forward declaration

namespace class_loader_private
{

//Typedefs
/*****************************************************************************/
typedef std::string LibraryPath;
typedef std::string ClassName;
typedef std::string BaseClassName;
typedef std::map<ClassName, class_loader_private::AbstractMetaObjectBase*> FactoryMap;
typedef std::map<BaseClassName, FactoryMap> BaseToFactoryMapMap;
typedef std::pair<LibraryPath, Poco::SharedLibrary*> LibraryPair;
typedef std::vector<LibraryPair> LibraryVector;
typedef std::vector<AbstractMetaObjectBase*> MetaObjectVector;

//Debug 
/*****************************************************************************/
void printDebugInfoToScreen();

//Global storage
/*****************************************************************************/

BaseToFactoryMapMap& getGlobalPluginBaseToFactoryMapMap();

LibraryVector& getLoadedLibraryVector();

std::string getCurrentlyLoadingLibraryName();

void setCurrentlyLoadingLibraryName(const std::string& library_name);


ClassLoader* getCurrentlyActiveClassLoader();

void setCurrentlyActiveClassLoader(ClassLoader* loader);


FactoryMap& getFactoryMapForBaseClass(const std::string& typeid_base_class_name);

template <typename Base>
FactoryMap& getFactoryMapForBaseClass()
{
    return(getFactoryMapForBaseClass(typeid(Base).name()));
}

boost::recursive_mutex& getLoadedLibraryVectorMutex();
boost::recursive_mutex& getPluginBaseToFactoryMapMapMutex();

bool hasANonPurePluginLibraryBeenOpened();

void hasANonPurePluginLibraryBeenOpened(bool hasIt);

//Plugin Functions
/*****************************************************************************/

template <typename Derived, typename Base> 
void registerPlugin(const std::string& class_name, const std::string& base_class_name)
{
  //Note: This function will be automatically invoked when a dlopen() call
  //opens a library. Normally it will happen within the scope of loadLibrary(),
  //but that may not be guaranteed.
  logDebug("class_loader::class_loader_private: Registering plugin factory for class = %s, ClassLoader* = %p and library name %s.", class_name.c_str(), getCurrentlyActiveClassLoader(), getCurrentlyLoadingLibraryName().c_str());

  if(getCurrentlyActiveClassLoader() == NULL)
  {
    logDebug("class_loader::class_loader_private: ALERT!!! A library containing plugins has been opened through a means other than through the class_loader or pluginlib package. This can happen if you build plugin libraries that contain more than just plugins (i.e. normal code your app links against). This inherently will trigger a dlopen() prior to main() and cause problems as class_loader is not aware of plugin factories that autoregister under the hood. The class_loader package can compensate, but you may run into namespace collision problems (e.g. if you have the same plugin class in two different libraries and you load them both at the same time). The biggest problem is that library can now no longer be safely unloaded as the ClassLoader does not know when non-plugin code is still in use. In fact, no ClassLoader instance in your application will be unable to unload any library once a non-pure one has been opened. Please refactor your code to isolate plugins into their own libraries.");
    hasANonPurePluginLibraryBeenOpened(true);    
  }

  //Create factory
  class_loader_private::AbstractMetaObject<Base>* new_factory = new class_loader_private::MetaObject<Derived, Base>(class_name, base_class_name);
  new_factory->addOwningClassLoader(getCurrentlyActiveClassLoader());
  new_factory->setAssociatedLibraryPath(getCurrentlyLoadingLibraryName());


  //Add it to global factory map map
  getPluginBaseToFactoryMapMapMutex().lock();
  FactoryMap& factoryMap = getFactoryMapForBaseClass<Base>();
  if(factoryMap.find(class_name) != factoryMap.end())
    logWarn("class_loader::class_loader_private: SEVERE WARNING!!! A namespace collision has occured with plugin factory for class %s. New factory will OVERWRITE existing one. This situation occurs when libraries containing plugins are directly linked against an executable (the one running right now generating this message). Please separate plugins out into their own library or just don't link against the library and use either class_loader::ClassLoader/MultiLibraryClassLoader to open.", class_name.c_str());
  factoryMap[class_name] = new_factory;
  getPluginBaseToFactoryMapMapMutex().unlock();

  logDebug("class_loader::class_loader_private: Registration of %s complete (Metaobject Address = %p)", class_name.c_str(), new_factory);
}

template <typename Base> 
Base* createInstance(const std::string& derived_class_name, ClassLoader* loader)
{
  AbstractMetaObject<Base>* factory = NULL;
  
  getPluginBaseToFactoryMapMapMutex().lock();
  FactoryMap& factoryMap = getFactoryMapForBaseClass<Base>();
  if(factoryMap.find(derived_class_name) != factoryMap.end())
    factory = dynamic_cast<class_loader_private::AbstractMetaObject<Base>*>(factoryMap[derived_class_name]);
  else
  {
    logError("class_loader::class_loader_private: No metaobject exists for class type %s.", derived_class_name.c_str());
  }
  getPluginBaseToFactoryMapMapMutex().unlock();

  Base* obj = NULL;
  if(factory != NULL && factory->isOwnedBy(loader))
    obj = factory->create();

  if(obj == NULL) //Was never created
  {
    if(factory && factory->isOwnedBy(NULL))
    {
      logDebug("class_loader::class_loader_private: ALERT!!! A metaobject (i.e. factory) exists for desired class, but has no owner. This implies that the library containing the class was dlopen()ed by means other than through the class_loader interface. This can happen if you build plugin libraries that contain more than just plugins (i.e. normal code your app links against) -- that intrinsically will trigger a dlopen() prior to main(). You should isolate your plugins into their own library, otherwise it will not be possible to shutdown the library!");

      obj = factory->create();
    }
    else
      throw(class_loader::CreateClassException("Could not create instance of type " + derived_class_name));
  }

  logDebug("class_loader::class_loader_private: Created instance of type %s and object pointer = %p", (typeid(obj).name()), obj);

  return(obj);
}

template <typename Base> 
std::vector<std::string> getAvailableClasses(ClassLoader* loader)
{
  boost::recursive_mutex::scoped_lock lock(getPluginBaseToFactoryMapMapMutex());

  FactoryMap& factory_map = getFactoryMapForBaseClass<Base>();
  std::vector<std::string> classes;
  std::vector<std::string> classes_with_no_owner;

  for(FactoryMap::const_iterator itr = factory_map.begin(); itr != factory_map.end(); ++itr)
  {
    AbstractMetaObjectBase* factory = itr->second;
    if(factory->isOwnedBy(loader))
      classes.push_back(itr->first);
    else if(factory->isOwnedBy(NULL))
      classes_with_no_owner.push_back(itr->first);
  }

  //Added classes not associated with a class loader (Which can happen through
  //an unexpected dlopen() to the library)
  classes.insert(classes.end(), classes_with_no_owner.begin(),  classes_with_no_owner.end());
  return(classes);
}

std::vector<std::string> getAllLibrariesUsedByClassLoader(const ClassLoader* loader);

bool isLibraryLoaded(const std::string& library_path, ClassLoader* loader);

bool isLibraryLoadedByAnybody(const std::string& library_path);

void loadLibrary(const std::string& library_path, ClassLoader* loader);

void unloadLibrary(const std::string& library_path, ClassLoader* loader);


} //End namespace class_loader_private
} //End namespace class_loader

#endif