ComponentManager.h

 
#ifndef COSMO_COMPONENT_MANAGER_H
#define COSMO_COMPONENT_MANAGER_H
 
#include <Pt/Cosmo/Component.h>
#include <Pt/Cosmo/ComponentPlugin.h>
#include <Pt/Cosmo/IComponentManager.h>
#include <Pt/Cosmo/Enumerable.h>
 
#include <string>
 
namespace Pt {
 
namespace Cosmo {
 
class ComponentInfo;
class IComponentInfo;
 
class PT_COSMO_API ComponentManager : public Component  
{  
  public:
    template <typename I>
    I* getInterface();
 
  public:
    ComponentManager();
 
    ~ComponentManager();
 
    void setModulesDir(const std::string& dir);
 
    void importComponents(const std::string& manifest);
 
    void registerComponent(IComponentPlugin& plugin,
                           const std::string& require,
                           const std::string& instanceId);
 
    void load();
 
    void load(const std::string& instanceId);
 
    void unload(IComponentPlugin& plugin);
 
    void unload(const std::string& instanceId);
 
    const IEnumerable<ComponentInfo>& components() const;
 
  private:
    class ComponentManagerPlugin*  _plugin;
    class ComponentManagerImpl*    _impl;
};
 
class ComponentManagerFactory
{
  public:
    explicit ComponentManagerFactory(ComponentManager& cm)
    : _cm(&cm)
    {}
 
    Component* create()
    { return _cm; }
 
    void destroy(Component* instance)
    { }
 
  private:
    ComponentManager* _cm;
};
 
class ComponentManagerPlugin : public ComponentPlugin<ComponentManager, 
                                                      ComponentManagerFactory>
{
  public:
    static const char* FeatureId()
    { return "Cosmo.ComponentManager"; }
 
    static const char* ClassId()
    { return "Cosmo.ComponentManager"; }
 
    static const char* Info()
    { return "Cosmo.Default"; }
 
  public:
    ComponentManagerPlugin(ComponentManager& cm);
};
 
} // namespace Cosmo
 
} // namespace Pt
 
#endif