ModuleManager.h

[詳解]

// -*- C++ -*-
#ifndef RTC_MODULEMANAGER_H
#define RTC_MODULEMANAGER_H
 
 
// ACE includes
#include <coil/DynamicLib.h>
 
// RTC includes
#include <rtm/Manager.h>
#include <coil/Properties.h>
#include <rtm/ObjectManager.h>
 
// STL includes
#include <string>
#include <utility>
#include <vector>
#include <map>
 
#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"
 
namespace RTC
{
  class ModuleManager
  {
    using vProperties = std::vector<coil::Properties>;
  public:
    explicit ModuleManager(coil::Properties& prop);
 
    ~ModuleManager();
 
    struct Error
    {
      explicit Error(std::string  _reason)
        : reason(std::move(_reason)) {}
      std::string reason;
    };
 
    struct NotFound
    {
      explicit NotFound(std::string  _name)
        : name(std::move(_name)) {}
      std::string name;
    };
 
    struct FileNotFound
      : public NotFound
    {
      explicit FileNotFound(const std::string& _name)
        : NotFound(_name) {}
    };
 
    struct ModuleNotFound
      : public NotFound
    {
      explicit ModuleNotFound(const std::string& _name)
        : NotFound(_name) {}
    };
 
    struct SymbolNotFound
      : public NotFound
    {
      explicit SymbolNotFound(const std::string& _name)
        : NotFound(_name) {}
    };
 
    struct NotAllowedOperation
      : public Error
    {
      explicit NotAllowedOperation(const std::string& _reason)
        : Error(_reason) {}
    };
 
    struct InvalidArguments
      : public Error
    {
      explicit InvalidArguments(const std::string& _reason)
        : Error(_reason) {}
    };
 
    struct InvalidOperation
      : public Error
    {
      explicit InvalidOperation(const std::string& _reason)
        : Error(_reason) {}
    };
    using ModuleInitFunc = void (*)(Manager*);
 
    std::string load(const std::string& file_name);
    std::string load(coil::Properties& prop);
 
 
    std::string load(const std::string& file_name,
                     const std::string& init_func);
    std::string load(coil::Properties& prop,
        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);
 
    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, const std::string& lang);
 
    void getModuleProfiles(const std::string& lang,
                           const coil::vstring& modules, vProperties& modprops);
 
    Logger rtclog;
 
    struct DLLEntity
    {
      coil::Properties properties;
      coil::DynamicLib dll;
    };
 
    using StringVector = std::vector<std::string>;
    using StringVectorItr = StringVector::iterator;
    using StringVectorConstItr = StringVector::const_iterator;
 
    using DllMap = std::vector<DLLEntity>;
    using DllMapItr = DllMap::iterator;
    using DllMapConstItr = DllMap::const_iterator;
 
 
    coil::Properties& m_properties;
 
    class DllPred
    {
      std::string m_filepath;
    public:
      explicit DllPred(const char* filepath) 
      {
        m_filepath = coil::replaceString(filepath, "\\", "/");
        m_filepath = coil::replaceString(m_filepath, "//", "/");
      }
      explicit DllPred(const DLLEntity* dll)
      {
        m_filepath = coil::replaceString(dll->properties["file_path"], "\\", "/");
        m_filepath = coil::replaceString(m_filepath, "//", "/");
      }
      bool operator()(DLLEntity* dllentity)
      {
        std::string file_path = coil::replaceString(
          dllentity->properties.getProperty("file_path"), "\\", "/");
        file_path = coil::replaceString(file_path, "//", "/");
        return m_filepath == 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;
 
    coil::vstring m_supported_languages;
 
    class UnloadPred
    {
    public:
      UnloadPred() = default;
      void operator()(DLLEntity* dll)
      {
        dll->dll.close();
        delete dll;
      }
    };
 
    vProperties m_modprofs;
    std::map<std::string, coil::vstring> m_loadfailmods;
 
  };   // class ModuleManager
} // namespace RTC
 
#endif  // RTC_MODULEMANAGER_H