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