IComponentManager.h

 
#ifndef COSMO_COMPONENT_MANAGER_INTERFACE_H
#define COSMO_COMPONENT_MANAGER_INTERFACE_H
 
#include <Pt/Cosmo/Api.h>
#include <Pt/Cosmo/IUnknown.h>
#include <Pt/Cosmo/ComponentInfo.h>
#include <Pt/Cosmo/IEnumerable.h>
 
#include <string>
#include <vector>
#include <stdexcept>
 
namespace Pt {
 
namespace Cosmo {
 
class IComponentPlugin;
 
class IComponentManager : public IUnknown
{
  public:
    virtual ~IComponentManager()
    {}
 
    void registerComponent(IComponentPlugin& plugin,
                           const std::string& require,
                           const std::string& instance);
 
    void load();
 
    void load(const std::string& instance);
 
    void unload(IComponentPlugin& plugin);
 
    void unload(const std::string& instanceId);
 
    const IEnumerable<ComponentInfo>& components() const
    {
      return onGetComponents();
    }
 
  protected:
    virtual void onRegisterComponent(IComponentPlugin& plugin,
                                     const std::string& require,
                                     const std::string& instance) = 0;
 
 
    virtual void onLoad() = 0;
 
    virtual void onLoadInstance(const std::string& instanceId) = 0;
 
    virtual void onUnload(IComponentPlugin& plugin) = 0;
 
    virtual IComponentPlugin* onUnloadInstance(const std::string& instanceId) = 0;
 
    virtual const IEnumerable<ComponentInfo>& onGetComponents() const = 0;
};
 
} // namespace Cosmo
 
} // namespace Pt
 
#include <Pt/Cosmo/IComponentPlugin.h>
 
namespace Pt {
 
namespace Cosmo {
 
inline void IComponentManager::registerComponent(IComponentPlugin& plugin,
                                                 const std::string& require,
                                                 const std::string& instance)
{
  plugin.onAttach(*this, instance);
  onRegisterComponent(plugin, require, instance);
}
 
 
inline void IComponentManager::load()
{
  onLoad();
}
 
 
inline void IComponentManager::load(const std::string& instance)
{
  onLoadInstance(instance);
}
 
 
inline void IComponentManager::unload(IComponentPlugin& plugin)
{
  onUnload(plugin);
  plugin.onDetach(*this);
}
 
 
inline void IComponentManager::unload(const std::string& instanceId)
{
  IComponentPlugin* plugin = onUnloadInstance(instanceId);
  if(plugin)
    plugin->onDetach(*this, instanceId);
}
 
} // namespace Cosmo
 
} // namespace Pt
 
#endif