E:/dev/eLynx/include/elx/core/PluginManager.h

//============================================================================
//  PluginManager.h                                     Core.Component package
//============================================================================
//  Usage : definition of tool class to manage plugins
//----------------------------------------------------------------------------
//  Inheritance : 
//    PluginManager
//----------------------------------------------------------------------------
//  Copyright (C) 2006 by eLynx project
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Library General Public
//  License as published by the Free Software Foundation; either
//  version 2 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
//  See the GNU Library General Public License for more details.
//----------------------------------------------------------------------------
#ifndef __PluginManager_h__
#define __PluginManager_h__

#include "CoreLib.h"
#include "UUID.h"
#include <vector>
#include <map>

namespace eLynx {

class IPlugin;
class IPluginPackage;
class PluginFile;

class ExportedByCore PluginManager 
{
public:
  PluginManager(const UUID& iFamilyType);

  virtual ~PluginManager();



  bool IsEmpty() const;

  void Register(const char * iprPath, const char * iprExt);

  bool RegisterFile(const char * iprFilename);

  void Unregister();

  bool Unregister(const IPluginPackage * iprPackage);

  bool Unregister(const IPlugin * iprPlugin);

  bool UnregisterPackage(const char * iprFilename);

  bool UnregisterPackage(const UUID& iUUID);

  bool UnregisterPlugin(const char * iprName);

  bool UnregisterPlugin(const UUID& iUUID);



  size_t GetPackageCount() const;

  const IPluginPackage * GetPackage(size_t iIndex=0) const;

  const IPluginPackage * GetPackage(const IPlugin& iPlugin) const;

  const IPluginPackage * GetPackage(const UUID& iUUID, bool ibPlugin=false) const;

  const IPluginPackage * GetPackage(const char * iprName, bool ibPlugin=true) const;

  const IPluginPackage * GetPackageFromPackageID(const UUID& iUUID) const;
  const IPluginPackage * GetPackageFromFilename(const char * iprFilename) const;
  const IPluginPackage * GetPackageFromPluginName(const char * iprName) const;
  const IPluginPackage * GetPackageFromPluginID(const UUID& iUUID) const;




  size_t GetPluginCount() const;

  const IPlugin * GetPlugin(size_t iIndex=0) const;

  const IPlugin * GetPlugin(const UUID& iUUID) const;

  const IPlugin * GetPlugin(const char * iprName) const;

protected:
  static bool FileEnumCallback(const char * iprFilename, void * iprUserData);

  UUID _familyType;                 
  std::vector<PluginFile*> _files;  

  typedef std::map<const IPlugin *, const IPluginPackage *> PluginMap;
  PluginMap _plugins;               

private:
  // useless default methods intentionally not accessible (and not generated)
  PluginManager();
  PluginManager(const PluginManager&);
  PluginManager& operator=(const PluginManager&);
};

} // namespace eLynx

#endif // __PluginManager_h__