ModuleManager.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_MODULEMANAGER_H
#define RTC_MODULEMANAGER_H

// STL includes
#include <string>
#include <vector>
#include <map>

// ACE includes
#include <coil/DynamicLib.h>

// RTC includes
#include <rtm/Manager.h>
#include <coil/Properties.h>
#include <rtm/ObjectManager.h>


#define CONFIG_EXT    "manager.modules.config_ext"
#define CONFIG_PATH   "manager.modules.config_path"
#define DETECT_MOD    "manager.modules.detect_loadable"
#define MOD_LOADPTH   "manager.modules.load_path"
#define INITFUNC_SFX  "manager.modules.init_func_suffix"
#define INITFUNC_PFX  "manager.modules.init_func_prefix"
#define ALLOW_ABSPATH "manager.modules.abs_path_allowed"
#define ALLOW_URL     "manager.modules.download_allowed"
#define MOD_DWNDIR    "manager.modules.download_dir"
#define MOD_DELMOD    "manager.modules.download_cleanup"
#define MOD_PRELOAD   "manager.modules.preload"

#ifdef WIN32
#pragma warning( disable : 4290 )
#endif

namespace RTC
{
  class ModuleManager
  {
    typedef std::vector<coil::Properties> vProperties;
  public:
    ModuleManager(coil::Properties& prop);
    
    ~ModuleManager(void);
    
    struct Error
    {
      Error(const std::string& _reason)
        : reason(_reason) {}
      std::string reason;
    };
    
    struct NotFound
    {
      NotFound(const std::string& _name)
        : name(_name) {}
      std::string name;
    };
    
    struct FileNotFound
      : public NotFound
    {
      FileNotFound(const std::string& _name)
        : NotFound(_name) {}
    };
    
    struct ModuleNotFound
      : public NotFound
    {
      ModuleNotFound(const std::string& _name)
        : NotFound(_name) {}
    };
    
    struct SymbolNotFound
      : public NotFound
    {
      SymbolNotFound(const std::string& _name)
        : NotFound(_name) {}
    };
    
    struct NotAllowedOperation
      : public Error
    {
      NotAllowedOperation(const std::string& _reason)
        : Error(_reason) {}
    };
    
    struct InvalidArguments
      : public Error
    {
      InvalidArguments(const std::string& _reason)
        : Error(_reason) {}
    };
    
    struct InvalidOperation
      : public Error
    {
      InvalidOperation(const std::string& _reason)
        : Error(_reason) {}
    };
    typedef void (*ModuleInitFunc)(Manager*);
    
    std::string load(const std::string& file_name);
    
    std::string load(const std::string& file_name,
                     const std::string& init_func);
    
    void unload(const std::string& file_name);
    
    void unloadAll();
    
    void* symbol(const std::string& file_name, const std::string& func_name)
      throw (ModuleNotFound, SymbolNotFound);
    
    void setLoadpath(const std::vector<std::string>& load_path);
    
    inline std::vector<std::string> getLoadPath()
    {
      return m_loadPath;
    }
    
    void addLoadpath(const std::vector<std::string>& load_path);
    
    std::vector<coil::Properties> getLoadedModules();
    
    std::vector<coil::Properties> getLoadableModules();

    inline void allowAbsolutePath()
    {
      m_absoluteAllowed = true;
    }
    
    inline void disallowAbsolutePath()
    {
      m_absoluteAllowed = false;
    }
    
    inline void allowModuleDownload()
    {
      m_downloadAllowed = true;
    }
    
    inline void disallowModuleDownload()
    {
      m_downloadAllowed = false;
    }
    
    std::string findFile(const std::string& fname,
                         const std::vector<std::string>& load_path);
    
  bool fileExist(const std::string& filename);
    
    std::string getInitFuncName(const std::string& file_path);
    
  protected:
    void removeInvalidModules();
    
    void getModuleList(const std::string& lang, coil::vstring& modules);

    void addNewFile(const std::string& fpath, coil::vstring& modules);

    void getModuleProfiles(const std::string& lang,
                           const coil::vstring& modules, vProperties& modprops);

    Logger rtclog;

    struct DLLEntity
    {
      coil::Properties properties;
      coil::DynamicLib dll;
    };
    
    typedef std::vector<std::string>     StringVector;
    typedef StringVector::iterator       StringVectorItr;
    typedef StringVector::const_iterator StringVectorConstItr;
    
    typedef std::vector<DLLEntity>    DllMap;
    typedef DllMap::iterator           DllMapItr;
    typedef DllMap::const_iterator     DllMapConstItr;

    
    coil::Properties& m_properties;
    
    class DllPred
    {
      std::string m_filepath;
    public:
      DllPred(const char* filepath) : m_filepath(filepath) {}
      DllPred(const DLLEntity* dll) : m_filepath(dll->properties["file_path"]) {}
      bool operator()(DLLEntity* dllentity)
      {
        return m_filepath == dllentity->properties.getProperty("file_path");
      }
    };
    ObjectManager<const char*, DLLEntity, DllPred> m_modules;
    
    StringVector m_loadPath;
    StringVector m_configPath;
    bool m_downloadAllowed;
    bool m_absoluteAllowed;
    
    std::string m_initFuncSuffix;

    std::string m_initFuncPrefix;

    class UnloadPred
    {
    public:
      UnloadPred(){}
      void operator()(DLLEntity* dll)
      {
        dll->dll.close();
        delete dll;
      }
    };

    vProperties m_modprofs;

  };   // class ModuleManager
};     // namespace RTC  

#ifdef WIN32
#pragma warning( default : 4290 )
#endif

#endif // RTC_MODULEMANAGER_H