comparison vamp-sdk/hostext/PluginLoader.cpp @ 69:3456fe86d385

* Switch PluginLoader to an m_impl structure to make it generally nicer

 
 namespace Vamp {
 	
 namespace HostExt {
 
+class PluginLoader::Impl
+{
+public:
+    virtual ~Impl() { }
+
+    PluginKeyList listPlugins();
+
+    Plugin *loadPlugin(PluginKey key,
+                       float inputSampleRate,
+                       int adapterFlags);
+
+    PluginKey composePluginKey(string libraryName, string identifier);
+
+    PluginCategoryHierarchy getPluginCategory(PluginKey key);
+
+    std::string getLibraryPathForPlugin(PluginKey key);
+
+protected:
+    class PluginDeletionNotifyAdapter : public PluginWrapper {
+    public:
+        PluginDeletionNotifyAdapter(Plugin *plugin, Impl *loader);
+        virtual ~PluginDeletionNotifyAdapter();
+    protected:
+        Impl *m_loader;
+    };
+
+    virtual void pluginDeleted(PluginDeletionNotifyAdapter *adapter);
+
+    std::map<PluginKey, std::string> m_pluginLibraryNameMap;
+    void generateLibraryMap();
+
+    std::map<PluginKey, PluginCategoryHierarchy> m_taxonomy;
+    void generateTaxonomy();
+
+    std::map<Plugin *, void *> m_pluginLibraryHandleMap;
+
+    void *loadLibrary(std::string path);
+    void unloadLibrary(void *handle);
+    void *lookupInLibrary(void *handle, const char *symbol);
+
+    std::string splicePath(std::string a, std::string b);
+    std::vector<std::string> listFiles(std::string dir, std::string ext);
+};
+
 PluginLoader *
 PluginLoader::m_instance = 0;
 
 PluginLoader::PluginLoader()
 {
+    m_impl = new Impl();
 }
 
 PluginLoader::~PluginLoader()
 {
+    delete m_impl;
 }
 
 PluginLoader *
 PluginLoader::getInstance()
 {

     return m_instance;
 }
 
 vector<PluginLoader::PluginKey>
 PluginLoader::listPlugins() 
+{
+    return m_impl->listPlugins();
+}
+
+Plugin *
+PluginLoader::loadPlugin(PluginKey key,
+                         float inputSampleRate,
+                         int adapterFlags)
+{
+    return m_impl->loadPlugin(key, inputSampleRate, adapterFlags);
+}
+
+PluginLoader::PluginKey
+PluginLoader::composePluginKey(string libraryName, string identifier) 
+{
+    return m_impl->composePluginKey(libraryName, identifier);
+}
+
+PluginLoader::PluginCategoryHierarchy
+PluginLoader::getPluginCategory(PluginKey key)
+{
+    return m_impl->getPluginCategory(key);
+}
+
+string
+PluginLoader::getLibraryPathForPlugin(PluginKey key)
+{
+    return m_impl->getLibraryPathForPlugin(key);
+}
+
+vector<PluginLoader::PluginKey>
+PluginLoader::Impl::listPlugins() 
 {
     if (m_pluginLibraryNameMap.empty()) generateLibraryMap();
 
     vector<PluginKey> plugins;
     for (map<PluginKey, string>::iterator mi =

 
     return plugins;
 }
 
 void
-PluginLoader::generateLibraryMap()
+PluginLoader::Impl::generateLibraryMap()
 {
     vector<string> path = PluginHostAdapter::getPluginPath();
 
     for (size_t i = 0; i < path.size(); ++i) {
         

         }
     }
 }
 
 PluginLoader::PluginKey
-PluginLoader::composePluginKey(string libraryName, string identifier)
+PluginLoader::Impl::composePluginKey(string libraryName, string identifier)
 {
     string basename = libraryName;
 
     string::size_type li = basename.rfind('/');
     if (li != string::npos) basename = basename.substr(li + 1);

 
     return basename + ":" + identifier;
 }
 
 PluginLoader::PluginCategoryHierarchy
-PluginLoader::getPluginCategory(PluginKey plugin)
+PluginLoader::Impl::getPluginCategory(PluginKey plugin)
 {
     if (m_taxonomy.empty()) generateTaxonomy();
-    if (m_taxonomy.find(plugin) == m_taxonomy.end()) return PluginCategoryHierarchy();
+    if (m_taxonomy.find(plugin) == m_taxonomy.end()) {
+        return PluginCategoryHierarchy();
+    }
     return m_taxonomy[plugin];
 }
 
 string
-PluginLoader::getLibraryPathForPlugin(PluginKey plugin)
+PluginLoader::Impl::getLibraryPathForPlugin(PluginKey plugin)
 {
     if (m_pluginLibraryNameMap.empty()) generateLibraryMap();
     if (m_pluginLibraryNameMap.find(plugin) == m_pluginLibraryNameMap.end()) return "";
     return m_pluginLibraryNameMap[plugin];
 }    
 
 Plugin *
-PluginLoader::loadPlugin(PluginKey key, float inputSampleRate, int adapterFlags)
+PluginLoader::Impl::loadPlugin(PluginKey key,
+                               float inputSampleRate, int adapterFlags)
 {
     string fullPath = getLibraryPathForPlugin(key);
     if (fullPath == "") return 0;
     
     string::size_type ki = key.find(':');

 
     return 0;
 }
 
 void
-PluginLoader::generateTaxonomy()
-{
-//    cerr << "PluginLoader::generateTaxonomy" << endl;
+PluginLoader::Impl::generateTaxonomy()
+{
+//    cerr << "PluginLoader::Impl::generateTaxonomy" << endl;
 
     vector<string> path = PluginHostAdapter::getPluginPath();
     string libfragment = "/lib/";
     vector<string> catpath;
 

         }
     }
 }    
 
 void *
-PluginLoader::loadLibrary(string path)
+PluginLoader::Impl::loadLibrary(string path)
 {
     void *handle = 0;
 #ifdef _WIN32
     handle = LoadLibrary(path.c_str());
     if (!handle) {

 #endif
     return handle;
 }
 
 void
-PluginLoader::unloadLibrary(void *handle)
+PluginLoader::Impl::unloadLibrary(void *handle)
 {
 #ifdef _WIN32
     FreeLibrary((HINSTANCE)handle);
 #else
     dlclose(handle);
 #endif
 }
 
 void *
-PluginLoader::lookupInLibrary(void *handle, const char *symbol)
+PluginLoader::Impl::lookupInLibrary(void *handle, const char *symbol)
 {
 #ifdef _WIN32
     return (void *)GetProcAddress((HINSTANCE)handle, symbol);
 #else
     return (void *)dlsym(handle, symbol);
 #endif
 }
 
 string
-PluginLoader::splicePath(string a, string b)
+PluginLoader::Impl::splicePath(string a, string b)
 {
 #ifdef _WIN32
     return a + "\\" + b;
 #else
     return a + "/" + b;
 #endif
 }
 
 vector<string>
-PluginLoader::listFiles(string dir, string extension)
+PluginLoader::Impl::listFiles(string dir, string extension)
 {
     vector<string> files;
     size_t extlen = extension.length();
 
 #ifdef _WIN32

 
     return files;
 }
 
 void
-PluginLoader::pluginDeleted(PluginDeletionNotifyAdapter *adapter)
+PluginLoader::Impl::pluginDeleted(PluginDeletionNotifyAdapter *adapter)
 {
     void *handle = m_pluginLibraryHandleMap[adapter];
     if (handle) unloadLibrary(handle);
     m_pluginLibraryHandleMap.erase(adapter);
 }
 
-PluginLoader::PluginDeletionNotifyAdapter::PluginDeletionNotifyAdapter(Plugin *plugin,
-                                                                       PluginLoader *loader) :
+PluginLoader::Impl::PluginDeletionNotifyAdapter::PluginDeletionNotifyAdapter(Plugin *plugin,
+                                                                             Impl *loader) :
     PluginWrapper(plugin),
     m_loader(loader)
 {
 }
 
-PluginLoader::PluginDeletionNotifyAdapter::~PluginDeletionNotifyAdapter()
+PluginLoader::Impl::PluginDeletionNotifyAdapter::~PluginDeletionNotifyAdapter()
 {
     // We need to delete the plugin before calling pluginDeleted, as
     // the delete call may require calling through to the descriptor
     // (for e.g. cleanup) but pluginDeleted may unload the required
     // library for the call.  To prevent a double deletion when our