As pointed out on irc the template functions fail to compile.

I've removed the method in the base class so remove in OPluginLoader as well

Evaluate if we want to allow loading of a 'path' + QUUid or only via
OPluginItem

1 files changed, 0 insertions, 6 deletions

diff --git a/libopie2/opiecore/opluginloader.h b/libopie2/opiecore/opluginloader.h
index 421d1f6..6166b75 100644
--- a/libopie2/opiecore/opluginloader.h
+++ b/libopie2/opiecore/opluginloader.h
@@ -1,187 +1,181 @@
 /*
  * LGPLv2 or later
  * zecke@handhelds.org
  */
 #ifndef ODP_CORE_OPLUGIN_LOADER_H
 #define ODP_CORE_OPLUGIN_LOADER_H
 
 #include <qpe/qlibrary.h>
 
 #include <qptrdict.h>
 #include <qstringlist.h>
 
 namespace Opie {
 namespace Core {
 class OConfig;
 namespace Internal {
 class OPluginLibraryHolder;
 }
 
 template class QPtrDict<QLibrary>;
 
 /**
  * \brief A small item representing the Plugin Information
  * This class contains the information about a Plugin. It contains
  * a translated name if available to the system, a config key,
  * and the path location.
  *
  * @since 1.2
  *
  */
 class OPluginItem {
 public:
     typedef QValueList<OPluginItem> List;
     OPluginItem();
     OPluginItem( const QString& name, const QString& path, int pos = -1 );
     ~OPluginItem();
 
     bool operator==( const OPluginItem& )const;
     bool operator!=( const OPluginItem& )const;
 
 
     QString  name()const;
     QString  path()const;
     int position()const;
 
     void setName( const QString& );
     void setPath( const QString& );
     void setPosition( int );
 
 private:
     QString m_name;
     QString m_path;
     int m_pos;
     struct Private;
     Private *d;
 };
 
 /**
  * \brief A generic class to easily load and manage plugins
  *
  * This is the generic non sepcialised loader for plugins. Normally
  * you would prefer using the OPluginLoader directly. This class
  * exists to minimize the application binary size due the usage
  * of templates in the specialized API
  *
  * @since 1.2
  * @see OPluginLoader
  */
 class OGenericPluginLoader {
 public:
     typedef OPluginItem::List List;
     OGenericPluginLoader( const QString &name, bool isSorted = false );
     virtual ~OGenericPluginLoader();
 
     void setAutoDelete( bool );
     bool autoDelete()const;
     void clear();
 
 
     bool isInSafeMode()const;
 
 
     List  allAvailable(bool sorted = FALSE)const;
     List  filtered(bool sorted = FALSE)const;
 
 
     virtual QUnknownInterface* load( const OPluginItem& item, const QUuid& );
     virtual void unload( QUnknownInterface* );
 
 protected:
     void readConfig();
     virtual List plugins( const QString& dir, bool sorted, bool disabled )const;
     void setPluginDirs( const QStringList& );
     void setPluginDir( const QString& );
     bool isSorted()const;
     void setSafeMode(const QString& app = QString::null,  bool b = false);
     static QString unlibify( const QString& str );
 
 private:
     QStringList languageList();
     void installTranslators(const QString& type);
     QString m_dir;
     QStringList m_plugDirs;
     QStringList m_languages;
     bool m_autoDelete : 1;
     bool m_isSafeMode : 1;
     bool m_isSorted   : 1;
     QPtrDict<QLibrary> m_library;
 
     struct Private;
     Private* d;
 };
 
 /**
  * \brief The class to load your QCOM+ plugins
  *
  * This class takes care of activation and even the order
  * if you need it. It is normally good to place a .directory file
  * into your plugin directory if you need order of activation.
  *
  * You'll create the OPluginLoader and then use it to load the filtered
  *  plugins.
  *
  * There is also a GUI for the configuration and a Manager to write the
  * mentioned .directory file
  *
  * On crash the safe mode is activated for the next run. You can then decide
  * if you want to load plugins or come up with the  Configuration on
  * next start yourself then.
  *
  * @since 1.2
  */
 class OPluginLoader : public OGenericPluginLoader {
 public:
     OPluginLoader( const QString& name, bool sorted = false );
     ~OPluginLoader();
 
     template<class IFace>
-    IFace* load( const QString& name, const QUuid& );
-    template<class IFace>
     IFace* load( const OPluginItem& item, const QUuid& );
 };
 
 /**
  * \brief A class to manager order and activation of plugins
  *
  * Manage order and activation. This is used by the Opie::Ui::OPluginConfig
  * This class controls the activation and order of plugins depending
  * on the OPluginLoader you supply.
  *
  * @see OPluginConfig
  *
  */
 class OPluginManager {
 public:
     OPluginManager( OGenericPluginLoader* , const QString& name);
     OPluginManager( OConfig* conf, const QString&,
                     const QCString& group, const OPluginItem::List& );
     ~OPluginManager();
 
     QString name();
     void setName( const QString& );
 
     void setPosition( const OPluginItem& );
     void enable( const OPluginItem& );
     void disable( const OPluginItem& );
     void setEnabled( const OPluginItem&, bool = true);
 
     void load();
     void save();
 };
 
-template<class IFace>
-IFace* OPluginLoader::load( const QString& name, const QUuid& uid ) {
-    return static_cast<IFace*>( OGenericPluginLoader::load( item, uid ) );
-}
 
 template<class IFace>
 IFace* OPluginLoader::load( const OPluginItem& item, const QUuid& uid ) {
     return static_cast<IFace*>( OGenericPluginLoader::load( item, uid ) );
 }
 
 }
 }
 
 
 #endif